@wp-playground/storage 0.9.46 → 1.0.0

package/index.js

@@ -1,335 +1,2915 @@
-import { Semaphore as d, normalizePath as g, joinPaths as m } from "@php-wasm/util";
-import { Octokit as b } from "octokit";
-function B(t) {
-  return new b({
-    auth: t
+import { Semaphore as Lt, normalizePath as Mt, joinPaths as Ie } from "@php-wasm/util";
+import { Octokit as _e } from "octokit";
+import Ae from "crc-32";
+import Gt from "pako";
+function jr(n) {
+  return new _e({
+    auth: n
   });
 }
-function H(t, e = "") {
-  e.length && !e.endsWith("/") && (e += "/");
-  const r = {};
-  for (const a of t)
-    a.path.startsWith(e) && (r[a.path.substring(e.length)] = a.content);
-  return r;
+function Lr(n, r = "") {
+  r.length && !r.endsWith("/") && (r += "/");
+  const o = {};
+  for (const s of n)
+    s.path.startsWith(r) && (o[s.path.substring(r.length)] = s.content);
+  return o;
 }
-async function F(t, e, r, a, n, s = {}) {
-  s.progress || (s.progress = {
+async function Fe(n, r, o, s, f, u = {}) {
+  u.progress || (u.progress = {
     foundFiles: 0,
     downloadedFiles: 0
   });
-  const { onProgress: i } = s, o = [], f = [], { data: u } = await t.rest.repos.getContent({
-    owner: e,
-    repo: r,
-    path: n,
-    ref: a
+  const { onProgress: h } = u, c = [], w = [], { data: y } = await n.rest.repos.getContent({
+    owner: r,
+    repo: o,
+    path: f,
+    ref: s
   });
-  if (!Array.isArray(u))
+  if (!Array.isArray(y))
     throw new Error(
-      `Expected the list of files to be an array, but got ${typeof u}`
+      `Expected the list of files to be an array, but got ${typeof y}`
     );
-  for (const c of u)
-    c.type === "file" ? (++s.progress.foundFiles, i == null || i(s.progress), o.push(
-      P(t, e, r, a, c).then((y) => (++s.progress.downloadedFiles, i == null || i(s.progress), y))
-    )) : c.type === "dir" && f.push(
-      F(
-        t,
-        e,
+  for (const b of y)
+    b.type === "file" ? (++u.progress.foundFiles, h == null || h(u.progress), c.push(
+      Se(n, r, o, s, b).then((B) => (++u.progress.downloadedFiles, h == null || h(u.progress), B))
+    )) : b.type === "dir" && w.push(
+      Fe(
+        n,
         r,
-        a,
-        c.path,
-        s
+        o,
+        s,
+        b.path,
+        u
       )
     );
-  const l = await Promise.all(o), p = (await Promise.all(f)).flatMap(
-    (c) => c
+  const g = await Promise.all(c), m = (await Promise.all(w)).flatMap(
+    (b) => b
   );
-  return [...l, ...p];
+  return [...g, ...m];
 }
-const T = new d({ concurrency: 15 });
-async function P(t, e, r, a, n) {
-  const s = await T.acquire();
+const Ue = new Lt({ concurrency: 15 });
+async function Se(n, r, o, s, f) {
+  const u = await Ue.acquire();
   try {
-    const { data: i } = await t.rest.repos.getContent({
-      owner: e,
-      repo: r,
-      ref: a,
-      path: n.path
+    const { data: h } = await n.rest.repos.getContent({
+      owner: r,
+      repo: o,
+      ref: s,
+      path: f.path
     });
-    if (!("content" in i))
-      throw new Error(`No content found for ${n.path}`);
+    if (!("content" in h))
+      throw new Error(`No content found for ${f.path}`);
     return {
-      name: n.name,
-      path: n.path,
-      content: A(i.content)
+      name: f.name,
+      path: f.path,
+      content: ke(h.content)
     };
   } finally {
-    s();
-  }
-}
-function A(t) {
-  const e = window.atob(t), r = e.length, a = new Uint8Array(r);
-  for (let n = 0; n < r; n++)
-    a[n] = e.charCodeAt(n);
-  return a;
-}
-async function M(t, e, r, a, n) {
-  var l;
-  const { data: s } = await t.rest.pulls.get({
-    owner: e,
-    repo: r,
-    pull_number: a
-  }), o = (l = (await t.rest.actions.listWorkflowRuns({
-    owner: e,
-    repo: r,
-    branch: s.head.ref,
-    workflow_id: n
-  })).data.workflow_runs[0]) == null ? void 0 : l.id, f = await t.rest.actions.listWorkflowRunArtifacts({
-    owner: e,
-    repo: r,
-    run_id: o
+    u();
+  }
+}
+function ke(n) {
+  const r = window.atob(n), o = r.length, s = new Uint8Array(o);
+  for (let f = 0; f < o; f++)
+    s[f] = r.charCodeAt(f);
+  return s;
+}
+async function Mr(n, r, o, s, f) {
+  var g;
+  const { data: u } = await n.rest.pulls.get({
+    owner: r,
+    repo: o,
+    pull_number: s
+  }), c = (g = (await n.rest.actions.listWorkflowRuns({
+    owner: r,
+    repo: o,
+    branch: u.head.ref,
+    workflow_id: f
+  })).data.workflow_runs[0]) == null ? void 0 : g.id, w = await n.rest.actions.listWorkflowRunArtifacts({
+    owner: r,
+    repo: o,
+    run_id: c
   });
-  return (await t.rest.actions.downloadArtifact({
-    owner: e,
-    repo: r,
-    artifact_id: f.data.artifacts[0].id,
+  return (await n.rest.actions.downloadArtifact({
+    owner: r,
+    repo: o,
+    artifact_id: w.data.artifacts[0].id,
     archive_format: "zip"
   })).data;
 }
-async function k(t, e, r) {
-  var s;
-  const { data: a, headers: n } = await t.request(
+async function Gr(n, r, o) {
+  var u;
+  const { data: s, headers: f } = await n.request(
     "GET /repos/{owner}/{repo}",
     {
-      owner: e,
-      repo: r
+      owner: r,
+      repo: o
     }
   );
-  return !(!n["x-oauth-scopes"] || !((s = a.permissions) != null && s.push));
+  return !(!f["x-oauth-scopes"] || !((u = s.permissions) != null && u.push));
 }
-async function R(t, e, r, a, n) {
-  await t.request("GET /repos/{owner}/{repo}/branches/{branch}", {
-    owner: e,
-    repo: r,
-    branch: a
+async function Hr(n, r, o, s, f) {
+  await n.request("GET /repos/{owner}/{repo}/branches/{branch}", {
+    owner: r,
+    repo: o,
+    branch: s
   }).then(
     () => !0,
     () => !1
-  ) ? await t.request("PATCH /repos/{owner}/{repo}/git/refs/{ref}", {
-    owner: e,
-    repo: r,
-    sha: n,
-    ref: `heads/${a}`
-  }) : await t.request("POST /repos/{owner}/{repo}/git/refs", {
-    owner: e,
-    repo: r,
-    sha: n,
-    ref: `refs/heads/${a}`
+  ) ? await n.request("PATCH /repos/{owner}/{repo}/git/refs/{ref}", {
+    owner: r,
+    repo: o,
+    sha: f,
+    ref: `heads/${s}`
+  }) : await n.request("POST /repos/{owner}/{repo}/git/refs", {
+    owner: r,
+    repo: o,
+    sha: f,
+    ref: `refs/heads/${s}`
   });
 }
-async function _(t, e, r) {
-  const a = await t.request("GET /user");
-  return (await t.request("GET /repos/{owner}/{repo}/forks", {
-    owner: e,
-    repo: r
+async function qr(n, r, o) {
+  const s = await n.request("GET /user");
+  return (await n.request("GET /repos/{owner}/{repo}/forks", {
+    owner: r,
+    repo: o
   })).data.find(
-    (i) => i.owner && i.owner.login === a.data.login
-  ) || await t.request("POST /repos/{owner}/{repo}/forks", {
-    owner: e,
-    repo: r
-  }), a.data.login;
+    (h) => h.owner && h.owner.login === s.data.login
+  ) || await n.request("POST /repos/{owner}/{repo}/forks", {
+    owner: r,
+    repo: o
+  }), s.data.login;
 }
-async function j(t, e, r, a, n, s) {
+async function vr(n, r, o, s, f, u) {
   const {
-    data: { sha: i }
-  } = await t.request("POST /repos/{owner}/{repo}/git/commits", {
-    owner: e,
-    repo: r,
-    message: a,
-    tree: s,
-    parents: [n]
+    data: { sha: h }
+  } = await n.request("POST /repos/{owner}/{repo}/git/commits", {
+    owner: r,
+    repo: o,
+    message: s,
+    tree: u,
+    parents: [f]
   });
-  return i;
+  return h;
 }
-async function G(t, e, r, a, n) {
-  const s = await q(
-    t,
-    e,
+async function zr(n, r, o, s, f) {
+  const u = await Te(
+    n,
     r,
-    a,
-    n
+    o,
+    s,
+    f
   );
-  if (s.length === 0)
+  if (u.length === 0)
     return null;
   const {
-    data: { sha: i }
-  } = await t.request("POST /repos/{owner}/{repo}/git/trees", {
-    owner: e,
-    repo: r,
-    base_tree: a,
-    tree: s
+    data: { sha: h }
+  } = await n.request("POST /repos/{owner}/{repo}/git/trees", {
+    owner: r,
+    repo: o,
+    base_tree: s,
+    tree: u
   });
-  return i;
-}
-async function q(t, e, r, a, n) {
-  const s = [];
-  for (const [i, o] of n.create)
-    s.push(h(t, e, r, i, o));
-  for (const [i, o] of n.update)
-    s.push(h(t, e, r, i, o));
-  for (const i of n.delete)
-    s.push(E(t, e, r, a, i));
-  return Promise.all(s).then(
-    (i) => i.filter((o) => !!o)
+  return h;
+}
+async function Te(n, r, o, s, f) {
+  const u = [];
+  for (const [h, c] of f.create)
+    u.push(Ct(n, r, o, h, c));
+  for (const [h, c] of f.update)
+    u.push(Ct(n, r, o, h, c));
+  for (const h of f.delete)
+    u.push($e(n, r, o, s, h));
+  return Promise.all(u).then(
+    (h) => h.filter((c) => !!c)
   );
 }
-const w = new d({ concurrency: 10 });
-async function h(t, e, r, a, n) {
-  const s = await w.acquire();
+const Ht = new Lt({ concurrency: 10 });
+async function Ct(n, r, o, s, f) {
+  const u = await Ht.acquire();
   try {
-    if (ArrayBuffer.isView(n))
+    if (ArrayBuffer.isView(f))
       try {
-        const i = new TextDecoder("utf-8", {
+        const h = new TextDecoder("utf-8", {
           fatal: !0
-        }).decode(n);
+        }).decode(f);
         return {
-          path: a,
-          content: i,
+          path: s,
+          content: h,
           mode: "100644"
         };
       } catch {
         const {
-          data: { sha: o }
-        } = await t.rest.git.createBlob({
-          owner: e,
-          repo: r,
+          data: { sha: c }
+        } = await n.rest.git.createBlob({
+          owner: r,
+          repo: o,
           encoding: "base64",
-          content: D(n)
+          content: Re(f)
         });
         return {
-          path: a,
-          sha: o,
+          path: s,
+          sha: c,
           mode: "100644"
         };
       }
     else
       return {
-        path: a,
-        content: n,
+        path: s,
+        content: f,
         mode: "100644"
       };
   } finally {
-    s();
+    u();
   }
 }
-async function E(t, e, r, a, n) {
-  const s = await w.acquire();
+async function $e(n, r, o, s, f) {
+  const u = await Ht.acquire();
   try {
-    return await t.request("HEAD /repos/{owner}/{repo}/contents/:path", {
-      owner: e,
-      repo: r,
-      ref: a,
-      path: n
+    return await n.request("HEAD /repos/{owner}/{repo}/contents/:path", {
+      owner: r,
+      repo: o,
+      ref: s,
+      path: f
     }), {
-      path: n,
+      path: f,
       mode: "100644",
       sha: null
     };
   } catch {
     return;
   } finally {
-    s();
+    u();
   }
 }
-function D(t) {
-  const e = [], r = t.byteLength;
-  for (let a = 0; a < r; a++)
-    e.push(String.fromCharCode(t[a]));
-  return window.btoa(e.join(""));
+function Re(n) {
+  const r = [], o = n.byteLength;
+  for (let s = 0; s < o; s++)
+    r.push(String.fromCharCode(n[s]));
+  return window.btoa(r.join(""));
 }
-async function* N(t, e, { exceptPaths: r = [] } = {}) {
-  if (e = g(e), !await t.isDir(e)) {
-    await t.fileExists(e) && (yield {
-      path: e,
-      read: async () => await t.readFileAsBuffer(e)
+async function* Wr(n, r, { exceptPaths: o = [] } = {}) {
+  if (r = Mt(r), !await n.isDir(r)) {
+    await n.fileExists(r) && (yield {
+      path: r,
+      read: async () => await n.readFileAsBuffer(r)
     });
     return;
   }
-  const a = [e];
-  for (; a.length; ) {
-    const n = a.pop();
-    if (!n)
+  const s = [r];
+  for (; s.length; ) {
+    const f = s.pop();
+    if (!f)
       return;
-    const s = await t.listFiles(n);
-    for (const i of s) {
-      const o = m(n, i);
-      r.includes(o.substring(e.length + 1)) || (await t.isDir(o) ? a.push(o) : yield {
-        path: o,
-        read: async () => await t.readFileAsBuffer(o)
+    const u = await n.listFiles(f);
+    for (const h of u) {
+      const c = Ie(f, h);
+      o.includes(c.substring(r.length + 1)) || (await n.isDir(c) ? s.push(c) : yield {
+        path: c,
+        read: async () => await n.readFileAsBuffer(c)
       });
     }
   }
 }
-async function U(t, e) {
-  const r = {
+async function Yr(n, r) {
+  const o = {
     create: /* @__PURE__ */ new Map(),
     update: /* @__PURE__ */ new Map(),
     delete: /* @__PURE__ */ new Set()
-  }, a = /* @__PURE__ */ new Set();
-  for await (const n of e) {
-    a.add(n.path);
-    const s = t.get(n.path), i = await n.read();
-    s ? C(s, i) || r.update.set(n.path, i) : r.create.set(n.path, i);
-  }
-  for (const n of t.keys())
-    a.has(n) || r.delete.add(n);
-  return r;
+  }, s = /* @__PURE__ */ new Set();
+  for await (const f of r) {
+    s.add(f.path);
+    const u = n.get(f.path), h = await f.read();
+    u ? Ce(u, h) || o.update.set(f.path, h) : o.create.set(f.path, h);
+  }
+  for (const f of n.keys())
+    s.has(f) || o.delete.add(f);
+  return o;
 }
-function C(t, e) {
-  return t.length === e.length && t.every((r, a) => r === e[a]);
+function Ce(n, r) {
+  return n.length === r.length && n.every((o, s) => o === r[s]);
 }
-async function S(t) {
-  return t.type === "local-fs" ? t.handle : O(t.path);
+async function Oe(n) {
+  return n.type === "local-fs" ? n.handle : Pe(n.path);
 }
-async function O(t) {
-  const e = t.split("/").filter((a) => a.length > 0);
-  let r = await navigator.storage.getDirectory();
-  for (const a of e)
-    r = await r.getDirectoryHandle(a, { create: !0 });
-  return r;
+async function Pe(n) {
+  const r = n.split("/").filter((s) => s.length > 0);
+  let o = await navigator.storage.getDirectory();
+  for (const s of r)
+    o = await o.getDirectoryHandle(s, { create: !0 });
+  return o;
 }
-async function W(t) {
-  const r = await (await navigator.storage.getDirectory()).resolve(t);
-  if (r === null)
+async function Vr(n) {
+  const o = await (await navigator.storage.getDirectory()).resolve(n);
+  if (o === null)
     throw new DOMException(
       "Unable to resolve path of OPFS directory handle.",
       "NotFoundError"
     );
-  return "/" + r.join("/");
+  return "/" + o.join("/");
 }
-async function $(t) {
-  const e = await S(t);
-  for await (const r of e.keys())
-    await e.removeEntry(r, {
+async function Kr(n) {
+  const r = await Oe(n);
+  for await (const o of r.keys())
+    await r.removeEntry(o, {
       recursive: !0
     });
 }
+function De(n) {
+  let r = [n];
+  return {
+    next() {
+      return Promise.resolve({ done: r.length === 0, value: r.pop() });
+    },
+    return() {
+      return r = [], {};
+    },
+    [Symbol.asyncIterator]() {
+      return this;
+    }
+  };
+}
+function qt(n) {
+  return n[Symbol.asyncIterator] ? n[Symbol.asyncIterator]() : n[Symbol.iterator] ? n[Symbol.iterator]() : n.next ? n : De(n);
+}
+class vt {
+  constructor(r) {
+    if (typeof Buffer > "u")
+      throw new Error("Missing Buffer dependency");
+    this.stream = qt(r), this.buffer = null, this.cursor = 0, this.undoCursor = 0, this.started = !1, this._ended = !1, this._discardedBytes = 0;
+  }
+  eof() {
+    return this._ended && this.cursor === this.buffer.length;
+  }
+  tell() {
+    return this._discardedBytes + this.cursor;
+  }
+  async byte() {
+    if (!this.eof() && (this.started || await this._init(), !(this.cursor === this.buffer.length && (await this._loadnext(), this._ended))))
+      return this._moveCursor(1), this.buffer[this.undoCursor];
+  }
+  async chunk() {
+    if (!this.eof() && (this.started || await this._init(), !(this.cursor === this.buffer.length && (await this._loadnext(), this._ended))))
+      return this._moveCursor(this.buffer.length), this.buffer.slice(this.undoCursor, this.cursor);
+  }
+  async read(r) {
+    if (!this.eof())
+      return this.started || await this._init(), this.cursor + r > this.buffer.length && (this._trim(), await this._accumulate(r)), this._moveCursor(r), this.buffer.slice(this.undoCursor, this.cursor);
+  }
+  async skip(r) {
+    this.eof() || (this.started || await this._init(), this.cursor + r > this.buffer.length && (this._trim(), await this._accumulate(r)), this._moveCursor(r));
+  }
+  async undo() {
+    this.cursor = this.undoCursor;
+  }
+  async _next() {
+    this.started = !0;
+    let { done: r, value: o } = await this.stream.next();
+    return r && (this._ended = !0, !o) ? Buffer.alloc(0) : (o && (o = Buffer.from(o)), o);
+  }
+  _trim() {
+    this.buffer = this.buffer.slice(this.undoCursor), this.cursor -= this.undoCursor, this._discardedBytes += this.undoCursor, this.undoCursor = 0;
+  }
+  _moveCursor(r) {
+    this.undoCursor = this.cursor, this.cursor += r, this.cursor > this.buffer.length && (this.cursor = this.buffer.length);
+  }
+  async _accumulate(r) {
+    if (this._ended)
+      return;
+    const o = [this.buffer];
+    for (; this.cursor + r > Ne(o); ) {
+      const s = await this._next();
+      if (this._ended)
+        break;
+      o.push(s);
+    }
+    this.buffer = Buffer.concat(o);
+  }
+  async _loadnext() {
+    this._discardedBytes += this.buffer.length, this.undoCursor = 0, this.cursor = 0, this.buffer = await this._next();
+  }
+  async _init() {
+    this.buffer = await this._next();
+  }
+}
+function Ne(n) {
+  return n.reduce((r, o) => r + o.length, 0);
+}
+function je(n, r) {
+  const o = r.toString(16);
+  return "0".repeat(n - o.length) + o;
+}
+class k {
+  static flush() {
+    return Buffer.from("0000", "utf8");
+  }
+  static delim() {
+    return Buffer.from("0001", "utf8");
+  }
+  static encode(r) {
+    typeof r == "string" && (r = Buffer.from(r));
+    const o = r.length + 4, s = je(4, o);
+    return Buffer.concat([Buffer.from(s, "utf8"), r]);
+  }
+  static streamReader(r) {
+    const o = new vt(r);
+    return async function() {
+      try {
+        let f = await o.read(4);
+        if (f == null)
+          return !0;
+        if (f = parseInt(f.toString("utf8"), 16), f === 0 || f === 1)
+          return null;
+        const u = await o.read(f - 4);
+        return u ?? !0;
+      } catch (f) {
+        return r.error = f, !0;
+      }
+    };
+  }
+}
+class J extends Error {
+  constructor(r) {
+    super(r), this.caller = "";
+  }
+  toJSON() {
+    return {
+      code: this.code,
+      data: this.data,
+      caller: this.caller,
+      message: this.message,
+      stack: this.stack
+    };
+  }
+  fromJSON(r) {
+    const o = new J(r.message);
+    return o.code = r.code, o.data = r.data, o.caller = r.caller, o.stack = r.stack, o;
+  }
+  get isIsomorphicGitError() {
+    return !0;
+  }
+}
+class _ extends J {
+  /**
+   * @param {string} message
+   */
+  constructor(r) {
+    super(
+      `An internal error caused this command to fail. Please file a bug report at https://github.com/isomorphic-git/isomorphic-git/issues with this error message: ${r}`
+    ), this.code = this.name = _.code, this.data = { message: r };
+  }
+}
+_.code = "InternalError";
+class ot extends J {
+  /**
+   * @param {string} filepath
+   */
+  constructor(r) {
+    super(`The filepath "${r}" contains unsafe character sequences`), this.code = this.name = ot.code, this.data = { filepath: r };
+  }
+}
+ot.code = "UnsafeFilepathError";
+function zt(n, r) {
+  return -(n < r) || +(n > r);
+}
+function Le(n, r) {
+  return zt(n.path, r.path);
+}
+function Me(n, r) {
+  return zt(Ot(n), Ot(r));
+}
+function Ot(n) {
+  return n.mode === "040000" ? n.path + "/" : n.path;
+}
+function Wt(n) {
+  switch (n) {
+    case "040000":
+      return "tree";
+    case "100644":
+      return "blob";
+    case "100755":
+      return "blob";
+    case "120000":
+      return "blob";
+    case "160000":
+      return "commit";
+  }
+  throw new _(`Unexpected GitTree entry mode: ${n}`);
+}
+function Ge(n) {
+  const r = [];
+  let o = 0;
+  for (; o < n.length; ) {
+    const s = n.indexOf(32, o);
+    if (s === -1)
+      throw new _(
+        `GitTree: Error parsing buffer at byte location ${o}: Could not find the next space character.`
+      );
+    const f = n.indexOf(0, o);
+    if (f === -1)
+      throw new _(
+        `GitTree: Error parsing buffer at byte location ${o}: Could not find the next null character.`
+      );
+    let u = n.slice(o, s).toString("utf8");
+    u === "40000" && (u = "040000");
+    const h = Wt(u), c = n.slice(s + 1, f).toString("utf8");
+    if (c.includes("\\") || c.includes("/"))
+      throw new ot(c);
+    const w = n.slice(f + 1, f + 21).toString("hex");
+    o = f + 21, r.push({ mode: u, path: c, oid: w, type: h });
+  }
+  return r;
+}
+function He(n) {
+  if (typeof n == "number" && (n = n.toString(8)), n.match(/^0?4.*/))
+    return "040000";
+  if (n.match(/^1006.*/))
+    return "100644";
+  if (n.match(/^1007.*/))
+    return "100755";
+  if (n.match(/^120.*/))
+    return "120000";
+  if (n.match(/^160.*/))
+    return "160000";
+  throw new _(`Could not understand file mode: ${n}`);
+}
+function qe(n) {
+  return !n.oid && n.sha && (n.oid = n.sha), n.mode = He(n.mode), n.type || (n.type = Wt(n.mode)), n;
+}
+class bt {
+  constructor(r) {
+    if (Buffer.isBuffer(r))
+      this._entries = Ge(r);
+    else if (Array.isArray(r))
+      this._entries = r.map(qe);
+    else
+      throw new _("invalid type passed to GitTree constructor");
+    this._entries.sort(Le);
+  }
+  static from(r) {
+    return new bt(r);
+  }
+  render() {
+    return this._entries.map((r) => `${r.mode} ${r.type} ${r.oid}    ${r.path}`).join(`
+`);
+  }
+  toObject() {
+    const r = [...this._entries];
+    return r.sort(Me), Buffer.concat(
+      r.map((o) => {
+        const s = Buffer.from(o.mode.replace(/^0/, "")), f = Buffer.from(" "), u = Buffer.from(o.path, "utf8"), h = Buffer.from([0]), c = Buffer.from(o.oid, "hex");
+        return Buffer.concat([s, f, u, h, c]);
+      })
+    );
+  }
+  /**
+   * @returns {TreeEntry[]}
+   */
+  entries() {
+    return this._entries;
+  }
+  *[Symbol.iterator]() {
+    for (const r of this._entries)
+      yield r;
+  }
+}
+function yt({ name: n, email: r, timestamp: o, timezoneOffset: s }) {
+  return s = ve(s), `${n} <${r}> ${o} ${s}`;
+}
+function ve(n) {
+  const r = ze(We(n));
+  n = Math.abs(n);
+  const o = Math.floor(n / 60);
+  n -= o * 60;
+  let s = String(o), f = String(n);
+  return s.length < 2 && (s = "0" + s), f.length < 2 && (f = "0" + f), (r === -1 ? "-" : "+") + s + f;
+}
+function ze(n) {
+  return Math.sign(n) || (Object.is(n, -0) ? -1 : 1);
+}
+function We(n) {
+  return n === 0 ? n : -n;
+}
+function H(n) {
+  return n = n.replace(/\r/g, ""), n = n.replace(/^\n+/, ""), n = n.replace(/\n+$/, "") + `
+`, n;
+}
+function it(n) {
+  const [, r, o, s, f] = n.match(
+    /^(.*) <(.*)> (.*) (.*)$/
+  );
+  return {
+    name: r,
+    email: o,
+    timestamp: Number(s),
+    timezoneOffset: Ye(f)
+  };
+}
+function Ye(n) {
+  let [, r, o, s] = n.match(/(\+|-)(\d\d)(\d\d)/);
+  return s = (r === "+" ? 1 : -1) * (Number(o) * 60 + Number(s)), Ve(s);
+}
+function Ve(n) {
+  return n === 0 ? n : -n;
+}
+class Z {
+  constructor(r) {
+    if (typeof r == "string")
+      this._tag = r;
+    else if (Buffer.isBuffer(r))
+      this._tag = r.toString("utf8");
+    else if (typeof r == "object")
+      this._tag = Z.render(r);
+    else
+      throw new _(
+        "invalid type passed to GitAnnotatedTag constructor"
+      );
+  }
+  static from(r) {
+    return new Z(r);
+  }
+  static render(r) {
+    return `object ${r.object}
+type ${r.type}
+tag ${r.tag}
+tagger ${yt(r.tagger)}
+
+${r.message}
+${r.gpgsig ? r.gpgsig : ""}`;
+  }
+  justHeaders() {
+    return this._tag.slice(0, this._tag.indexOf(`
+
+`));
+  }
+  message() {
+    const r = this.withoutSignature();
+    return r.slice(r.indexOf(`
+
+`) + 2);
+  }
+  parse() {
+    return Object.assign(this.headers(), {
+      message: this.message(),
+      gpgsig: this.gpgsig()
+    });
+  }
+  render() {
+    return this._tag;
+  }
+  headers() {
+    const r = this.justHeaders().split(`
+`), o = [];
+    for (const f of r)
+      f[0] === " " ? o[o.length - 1] += `
+` + f.slice(1) : o.push(f);
+    const s = {};
+    for (const f of o) {
+      const u = f.slice(0, f.indexOf(" ")), h = f.slice(f.indexOf(" ") + 1);
+      Array.isArray(s[u]) ? s[u].push(h) : s[u] = h;
+    }
+    return s.tagger && (s.tagger = it(s.tagger)), s.committer && (s.committer = it(s.committer)), s;
+  }
+  withoutSignature() {
+    const r = H(this._tag);
+    return r.indexOf(`
+-----BEGIN PGP SIGNATURE-----`) === -1 ? r : r.slice(0, r.lastIndexOf(`
+-----BEGIN PGP SIGNATURE-----`));
+  }
+  gpgsig() {
+    if (this._tag.indexOf(`
+-----BEGIN PGP SIGNATURE-----`) === -1)
+      return;
+    const r = this._tag.slice(
+      this._tag.indexOf("-----BEGIN PGP SIGNATURE-----"),
+      this._tag.indexOf("-----END PGP SIGNATURE-----") + 27
+    );
+    return H(r);
+  }
+  payload() {
+    return this.withoutSignature() + `
+`;
+  }
+  toObject() {
+    return Buffer.from(this._tag, "utf8");
+  }
+  static async sign(r, o, s) {
+    const f = r.payload();
+    let { signature: u } = await o({ payload: f, secretKey: s });
+    u = H(u);
+    const h = f + u;
+    return Z.from(h);
+  }
+}
+function lt(n) {
+  return n.trim().split(`
+`).map((r) => " " + r).join(`
+`) + `
+`;
+}
+function Ke(n) {
+  return n.split(`
+`).map((r) => r.replace(/^ /, "")).join(`
+`);
+}
+class O {
+  constructor(r) {
+    if (typeof r == "string")
+      this._commit = r;
+    else if (Buffer.isBuffer(r))
+      this._commit = r.toString("utf8");
+    else if (typeof r == "object")
+      this._commit = O.render(r);
+    else
+      throw new _("invalid type passed to GitCommit constructor");
+  }
+  static fromPayloadSignature({ payload: r, signature: o }) {
+    const s = O.justHeaders(r), f = O.justMessage(r), u = H(
+      s + `
+gpgsig` + lt(o) + `
+` + f
+    );
+    return new O(u);
+  }
+  static from(r) {
+    return new O(r);
+  }
+  toObject() {
+    return Buffer.from(this._commit, "utf8");
+  }
+  // Todo: allow setting the headers and message
+  headers() {
+    return this.parseHeaders();
+  }
+  // Todo: allow setting the headers and message
+  message() {
+    return O.justMessage(this._commit);
+  }
+  parse() {
+    return Object.assign({ message: this.message() }, this.headers());
+  }
+  static justMessage(r) {
+    return H(r.slice(r.indexOf(`
+
+`) + 2));
+  }
+  static justHeaders(r) {
+    return r.slice(0, r.indexOf(`
+
+`));
+  }
+  parseHeaders() {
+    const r = O.justHeaders(this._commit).split(`
+`), o = [];
+    for (const f of r)
+      f[0] === " " ? o[o.length - 1] += `
+` + f.slice(1) : o.push(f);
+    const s = {
+      parent: []
+    };
+    for (const f of o) {
+      const u = f.slice(0, f.indexOf(" ")), h = f.slice(f.indexOf(" ") + 1);
+      Array.isArray(s[u]) ? s[u].push(h) : s[u] = h;
+    }
+    return s.author && (s.author = it(s.author)), s.committer && (s.committer = it(s.committer)), s;
+  }
+  static renderHeaders(r) {
+    let o = "";
+    if (r.tree ? o += `tree ${r.tree}
+` : o += `tree 4b825dc642cb6eb9a060e54bf8d69288fbee4904
+`, r.parent) {
+      if (r.parent.length === void 0)
+        throw new _("commit 'parent' property should be an array");
+      for (const u of r.parent)
+        o += `parent ${u}
+`;
+    }
+    const s = r.author;
+    o += `author ${yt(s)}
+`;
+    const f = r.committer || r.author;
+    return o += `committer ${yt(f)}
+`, r.gpgsig && (o += "gpgsig" + lt(r.gpgsig)), o;
+  }
+  static render(r) {
+    return O.renderHeaders(r) + `
+` + H(r.message);
+  }
+  render() {
+    return this._commit;
+  }
+  withoutSignature() {
+    const r = H(this._commit);
+    if (r.indexOf(`
+gpgsig`) === -1)
+      return r;
+    const o = r.slice(0, r.indexOf(`
+gpgsig`)), s = r.slice(
+      r.indexOf(`-----END PGP SIGNATURE-----
+`) + 28
+    );
+    return H(o + `
+` + s);
+  }
+  isolateSignature() {
+    const r = this._commit.slice(
+      this._commit.indexOf("-----BEGIN PGP SIGNATURE-----"),
+      this._commit.indexOf("-----END PGP SIGNATURE-----") + 27
+    );
+    return Ke(r);
+  }
+  static async sign(r, o, s) {
+    const f = r.withoutSignature(), u = O.justMessage(r._commit);
+    let { signature: h } = await o({ payload: f, secretKey: s });
+    h = H(h);
+    const w = O.justHeaders(r._commit) + `
+gpgsig` + lt(h) + `
+` + u;
+    return O.from(w);
+  }
+}
+class Je {
+  static wrap({ type: r, object: o }) {
+    return Buffer.concat([
+      Buffer.from(`${r} ${o.byteLength.toString()}\0`),
+      Buffer.from(o)
+    ]);
+  }
+  static unwrap(r) {
+    const o = r.indexOf(32), s = r.indexOf(0), f = r.slice(0, o).toString("utf8"), u = r.slice(o + 1, s).toString("utf8"), h = r.length - (s + 1);
+    if (parseInt(u) !== h)
+      throw new _(
+        `Length mismatch: expected ${u} bytes but got ${h} instead.`
+      );
+    return {
+      type: f,
+      object: Buffer.from(r.slice(s + 1))
+    };
+  }
+}
+class z {
+  constructor(r) {
+    this.buffer = r, this._start = 0;
+  }
+  eof() {
+    return this._start >= this.buffer.length;
+  }
+  tell() {
+    return this._start;
+  }
+  seek(r) {
+    this._start = r;
+  }
+  slice(r) {
+    const o = this.buffer.slice(this._start, this._start + r);
+    return this._start += r, o;
+  }
+  toString(r, o) {
+    const s = this.buffer.toString(r, this._start, this._start + o);
+    return this._start += o, s;
+  }
+  write(r, o, s) {
+    const f = this.buffer.write(r, this._start, o, s);
+    return this._start += o, f;
+  }
+  copy(r, o, s) {
+    const f = r.copy(this.buffer, this._start, o, s);
+    return this._start += f, f;
+  }
+  readUInt8() {
+    const r = this.buffer.readUInt8(this._start);
+    return this._start += 1, r;
+  }
+  writeUInt8(r) {
+    const o = this.buffer.writeUInt8(r, this._start);
+    return this._start += 1, o;
+  }
+  readUInt16BE() {
+    const r = this.buffer.readUInt16BE(this._start);
+    return this._start += 2, r;
+  }
+  writeUInt16BE(r) {
+    const o = this.buffer.writeUInt16BE(r, this._start);
+    return this._start += 2, o;
+  }
+  readUInt32BE() {
+    const r = this.buffer.readUInt32BE(this._start);
+    return this._start += 4, r;
+  }
+  writeUInt32BE(r) {
+    const o = this.buffer.writeUInt32BE(r, this._start);
+    return this._start += 4, o;
+  }
+}
+function Xe(n, r) {
+  const o = new z(n), s = Pt(o);
+  if (s !== r.byteLength)
+    throw new _(
+      `applyDelta expected source buffer to be ${s} bytes but the provided buffer was ${r.length} bytes`
+    );
+  const f = Pt(o);
+  let u;
+  const h = Nt(o, r);
+  if (h.byteLength === f)
+    u = h;
+  else {
+    u = Buffer.alloc(f);
+    const c = new z(u);
+    for (c.copy(h); !o.eof(); )
+      c.copy(Nt(o, r));
+    const w = c.tell();
+    if (f !== w)
+      throw new _(
+        `applyDelta expected target buffer to be ${f} bytes but the resulting buffer was ${w} bytes`
+      );
+  }
+  return u;
+}
+function Pt(n) {
+  let r = 0, o = 0, s = null;
+  do
+    s = n.readUInt8(), r |= (s & 127) << o, o += 7;
+  while (s & 128);
+  return r;
+}
+function Dt(n, r, o) {
+  let s = 0, f = 0;
+  for (; o--; )
+    r & 1 && (s |= n.readUInt8() << f), r >>= 1, f += 8;
+  return s;
+}
+function Nt(n, r) {
+  const o = n.readUInt8(), s = 128, f = 15, u = 112;
+  if (o & s) {
+    const h = Dt(n, o & f, 4);
+    let c = Dt(n, (o & u) >> 4, 3);
+    return c === 0 && (c = 65536), r.slice(h, h + c);
+  } else
+    return n.slice(o);
+}
+async function Ze(n, r) {
+  const o = new vt(n);
+  let s = await o.read(4);
+  if (s = s.toString("utf8"), s !== "PACK")
+    throw new _(`Invalid PACK header '${s}'`);
+  let f = await o.read(4);
+  if (f = f.readUInt32BE(0), f !== 2)
+    throw new _(`Invalid packfile version: ${f}`);
+  let u = await o.read(4);
+  if (u = u.readUInt32BE(0), !(u < 1))
+    for (; !o.eof() && u--; ) {
+      const h = o.tell(), { type: c, length: w, ofs: y, reference: g } = await Qe(o), m = new Gt.Inflate();
+      for (; !m.result; ) {
+        const b = await o.chunk();
+        if (!b)
+          break;
+        if (m.push(b, !1), m.err)
+          throw new _(`Pako error: ${m.msg}`);
+        if (m.result) {
+          if (m.result.length !== w)
+            throw new _(
+              "Inflated object size is different from that stated in packfile."
+            );
+          await o.undo(), await o.read(b.length - m.strm.avail_in);
+          const B = o.tell();
+          await r({
+            data: m.result,
+            type: c,
+            num: u,
+            offset: h,
+            end: B,
+            reference: g,
+            ofs: y
+          });
+        }
+      }
+    }
+}
+async function Qe(n) {
+  let r = await n.byte();
+  const o = r >> 4 & 7;
+  let s = r & 15;
+  if (r & 128) {
+    let h = 4;
+    do
+      r = await n.byte(), s |= (r & 127) << h, h += 7;
+    while (r & 128);
+  }
+  let f, u;
+  if (o === 6) {
+    let h = 0;
+    f = 0;
+    const c = [];
+    do
+      r = await n.byte(), f |= (r & 127) << h, h += 7, c.push(r);
+    while (r & 128);
+    u = Buffer.from(c);
+  }
+  return o === 7 && (u = await n.read(20)), { type: o, length: s, ofs: f, reference: u };
+}
+let tr = !1;
+async function er(n) {
+  return tr ? rr(n) : Gt.inflate(n);
+}
+async function rr(n) {
+  const r = new DecompressionStream("deflate"), o = new Blob([n]).stream().pipeThrough(r);
+  return new Uint8Array(await new Response(o).arrayBuffer());
+}
+function nr(n) {
+  return n && n.__esModule && Object.prototype.hasOwnProperty.call(n, "default") ? n.default : n;
+}
+var gt = { exports: {} };
+typeof Object.create == "function" ? gt.exports = function(r, o) {
+  o && (r.super_ = o, r.prototype = Object.create(o.prototype, {
+    constructor: {
+      value: r,
+      enumerable: !1,
+      writable: !0,
+      configurable: !0
+    }
+  }));
+} : gt.exports = function(r, o) {
+  if (o) {
+    r.super_ = o;
+    var s = function() {
+    };
+    s.prototype = o.prototype, r.prototype = new s(), r.prototype.constructor = r;
+  }
+};
+var ir = gt.exports, mt = { exports: {} }, q = {}, st = {};
+st.byteLength = ar;
+st.toByteArray = fr;
+st.fromByteArray = lr;
+var j = [], P = [], or = typeof Uint8Array < "u" ? Uint8Array : Array, pt = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+for (var K = 0, sr = pt.length; K < sr; ++K)
+  j[K] = pt[K], P[pt.charCodeAt(K)] = K;
+P["-".charCodeAt(0)] = 62;
+P["_".charCodeAt(0)] = 63;
+function Yt(n) {
+  var r = n.length;
+  if (r % 4 > 0)
+    throw new Error("Invalid string. Length must be a multiple of 4");
+  var o = n.indexOf("=");
+  o === -1 && (o = r);
+  var s = o === r ? 0 : 4 - o % 4;
+  return [o, s];
+}
+function ar(n) {
+  var r = Yt(n), o = r[0], s = r[1];
+  return (o + s) * 3 / 4 - s;
+}
+function cr(n, r, o) {
+  return (r + o) * 3 / 4 - o;
+}
+function fr(n) {
+  var r, o = Yt(n), s = o[0], f = o[1], u = new or(cr(n, s, f)), h = 0, c = f > 0 ? s - 4 : s, w;
+  for (w = 0; w < c; w += 4)
+    r = P[n.charCodeAt(w)] << 18 | P[n.charCodeAt(w + 1)] << 12 | P[n.charCodeAt(w + 2)] << 6 | P[n.charCodeAt(w + 3)], u[h++] = r >> 16 & 255, u[h++] = r >> 8 & 255, u[h++] = r & 255;
+  return f === 2 && (r = P[n.charCodeAt(w)] << 2 | P[n.charCodeAt(w + 1)] >> 4, u[h++] = r & 255), f === 1 && (r = P[n.charCodeAt(w)] << 10 | P[n.charCodeAt(w + 1)] << 4 | P[n.charCodeAt(w + 2)] >> 2, u[h++] = r >> 8 & 255, u[h++] = r & 255), u;
+}
+function ur(n) {
+  return j[n >> 18 & 63] + j[n >> 12 & 63] + j[n >> 6 & 63] + j[n & 63];
+}
+function hr(n, r, o) {
+  for (var s, f = [], u = r; u < o; u += 3)
+    s = (n[u] << 16 & 16711680) + (n[u + 1] << 8 & 65280) + (n[u + 2] & 255), f.push(ur(s));
+  return f.join("");
+}
+function lr(n) {
+  for (var r, o = n.length, s = o % 3, f = [], u = 16383, h = 0, c = o - s; h < c; h += u)
+    f.push(hr(n, h, h + u > c ? c : h + u));
+  return s === 1 ? (r = n[o - 1], f.push(
+    j[r >> 2] + j[r << 4 & 63] + "=="
+  )) : s === 2 && (r = (n[o - 2] << 8) + n[o - 1], f.push(
+    j[r >> 10] + j[r >> 4 & 63] + j[r << 2 & 63] + "="
+  )), f.join("");
+}
+var xt = {};
+/*! ieee754. BSD-3-Clause License. Feross Aboukhadijeh <https://feross.org/opensource> */
+xt.read = function(n, r, o, s, f) {
+  var u, h, c = f * 8 - s - 1, w = (1 << c) - 1, y = w >> 1, g = -7, m = o ? f - 1 : 0, b = o ? -1 : 1, B = n[r + m];
+  for (m += b, u = B & (1 << -g) - 1, B >>= -g, g += c; g > 0; u = u * 256 + n[r + m], m += b, g -= 8)
+    ;
+  for (h = u & (1 << -g) - 1, u >>= -g, g += s; g > 0; h = h * 256 + n[r + m], m += b, g -= 8)
+    ;
+  if (u === 0)
+    u = 1 - y;
+  else {
+    if (u === w)
+      return h ? NaN : (B ? -1 : 1) * (1 / 0);
+    h = h + Math.pow(2, s), u = u - y;
+  }
+  return (B ? -1 : 1) * h * Math.pow(2, u - s);
+};
+xt.write = function(n, r, o, s, f, u) {
+  var h, c, w, y = u * 8 - f - 1, g = (1 << y) - 1, m = g >> 1, b = f === 23 ? Math.pow(2, -24) - Math.pow(2, -77) : 0, B = s ? 0 : u - 1, T = s ? 1 : -1, L = r < 0 || r === 0 && 1 / r < 0 ? 1 : 0;
+  for (r = Math.abs(r), isNaN(r) || r === 1 / 0 ? (c = isNaN(r) ? 1 : 0, h = g) : (h = Math.floor(Math.log(r) / Math.LN2), r * (w = Math.pow(2, -h)) < 1 && (h--, w *= 2), h + m >= 1 ? r += b / w : r += b * Math.pow(2, 1 - m), r * w >= 2 && (h++, w /= 2), h + m >= g ? (c = 0, h = g) : h + m >= 1 ? (c = (r * w - 1) * Math.pow(2, f), h = h + m) : (c = r * Math.pow(2, m - 1) * Math.pow(2, f), h = 0)); f >= 8; n[o + B] = c & 255, B += T, c /= 256, f -= 8)
+    ;
+  for (h = h << f | c, y += f; y > 0; n[o + B] = h & 255, B += T, h /= 256, y -= 8)
+    ;
+  n[o + B - T] |= L * 128;
+};
+/*!
+ * The buffer module from node.js, for the browser.
+ *
+ * @author   Feross Aboukhadijeh <https://feross.org>
+ * @license  MIT
+ */
+(function(n) {
+  const r = st, o = xt, s = typeof Symbol == "function" && typeof Symbol.for == "function" ? Symbol.for("nodejs.util.inspect.custom") : null;
+  n.Buffer = c, n.SlowBuffer = M, n.INSPECT_MAX_BYTES = 50;
+  const f = 2147483647;
+  n.kMaxLength = f, c.TYPED_ARRAY_SUPPORT = u(), !c.TYPED_ARRAY_SUPPORT && typeof console < "u" && typeof console.error == "function" && console.error(
+    "This browser lacks typed array (Uint8Array) support which is required by `buffer` v5.x. Use `buffer` v4.x if you require old browser support."
+  );
+  function u() {
+    try {
+      const i = new Uint8Array(1), t = { foo: function() {
+        return 42;
+      } };
+      return Object.setPrototypeOf(t, Uint8Array.prototype), Object.setPrototypeOf(i, t), i.foo() === 42;
+    } catch {
+      return !1;
+    }
+  }
+  Object.defineProperty(c.prototype, "parent", {
+    enumerable: !0,
+    get: function() {
+      if (c.isBuffer(this))
+        return this.buffer;
+    }
+  }), Object.defineProperty(c.prototype, "offset", {
+    enumerable: !0,
+    get: function() {
+      if (c.isBuffer(this))
+        return this.byteOffset;
+    }
+  });
+  function h(i) {
+    if (i > f)
+      throw new RangeError('The value "' + i + '" is invalid for option "size"');
+    const t = new Uint8Array(i);
+    return Object.setPrototypeOf(t, c.prototype), t;
+  }
+  function c(i, t, e) {
+    if (typeof i == "number") {
+      if (typeof t == "string")
+        throw new TypeError(
+          'The "string" argument must be of type string. Received type number'
+        );
+      return m(i);
+    }
+    return w(i, t, e);
+  }
+  c.poolSize = 8192;
+  function w(i, t, e) {
+    if (typeof i == "string")
+      return b(i, t);
+    if (ArrayBuffer.isView(i))
+      return T(i);
+    if (i == null)
+      throw new TypeError(
+        "The first argument must be one of type string, Buffer, ArrayBuffer, Array, or Array-like Object. Received type " + typeof i
+      );
+    if (N(i, ArrayBuffer) || i && N(i.buffer, ArrayBuffer) || typeof SharedArrayBuffer < "u" && (N(i, SharedArrayBuffer) || i && N(i.buffer, SharedArrayBuffer)))
+      return L(i, t, e);
+    if (typeof i == "number")
+      throw new TypeError(
+        'The "value" argument must not be of type number. Received type number'
+      );
+    const a = i.valueOf && i.valueOf();
+    if (a != null && a !== i)
+      return c.from(a, t, e);
+    const l = D(i);
+    if (l)
+      return l;
+    if (typeof Symbol < "u" && Symbol.toPrimitive != null && typeof i[Symbol.toPrimitive] == "function")
+      return c.from(i[Symbol.toPrimitive]("string"), t, e);
+    throw new TypeError(
+      "The first argument must be one of type string, Buffer, ArrayBuffer, Array, or Array-like Object. Received type " + typeof i
+    );
+  }
+  c.from = function(i, t, e) {
+    return w(i, t, e);
+  }, Object.setPrototypeOf(c.prototype, Uint8Array.prototype), Object.setPrototypeOf(c, Uint8Array);
+  function y(i) {
+    if (typeof i != "number")
+      throw new TypeError('"size" argument must be of type number');
+    if (i < 0)
+      throw new RangeError('The value "' + i + '" is invalid for option "size"');
+  }
+  function g(i, t, e) {
+    return y(i), i <= 0 ? h(i) : t !== void 0 ? typeof e == "string" ? h(i).fill(t, e) : h(i).fill(t) : h(i);
+  }
+  c.alloc = function(i, t, e) {
+    return g(i, t, e);
+  };
+  function m(i) {
+    return y(i), h(i < 0 ? 0 : U(i) | 0);
+  }
+  c.allocUnsafe = function(i) {
+    return m(i);
+  }, c.allocUnsafeSlow = function(i) {
+    return m(i);
+  };
+  function b(i, t) {
+    if ((typeof t != "string" || t === "") && (t = "utf8"), !c.isEncoding(t))
+      throw new TypeError("Unknown encoding: " + t);
+    const e = $(i, t) | 0;
+    let a = h(e);
+    const l = a.write(i, t);
+    return l !== e && (a = a.slice(0, l)), a;
+  }
+  function B(i) {
+    const t = i.length < 0 ? 0 : U(i.length) | 0, e = h(t);
+    for (let a = 0; a < t; a += 1)
+      e[a] = i[a] & 255;
+    return e;
+  }
+  function T(i) {
+    if (N(i, Uint8Array)) {
+      const t = new Uint8Array(i);
+      return L(t.buffer, t.byteOffset, t.byteLength);
+    }
+    return B(i);
+  }
+  function L(i, t, e) {
+    if (t < 0 || i.byteLength < t)
+      throw new RangeError('"offset" is outside of buffer bounds');
+    if (i.byteLength < t + (e || 0))
+      throw new RangeError('"length" is outside of buffer bounds');
+    let a;
+    return t === void 0 && e === void 0 ? a = new Uint8Array(i) : e === void 0 ? a = new Uint8Array(i, t) : a = new Uint8Array(i, t, e), Object.setPrototypeOf(a, c.prototype), a;
+  }
+  function D(i) {
+    if (c.isBuffer(i)) {
+      const t = U(i.length) | 0, e = h(t);
+      return e.length === 0 || i.copy(e, 0, 0, t), e;
+    }
+    if (i.length !== void 0)
+      return typeof i.length != "number" || ht(i.length) ? h(0) : B(i);
+    if (i.type === "Buffer" && Array.isArray(i.data))
+      return B(i.data);
+  }
+  function U(i) {
+    if (i >= f)
+      throw new RangeError("Attempt to allocate Buffer larger than maximum size: 0x" + f.toString(16) + " bytes");
+    return i | 0;
+  }
+  function M(i) {
+    return +i != i && (i = 0), c.alloc(+i);
+  }
+  c.isBuffer = function(t) {
+    return t != null && t._isBuffer === !0 && t !== c.prototype;
+  }, c.compare = function(t, e) {
+    if (N(t, Uint8Array) && (t = c.from(t, t.offset, t.byteLength)), N(e, Uint8Array) && (e = c.from(e, e.offset, e.byteLength)), !c.isBuffer(t) || !c.isBuffer(e))
+      throw new TypeError(
+        'The "buf1", "buf2" arguments must be one of type Buffer or Uint8Array'
+      );
+    if (t === e)
+      return 0;
+    let a = t.length, l = e.length;
+    for (let p = 0, d = Math.min(a, l); p < d; ++p)
+      if (t[p] !== e[p]) {
+        a = t[p], l = e[p];
+        break;
+      }
+    return a < l ? -1 : l < a ? 1 : 0;
+  }, c.isEncoding = function(t) {
+    switch (String(t).toLowerCase()) {
+      case "hex":
+      case "utf8":
+      case "utf-8":
+      case "ascii":
+      case "latin1":
+      case "binary":
+      case "base64":
+      case "ucs2":
+      case "ucs-2":
+      case "utf16le":
+      case "utf-16le":
+        return !0;
+      default:
+        return !1;
+    }
+  }, c.concat = function(t, e) {
+    if (!Array.isArray(t))
+      throw new TypeError('"list" argument must be an Array of Buffers');
+    if (t.length === 0)
+      return c.alloc(0);
+    let a;
+    if (e === void 0)
+      for (e = 0, a = 0; a < t.length; ++a)
+        e += t[a].length;
+    const l = c.allocUnsafe(e);
+    let p = 0;
+    for (a = 0; a < t.length; ++a) {
+      let d = t[a];
+      if (N(d, Uint8Array))
+        p + d.length > l.length ? (c.isBuffer(d) || (d = c.from(d)), d.copy(l, p)) : Uint8Array.prototype.set.call(
+          l,
+          d,
+          p
+        );
+      else if (c.isBuffer(d))
+        d.copy(l, p);
+      else
+        throw new TypeError('"list" argument must be an Array of Buffers');
+      p += d.length;
+    }
+    return l;
+  };
+  function $(i, t) {
+    if (c.isBuffer(i))
+      return i.length;
+    if (ArrayBuffer.isView(i) || N(i, ArrayBuffer))
+      return i.byteLength;
+    if (typeof i != "string")
+      throw new TypeError(
+        'The "string" argument must be one of type string, Buffer, or ArrayBuffer. Received type ' + typeof i
+      );
+    const e = i.length, a = arguments.length > 2 && arguments[2] === !0;
+    if (!a && e === 0)
+      return 0;
+    let l = !1;
+    for (; ; )
+      switch (t) {
+        case "ascii":
+        case "latin1":
+        case "binary":
+          return e;
+        case "utf8":
+        case "utf-8":
+          return ut(i).length;
+        case "ucs2":
+        case "ucs-2":
+        case "utf16le":
+        case "utf-16le":
+          return e * 2;
+        case "hex":
+          return e >>> 1;
+        case "base64":
+          return Rt(i).length;
+        default:
+          if (l)
+            return a ? -1 : ut(i).length;
+          t = ("" + t).toLowerCase(), l = !0;
+      }
+  }
+  c.byteLength = $;
+  function G(i, t, e) {
+    let a = !1;
+    if ((t === void 0 || t < 0) && (t = 0), t > this.length || ((e === void 0 || e > this.length) && (e = this.length), e <= 0) || (e >>>= 0, t >>>= 0, e <= t))
+      return "";
+    for (i || (i = "utf8"); ; )
+      switch (i) {
+        case "hex":
+          return de(this, t, e);
+        case "utf8":
+        case "utf-8":
+          return It(this, t, e);
+        case "ascii":
+          return le(this, t, e);
+        case "latin1":
+        case "binary":
+          return pe(this, t, e);
+        case "base64":
+          return ue(this, t, e);
+        case "ucs2":
+        case "ucs-2":
+        case "utf16le":
+        case "utf-16le":
+          return we(this, t, e);
+        default:
+          if (a)
+            throw new TypeError("Unknown encoding: " + i);
+          i = (i + "").toLowerCase(), a = !0;
+      }
+  }
+  c.prototype._isBuffer = !0;
+  function R(i, t, e) {
+    const a = i[t];
+    i[t] = i[e], i[e] = a;
+  }
+  c.prototype.swap16 = function() {
+    const t = this.length;
+    if (t % 2 !== 0)
+      throw new RangeError("Buffer size must be a multiple of 16-bits");
+    for (let e = 0; e < t; e += 2)
+      R(this, e, e + 1);
+    return this;
+  }, c.prototype.swap32 = function() {
+    const t = this.length;
+    if (t % 4 !== 0)
+      throw new RangeError("Buffer size must be a multiple of 32-bits");
+    for (let e = 0; e < t; e += 4)
+      R(this, e, e + 3), R(this, e + 1, e + 2);
+    return this;
+  }, c.prototype.swap64 = function() {
+    const t = this.length;
+    if (t % 8 !== 0)
+      throw new RangeError("Buffer size must be a multiple of 64-bits");
+    for (let e = 0; e < t; e += 8)
+      R(this, e, e + 7), R(this, e + 1, e + 6), R(this, e + 2, e + 5), R(this, e + 3, e + 4);
+    return this;
+  }, c.prototype.toString = function() {
+    const t = this.length;
+    return t === 0 ? "" : arguments.length === 0 ? It(this, 0, t) : G.apply(this, arguments);
+  }, c.prototype.toLocaleString = c.prototype.toString, c.prototype.equals = function(t) {
+    if (!c.isBuffer(t))
+      throw new TypeError("Argument must be a Buffer");
+    return this === t ? !0 : c.compare(this, t) === 0;
+  }, c.prototype.inspect = function() {
+    let t = "";
+    const e = n.INSPECT_MAX_BYTES;
+    return t = this.toString("hex", 0, e).replace(/(.{2})/g, "$1 ").trim(), this.length > e && (t += " ... "), "<Buffer " + t + ">";
+  }, s && (c.prototype[s] = c.prototype.inspect), c.prototype.compare = function(t, e, a, l, p) {
+    if (N(t, Uint8Array) && (t = c.from(t, t.offset, t.byteLength)), !c.isBuffer(t))
+      throw new TypeError(
+        'The "target" argument must be one of type Buffer or Uint8Array. Received type ' + typeof t
+      );
+    if (e === void 0 && (e = 0), a === void 0 && (a = t ? t.length : 0), l === void 0 && (l = 0), p === void 0 && (p = this.length), e < 0 || a > t.length || l < 0 || p > this.length)
+      throw new RangeError("out of range index");
+    if (l >= p && e >= a)
+      return 0;
+    if (l >= p)
+      return -1;
+    if (e >= a)
+      return 1;
+    if (e >>>= 0, a >>>= 0, l >>>= 0, p >>>= 0, this === t)
+      return 0;
+    let d = p - l, x = a - e;
+    const A = Math.min(d, x), I = this.slice(l, p), F = t.slice(e, a);
+    for (let E = 0; E < A; ++E)
+      if (I[E] !== F[E]) {
+        d = I[E], x = F[E];
+        break;
+      }
+    return d < x ? -1 : x < d ? 1 : 0;
+  };
+  function Bt(i, t, e, a, l) {
+    if (i.length === 0)
+      return -1;
+    if (typeof e == "string" ? (a = e, e = 0) : e > 2147483647 ? e = 2147483647 : e < -2147483648 && (e = -2147483648), e = +e, ht(e) && (e = l ? 0 : i.length - 1), e < 0 && (e = i.length + e), e >= i.length) {
+      if (l)
+        return -1;
+      e = i.length - 1;
+    } else if (e < 0)
+      if (l)
+        e = 0;
+      else
+        return -1;
+    if (typeof t == "string" && (t = c.from(t, a)), c.isBuffer(t))
+      return t.length === 0 ? -1 : Et(i, t, e, a, l);
+    if (typeof t == "number")
+      return t = t & 255, typeof Uint8Array.prototype.indexOf == "function" ? l ? Uint8Array.prototype.indexOf.call(i, t, e) : Uint8Array.prototype.lastIndexOf.call(i, t, e) : Et(i, [t], e, a, l);
+    throw new TypeError("val must be string, number or Buffer");
+  }
+  function Et(i, t, e, a, l) {
+    let p = 1, d = i.length, x = t.length;
+    if (a !== void 0 && (a = String(a).toLowerCase(), a === "ucs2" || a === "ucs-2" || a === "utf16le" || a === "utf-16le")) {
+      if (i.length < 2 || t.length < 2)
+        return -1;
+      p = 2, d /= 2, x /= 2, e /= 2;
+    }
+    function A(F, E) {
+      return p === 1 ? F[E] : F.readUInt16BE(E * p);
+    }
+    let I;
+    if (l) {
+      let F = -1;
+      for (I = e; I < d; I++)
+        if (A(i, I) === A(t, F === -1 ? 0 : I - F)) {
+          if (F === -1 && (F = I), I - F + 1 === x)
+            return F * p;
+        } else
+          F !== -1 && (I -= I - F), F = -1;
+    } else
+      for (e + x > d && (e = d - x), I = e; I >= 0; I--) {
+        let F = !0;
+        for (let E = 0; E < x; E++)
+          if (A(i, I + E) !== A(t, E)) {
+            F = !1;
+            break;
+          }
+        if (F)
+          return I;
+      }
+    return -1;
+  }
+  c.prototype.includes = function(t, e, a) {
+    return this.indexOf(t, e, a) !== -1;
+  }, c.prototype.indexOf = function(t, e, a) {
+    return Bt(this, t, e, a, !0);
+  }, c.prototype.lastIndexOf = function(t, e, a) {
+    return Bt(this, t, e, a, !1);
+  };
+  function oe(i, t, e, a) {
+    e = Number(e) || 0;
+    const l = i.length - e;
+    a ? (a = Number(a), a > l && (a = l)) : a = l;
+    const p = t.length;
+    a > p / 2 && (a = p / 2);
+    let d;
+    for (d = 0; d < a; ++d) {
+      const x = parseInt(t.substr(d * 2, 2), 16);
+      if (ht(x))
+        return d;
+      i[e + d] = x;
+    }
+    return d;
+  }
+  function se(i, t, e, a) {
+    return nt(ut(t, i.length - e), i, e, a);
+  }
+  function ae(i, t, e, a) {
+    return nt(be(t), i, e, a);
+  }
+  function ce(i, t, e, a) {
+    return nt(Rt(t), i, e, a);
+  }
+  function fe(i, t, e, a) {
+    return nt(xe(t, i.length - e), i, e, a);
+  }
+  c.prototype.write = function(t, e, a, l) {
+    if (e === void 0)
+      l = "utf8", a = this.length, e = 0;
+    else if (a === void 0 && typeof e == "string")
+      l = e, a = this.length, e = 0;
+    else if (isFinite(e))
+      e = e >>> 0, isFinite(a) ? (a = a >>> 0, l === void 0 && (l = "utf8")) : (l = a, a = void 0);
+    else
+      throw new Error(
+        "Buffer.write(string, encoding, offset[, length]) is no longer supported"
+      );
+    const p = this.length - e;
+    if ((a === void 0 || a > p) && (a = p), t.length > 0 && (a < 0 || e < 0) || e > this.length)
+      throw new RangeError("Attempt to write outside buffer bounds");
+    l || (l = "utf8");
+    let d = !1;
+    for (; ; )
+      switch (l) {
+        case "hex":
+          return oe(this, t, e, a);
+        case "utf8":
+        case "utf-8":
+          return se(this, t, e, a);
+        case "ascii":
+        case "latin1":
+        case "binary":
+          return ae(this, t, e, a);
+        case "base64":
+          return ce(this, t, e, a);
+        case "ucs2":
+        case "ucs-2":
+        case "utf16le":
+        case "utf-16le":
+          return fe(this, t, e, a);
+        default:
+          if (d)
+            throw new TypeError("Unknown encoding: " + l);
+          l = ("" + l).toLowerCase(), d = !0;
+      }
+  }, c.prototype.toJSON = function() {
+    return {
+      type: "Buffer",
+      data: Array.prototype.slice.call(this._arr || this, 0)
+    };
+  };
+  function ue(i, t, e) {
+    return t === 0 && e === i.length ? r.fromByteArray(i) : r.fromByteArray(i.slice(t, e));
+  }
+  function It(i, t, e) {
+    e = Math.min(i.length, e);
+    const a = [];
+    let l = t;
+    for (; l < e; ) {
+      const p = i[l];
+      let d = null, x = p > 239 ? 4 : p > 223 ? 3 : p > 191 ? 2 : 1;
+      if (l + x <= e) {
+        let A, I, F, E;
+        switch (x) {
+          case 1:
+            p < 128 && (d = p);
+            break;
+          case 2:
+            A = i[l + 1], (A & 192) === 128 && (E = (p & 31) << 6 | A & 63, E > 127 && (d = E));
+            break;
+          case 3:
+            A = i[l + 1], I = i[l + 2], (A & 192) === 128 && (I & 192) === 128 && (E = (p & 15) << 12 | (A & 63) << 6 | I & 63, E > 2047 && (E < 55296 || E > 57343) && (d = E));
+            break;
+          case 4:
+            A = i[l + 1], I = i[l + 2], F = i[l + 3], (A & 192) === 128 && (I & 192) === 128 && (F & 192) === 128 && (E = (p & 15) << 18 | (A & 63) << 12 | (I & 63) << 6 | F & 63, E > 65535 && E < 1114112 && (d = E));
+        }
+      }
+      d === null ? (d = 65533, x = 1) : d > 65535 && (d -= 65536, a.push(d >>> 10 & 1023 | 55296), d = 56320 | d & 1023), a.push(d), l += x;
+    }
+    return he(a);
+  }
+  const _t = 4096;
+  function he(i) {
+    const t = i.length;
+    if (t <= _t)
+      return String.fromCharCode.apply(String, i);
+    let e = "", a = 0;
+    for (; a < t; )
+      e += String.fromCharCode.apply(
+        String,
+        i.slice(a, a += _t)
+      );
+    return e;
+  }
+  function le(i, t, e) {
+    let a = "";
+    e = Math.min(i.length, e);
+    for (let l = t; l < e; ++l)
+      a += String.fromCharCode(i[l] & 127);
+    return a;
+  }
+  function pe(i, t, e) {
+    let a = "";
+    e = Math.min(i.length, e);
+    for (let l = t; l < e; ++l)
+      a += String.fromCharCode(i[l]);
+    return a;
+  }
+  function de(i, t, e) {
+    const a = i.length;
+    (!t || t < 0) && (t = 0), (!e || e < 0 || e > a) && (e = a);
+    let l = "";
+    for (let p = t; p < e; ++p)
+      l += Be[i[p]];
+    return l;
+  }
+  function we(i, t, e) {
+    const a = i.slice(t, e);
+    let l = "";
+    for (let p = 0; p < a.length - 1; p += 2)
+      l += String.fromCharCode(a[p] + a[p + 1] * 256);
+    return l;
+  }
+  c.prototype.slice = function(t, e) {
+    const a = this.length;
+    t = ~~t, e = e === void 0 ? a : ~~e, t < 0 ? (t += a, t < 0 && (t = 0)) : t > a && (t = a), e < 0 ? (e += a, e < 0 && (e = 0)) : e > a && (e = a), e < t && (e = t);
+    const l = this.subarray(t, e);
+    return Object.setPrototypeOf(l, c.prototype), l;
+  };
+  function S(i, t, e) {
+    if (i % 1 !== 0 || i < 0)
+      throw new RangeError("offset is not uint");
+    if (i + t > e)
+      throw new RangeError("Trying to access beyond buffer length");
+  }
+  c.prototype.readUintLE = c.prototype.readUIntLE = function(t, e, a) {
+    t = t >>> 0, e = e >>> 0, a || S(t, e, this.length);
+    let l = this[t], p = 1, d = 0;
+    for (; ++d < e && (p *= 256); )
+      l += this[t + d] * p;
+    return l;
+  }, c.prototype.readUintBE = c.prototype.readUIntBE = function(t, e, a) {
+    t = t >>> 0, e = e >>> 0, a || S(t, e, this.length);
+    let l = this[t + --e], p = 1;
+    for (; e > 0 && (p *= 256); )
+      l += this[t + --e] * p;
+    return l;
+  }, c.prototype.readUint8 = c.prototype.readUInt8 = function(t, e) {
+    return t = t >>> 0, e || S(t, 1, this.length), this[t];
+  }, c.prototype.readUint16LE = c.prototype.readUInt16LE = function(t, e) {
+    return t = t >>> 0, e || S(t, 2, this.length), this[t] | this[t + 1] << 8;
+  }, c.prototype.readUint16BE = c.prototype.readUInt16BE = function(t, e) {
+    return t = t >>> 0, e || S(t, 2, this.length), this[t] << 8 | this[t + 1];
+  }, c.prototype.readUint32LE = c.prototype.readUInt32LE = function(t, e) {
+    return t = t >>> 0, e || S(t, 4, this.length), (this[t] | this[t + 1] << 8 | this[t + 2] << 16) + this[t + 3] * 16777216;
+  }, c.prototype.readUint32BE = c.prototype.readUInt32BE = function(t, e) {
+    return t = t >>> 0, e || S(t, 4, this.length), this[t] * 16777216 + (this[t + 1] << 16 | this[t + 2] << 8 | this[t + 3]);
+  }, c.prototype.readBigUInt64LE = v(function(t) {
+    t = t >>> 0, V(t, "offset");
+    const e = this[t], a = this[t + 7];
+    (e === void 0 || a === void 0) && X(t, this.length - 8);
+    const l = e + this[++t] * 2 ** 8 + this[++t] * 2 ** 16 + this[++t] * 2 ** 24, p = this[++t] + this[++t] * 2 ** 8 + this[++t] * 2 ** 16 + a * 2 ** 24;
+    return BigInt(l) + (BigInt(p) << BigInt(32));
+  }), c.prototype.readBigUInt64BE = v(function(t) {
+    t = t >>> 0, V(t, "offset");
+    const e = this[t], a = this[t + 7];
+    (e === void 0 || a === void 0) && X(t, this.length - 8);
+    const l = e * 2 ** 24 + this[++t] * 2 ** 16 + this[++t] * 2 ** 8 + this[++t], p = this[++t] * 2 ** 24 + this[++t] * 2 ** 16 + this[++t] * 2 ** 8 + a;
+    return (BigInt(l) << BigInt(32)) + BigInt(p);
+  }), c.prototype.readIntLE = function(t, e, a) {
+    t = t >>> 0, e = e >>> 0, a || S(t, e, this.length);
+    let l = this[t], p = 1, d = 0;
+    for (; ++d < e && (p *= 256); )
+      l += this[t + d] * p;
+    return p *= 128, l >= p && (l -= Math.pow(2, 8 * e)), l;
+  }, c.prototype.readIntBE = function(t, e, a) {
+    t = t >>> 0, e = e >>> 0, a || S(t, e, this.length);
+    let l = e, p = 1, d = this[t + --l];
+    for (; l > 0 && (p *= 256); )
+      d += this[t + --l] * p;
+    return p *= 128, d >= p && (d -= Math.pow(2, 8 * e)), d;
+  }, c.prototype.readInt8 = function(t, e) {
+    return t = t >>> 0, e || S(t, 1, this.length), this[t] & 128 ? (255 - this[t] + 1) * -1 : this[t];
+  }, c.prototype.readInt16LE = function(t, e) {
+    t = t >>> 0, e || S(t, 2, this.length);
+    const a = this[t] | this[t + 1] << 8;
+    return a & 32768 ? a | 4294901760 : a;
+  }, c.prototype.readInt16BE = function(t, e) {
+    t = t >>> 0, e || S(t, 2, this.length);
+    const a = this[t + 1] | this[t] << 8;
+    return a & 32768 ? a | 4294901760 : a;
+  }, c.prototype.readInt32LE = function(t, e) {
+    return t = t >>> 0, e || S(t, 4, this.length), this[t] | this[t + 1] << 8 | this[t + 2] << 16 | this[t + 3] << 24;
+  }, c.prototype.readInt32BE = function(t, e) {
+    return t = t >>> 0, e || S(t, 4, this.length), this[t] << 24 | this[t + 1] << 16 | this[t + 2] << 8 | this[t + 3];
+  }, c.prototype.readBigInt64LE = v(function(t) {
+    t = t >>> 0, V(t, "offset");
+    const e = this[t], a = this[t + 7];
+    (e === void 0 || a === void 0) && X(t, this.length - 8);
+    const l = this[t + 4] + this[t + 5] * 2 ** 8 + this[t + 6] * 2 ** 16 + (a << 24);
+    return (BigInt(l) << BigInt(32)) + BigInt(e + this[++t] * 2 ** 8 + this[++t] * 2 ** 16 + this[++t] * 2 ** 24);
+  }), c.prototype.readBigInt64BE = v(function(t) {
+    t = t >>> 0, V(t, "offset");
+    const e = this[t], a = this[t + 7];
+    (e === void 0 || a === void 0) && X(t, this.length - 8);
+    const l = (e << 24) + // Overflow
+    this[++t] * 2 ** 16 + this[++t] * 2 ** 8 + this[++t];
+    return (BigInt(l) << BigInt(32)) + BigInt(this[++t] * 2 ** 24 + this[++t] * 2 ** 16 + this[++t] * 2 ** 8 + a);
+  }), c.prototype.readFloatLE = function(t, e) {
+    return t = t >>> 0, e || S(t, 4, this.length), o.read(this, t, !0, 23, 4);
+  }, c.prototype.readFloatBE = function(t, e) {
+    return t = t >>> 0, e || S(t, 4, this.length), o.read(this, t, !1, 23, 4);
+  }, c.prototype.readDoubleLE = function(t, e) {
+    return t = t >>> 0, e || S(t, 8, this.length), o.read(this, t, !0, 52, 8);
+  }, c.prototype.readDoubleBE = function(t, e) {
+    return t = t >>> 0, e || S(t, 8, this.length), o.read(this, t, !1, 52, 8);
+  };
+  function C(i, t, e, a, l, p) {
+    if (!c.isBuffer(i))
+      throw new TypeError('"buffer" argument must be a Buffer instance');
+    if (t > l || t < p)
+      throw new RangeError('"value" argument is out of bounds');
+    if (e + a > i.length)
+      throw new RangeError("Index out of range");
+  }
+  c.prototype.writeUintLE = c.prototype.writeUIntLE = function(t, e, a, l) {
+    if (t = +t, e = e >>> 0, a = a >>> 0, !l) {
+      const x = Math.pow(2, 8 * a) - 1;
+      C(this, t, e, a, x, 0);
+    }
+    let p = 1, d = 0;
+    for (this[e] = t & 255; ++d < a && (p *= 256); )
+      this[e + d] = t / p & 255;
+    return e + a;
+  }, c.prototype.writeUintBE = c.prototype.writeUIntBE = function(t, e, a, l) {
+    if (t = +t, e = e >>> 0, a = a >>> 0, !l) {
+      const x = Math.pow(2, 8 * a) - 1;
+      C(this, t, e, a, x, 0);
+    }
+    let p = a - 1, d = 1;
+    for (this[e + p] = t & 255; --p >= 0 && (d *= 256); )
+      this[e + p] = t / d & 255;
+    return e + a;
+  }, c.prototype.writeUint8 = c.prototype.writeUInt8 = function(t, e, a) {
+    return t = +t, e = e >>> 0, a || C(this, t, e, 1, 255, 0), this[e] = t & 255, e + 1;
+  }, c.prototype.writeUint16LE = c.prototype.writeUInt16LE = function(t, e, a) {
+    return t = +t, e = e >>> 0, a || C(this, t, e, 2, 65535, 0), this[e] = t & 255, this[e + 1] = t >>> 8, e + 2;
+  }, c.prototype.writeUint16BE = c.prototype.writeUInt16BE = function(t, e, a) {
+    return t = +t, e = e >>> 0, a || C(this, t, e, 2, 65535, 0), this[e] = t >>> 8, this[e + 1] = t & 255, e + 2;
+  }, c.prototype.writeUint32LE = c.prototype.writeUInt32LE = function(t, e, a) {
+    return t = +t, e = e >>> 0, a || C(this, t, e, 4, 4294967295, 0), this[e + 3] = t >>> 24, this[e + 2] = t >>> 16, this[e + 1] = t >>> 8, this[e] = t & 255, e + 4;
+  }, c.prototype.writeUint32BE = c.prototype.writeUInt32BE = function(t, e, a) {
+    return t = +t, e = e >>> 0, a || C(this, t, e, 4, 4294967295, 0), this[e] = t >>> 24, this[e + 1] = t >>> 16, this[e + 2] = t >>> 8, this[e + 3] = t & 255, e + 4;
+  };
+  function At(i, t, e, a, l) {
+    $t(t, a, l, i, e, 7);
+    let p = Number(t & BigInt(4294967295));
+    i[e++] = p, p = p >> 8, i[e++] = p, p = p >> 8, i[e++] = p, p = p >> 8, i[e++] = p;
+    let d = Number(t >> BigInt(32) & BigInt(4294967295));
+    return i[e++] = d, d = d >> 8, i[e++] = d, d = d >> 8, i[e++] = d, d = d >> 8, i[e++] = d, e;
+  }
+  function Ft(i, t, e, a, l) {
+    $t(t, a, l, i, e, 7);
+    let p = Number(t & BigInt(4294967295));
+    i[e + 7] = p, p = p >> 8, i[e + 6] = p, p = p >> 8, i[e + 5] = p, p = p >> 8, i[e + 4] = p;
+    let d = Number(t >> BigInt(32) & BigInt(4294967295));
+    return i[e + 3] = d, d = d >> 8, i[e + 2] = d, d = d >> 8, i[e + 1] = d, d = d >> 8, i[e] = d, e + 8;
+  }
+  c.prototype.writeBigUInt64LE = v(function(t, e = 0) {
+    return At(this, t, e, BigInt(0), BigInt("0xffffffffffffffff"));
+  }), c.prototype.writeBigUInt64BE = v(function(t, e = 0) {
+    return Ft(this, t, e, BigInt(0), BigInt("0xffffffffffffffff"));
+  }), c.prototype.writeIntLE = function(t, e, a, l) {
+    if (t = +t, e = e >>> 0, !l) {
+      const A = Math.pow(2, 8 * a - 1);
+      C(this, t, e, a, A - 1, -A);
+    }
+    let p = 0, d = 1, x = 0;
+    for (this[e] = t & 255; ++p < a && (d *= 256); )
+      t < 0 && x === 0 && this[e + p - 1] !== 0 && (x = 1), this[e + p] = (t / d >> 0) - x & 255;
+    return e + a;
+  }, c.prototype.writeIntBE = function(t, e, a, l) {
+    if (t = +t, e = e >>> 0, !l) {
+      const A = Math.pow(2, 8 * a - 1);
+      C(this, t, e, a, A - 1, -A);
+    }
+    let p = a - 1, d = 1, x = 0;
+    for (this[e + p] = t & 255; --p >= 0 && (d *= 256); )
+      t < 0 && x === 0 && this[e + p + 1] !== 0 && (x = 1), this[e + p] = (t / d >> 0) - x & 255;
+    return e + a;
+  }, c.prototype.writeInt8 = function(t, e, a) {
+    return t = +t, e = e >>> 0, a || C(this, t, e, 1, 127, -128), t < 0 && (t = 255 + t + 1), this[e] = t & 255, e + 1;
+  }, c.prototype.writeInt16LE = function(t, e, a) {
+    return t = +t, e = e >>> 0, a || C(this, t, e, 2, 32767, -32768), this[e] = t & 255, this[e + 1] = t >>> 8, e + 2;
+  }, c.prototype.writeInt16BE = function(t, e, a) {
+    return t = +t, e = e >>> 0, a || C(this, t, e, 2, 32767, -32768), this[e] = t >>> 8, this[e + 1] = t & 255, e + 2;
+  }, c.prototype.writeInt32LE = function(t, e, a) {
+    return t = +t, e = e >>> 0, a || C(this, t, e, 4, 2147483647, -2147483648), this[e] = t & 255, this[e + 1] = t >>> 8, this[e + 2] = t >>> 16, this[e + 3] = t >>> 24, e + 4;
+  }, c.prototype.writeInt32BE = function(t, e, a) {
+    return t = +t, e = e >>> 0, a || C(this, t, e, 4, 2147483647, -2147483648), t < 0 && (t = 4294967295 + t + 1), this[e] = t >>> 24, this[e + 1] = t >>> 16, this[e + 2] = t >>> 8, this[e + 3] = t & 255, e + 4;
+  }, c.prototype.writeBigInt64LE = v(function(t, e = 0) {
+    return At(this, t, e, -BigInt("0x8000000000000000"), BigInt("0x7fffffffffffffff"));
+  }), c.prototype.writeBigInt64BE = v(function(t, e = 0) {
+    return Ft(this, t, e, -BigInt("0x8000000000000000"), BigInt("0x7fffffffffffffff"));
+  });
+  function Ut(i, t, e, a, l, p) {
+    if (e + a > i.length)
+      throw new RangeError("Index out of range");
+    if (e < 0)
+      throw new RangeError("Index out of range");
+  }
+  function St(i, t, e, a, l) {
+    return t = +t, e = e >>> 0, l || Ut(i, t, e, 4), o.write(i, t, e, a, 23, 4), e + 4;
+  }
+  c.prototype.writeFloatLE = function(t, e, a) {
+    return St(this, t, e, !0, a);
+  }, c.prototype.writeFloatBE = function(t, e, a) {
+    return St(this, t, e, !1, a);
+  };
+  function kt(i, t, e, a, l) {
+    return t = +t, e = e >>> 0, l || Ut(i, t, e, 8), o.write(i, t, e, a, 52, 8), e + 8;
+  }
+  c.prototype.writeDoubleLE = function(t, e, a) {
+    return kt(this, t, e, !0, a);
+  }, c.prototype.writeDoubleBE = function(t, e, a) {
+    return kt(this, t, e, !1, a);
+  }, c.prototype.copy = function(t, e, a, l) {
+    if (!c.isBuffer(t))
+      throw new TypeError("argument should be a Buffer");
+    if (a || (a = 0), !l && l !== 0 && (l = this.length), e >= t.length && (e = t.length), e || (e = 0), l > 0 && l < a && (l = a), l === a || t.length === 0 || this.length === 0)
+      return 0;
+    if (e < 0)
+      throw new RangeError("targetStart out of bounds");
+    if (a < 0 || a >= this.length)
+      throw new RangeError("Index out of range");
+    if (l < 0)
+      throw new RangeError("sourceEnd out of bounds");
+    l > this.length && (l = this.length), t.length - e < l - a && (l = t.length - e + a);
+    const p = l - a;
+    return this === t && typeof Uint8Array.prototype.copyWithin == "function" ? this.copyWithin(e, a, l) : Uint8Array.prototype.set.call(
+      t,
+      this.subarray(a, l),
+      e
+    ), p;
+  }, c.prototype.fill = function(t, e, a, l) {
+    if (typeof t == "string") {
+      if (typeof e == "string" ? (l = e, e = 0, a = this.length) : typeof a == "string" && (l = a, a = this.length), l !== void 0 && typeof l != "string")
+        throw new TypeError("encoding must be a string");
+      if (typeof l == "string" && !c.isEncoding(l))
+        throw new TypeError("Unknown encoding: " + l);
+      if (t.length === 1) {
+        const d = t.charCodeAt(0);
+        (l === "utf8" && d < 128 || l === "latin1") && (t = d);
+      }
+    } else
+      typeof t == "number" ? t = t & 255 : typeof t == "boolean" && (t = Number(t));
+    if (e < 0 || this.length < e || this.length < a)
+      throw new RangeError("Out of range index");
+    if (a <= e)
+      return this;
+    e = e >>> 0, a = a === void 0 ? this.length : a >>> 0, t || (t = 0);
+    let p;
+    if (typeof t == "number")
+      for (p = e; p < a; ++p)
+        this[p] = t;
+    else {
+      const d = c.isBuffer(t) ? t : c.from(t, l), x = d.length;
+      if (x === 0)
+        throw new TypeError('The value "' + t + '" is invalid for argument "value"');
+      for (p = 0; p < a - e; ++p)
+        this[p + e] = d[p % x];
+    }
+    return this;
+  };
+  const Y = {};
+  function ft(i, t, e) {
+    Y[i] = class extends e {
+      constructor() {
+        super(), Object.defineProperty(this, "message", {
+          value: t.apply(this, arguments),
+          writable: !0,
+          configurable: !0
+        }), this.name = `${this.name} [${i}]`, this.stack, delete this.name;
+      }
+      get code() {
+        return i;
+      }
+      set code(l) {
+        Object.defineProperty(this, "code", {
+          configurable: !0,
+          enumerable: !0,
+          value: l,
+          writable: !0
+        });
+      }
+      toString() {
+        return `${this.name} [${i}]: ${this.message}`;
+      }
+    };
+  }
+  ft(
+    "ERR_BUFFER_OUT_OF_BOUNDS",
+    function(i) {
+      return i ? `${i} is outside of buffer bounds` : "Attempt to access memory outside buffer bounds";
+    },
+    RangeError
+  ), ft(
+    "ERR_INVALID_ARG_TYPE",
+    function(i, t) {
+      return `The "${i}" argument must be of type number. Received type ${typeof t}`;
+    },
+    TypeError
+  ), ft(
+    "ERR_OUT_OF_RANGE",
+    function(i, t, e) {
+      let a = `The value of "${i}" is out of range.`, l = e;
+      return Number.isInteger(e) && Math.abs(e) > 2 ** 32 ? l = Tt(String(e)) : typeof e == "bigint" && (l = String(e), (e > BigInt(2) ** BigInt(32) || e < -(BigInt(2) ** BigInt(32))) && (l = Tt(l)), l += "n"), a += ` It must be ${t}. Received ${l}`, a;
+    },
+    RangeError
+  );
+  function Tt(i) {
+    let t = "", e = i.length;
+    const a = i[0] === "-" ? 1 : 0;
+    for (; e >= a + 4; e -= 3)
+      t = `_${i.slice(e - 3, e)}${t}`;
+    return `${i.slice(0, e)}${t}`;
+  }
+  function ye(i, t, e) {
+    V(t, "offset"), (i[t] === void 0 || i[t + e] === void 0) && X(t, i.length - (e + 1));
+  }
+  function $t(i, t, e, a, l, p) {
+    if (i > e || i < t) {
+      const d = typeof t == "bigint" ? "n" : "";
+      let x;
+      throw p > 3 ? t === 0 || t === BigInt(0) ? x = `>= 0${d} and < 2${d} ** ${(p + 1) * 8}${d}` : x = `>= -(2${d} ** ${(p + 1) * 8 - 1}${d}) and < 2 ** ${(p + 1) * 8 - 1}${d}` : x = `>= ${t}${d} and <= ${e}${d}`, new Y.ERR_OUT_OF_RANGE("value", x, i);
+    }
+    ye(a, l, p);
+  }
+  function V(i, t) {
+    if (typeof i != "number")
+      throw new Y.ERR_INVALID_ARG_TYPE(t, "number", i);
+  }
+  function X(i, t, e) {
+    throw Math.floor(i) !== i ? (V(i, e), new Y.ERR_OUT_OF_RANGE(e || "offset", "an integer", i)) : t < 0 ? new Y.ERR_BUFFER_OUT_OF_BOUNDS() : new Y.ERR_OUT_OF_RANGE(
+      e || "offset",
+      `>= ${e ? 1 : 0} and <= ${t}`,
+      i
+    );
+  }
+  const ge = /[^+/0-9A-Za-z-_]/g;
+  function me(i) {
+    if (i = i.split("=")[0], i = i.trim().replace(ge, ""), i.length < 2)
+      return "";
+    for (; i.length % 4 !== 0; )
+      i = i + "=";
+    return i;
+  }
+  function ut(i, t) {
+    t = t || 1 / 0;
+    let e;
+    const a = i.length;
+    let l = null;
+    const p = [];
+    for (let d = 0; d < a; ++d) {
+      if (e = i.charCodeAt(d), e > 55295 && e < 57344) {
+        if (!l) {
+          if (e > 56319) {
+            (t -= 3) > -1 && p.push(239, 191, 189);
+            continue;
+          } else if (d + 1 === a) {
+            (t -= 3) > -1 && p.push(239, 191, 189);
+            continue;
+          }
+          l = e;
+          continue;
+        }
+        if (e < 56320) {
+          (t -= 3) > -1 && p.push(239, 191, 189), l = e;
+          continue;
+        }
+        e = (l - 55296 << 10 | e - 56320) + 65536;
+      } else
+        l && (t -= 3) > -1 && p.push(239, 191, 189);
+      if (l = null, e < 128) {
+        if ((t -= 1) < 0)
+          break;
+        p.push(e);
+      } else if (e < 2048) {
+        if ((t -= 2) < 0)
+          break;
+        p.push(
+          e >> 6 | 192,
+          e & 63 | 128
+        );
+      } else if (e < 65536) {
+        if ((t -= 3) < 0)
+          break;
+        p.push(
+          e >> 12 | 224,
+          e >> 6 & 63 | 128,
+          e & 63 | 128
+        );
+      } else if (e < 1114112) {
+        if ((t -= 4) < 0)
+          break;
+        p.push(
+          e >> 18 | 240,
+          e >> 12 & 63 | 128,
+          e >> 6 & 63 | 128,
+          e & 63 | 128
+        );
+      } else
+        throw new Error("Invalid code point");
+    }
+    return p;
+  }
+  function be(i) {
+    const t = [];
+    for (let e = 0; e < i.length; ++e)
+      t.push(i.charCodeAt(e) & 255);
+    return t;
+  }
+  function xe(i, t) {
+    let e, a, l;
+    const p = [];
+    for (let d = 0; d < i.length && !((t -= 2) < 0); ++d)
+      e = i.charCodeAt(d), a = e >> 8, l = e % 256, p.push(l), p.push(a);
+    return p;
+  }
+  function Rt(i) {
+    return r.toByteArray(me(i));
+  }
+  function nt(i, t, e, a) {
+    let l;
+    for (l = 0; l < a && !(l + e >= t.length || l >= i.length); ++l)
+      t[l + e] = i[l];
+    return l;
+  }
+  function N(i, t) {
+    return i instanceof t || i != null && i.constructor != null && i.constructor.name != null && i.constructor.name === t.name;
+  }
+  function ht(i) {
+    return i !== i;
+  }
+  const Be = function() {
+    const i = "0123456789abcdef", t = new Array(256);
+    for (let e = 0; e < 16; ++e) {
+      const a = e * 16;
+      for (let l = 0; l < 16; ++l)
+        t[a + l] = i[e] + i[l];
+    }
+    return t;
+  }();
+  function v(i) {
+    return typeof BigInt > "u" ? Ee : i;
+  }
+  function Ee() {
+    throw new Error("BigInt not supported");
+  }
+})(q);
+/*! safe-buffer. MIT License. Feross Aboukhadijeh <https://feross.org/opensource> */
+(function(n, r) {
+  var o = q, s = o.Buffer;
+  function f(h, c) {
+    for (var w in h)
+      c[w] = h[w];
+  }
+  s.from && s.alloc && s.allocUnsafe && s.allocUnsafeSlow ? n.exports = o : (f(o, r), r.Buffer = u);
+  function u(h, c, w) {
+    return s(h, c, w);
+  }
+  u.prototype = Object.create(s.prototype), f(s, u), u.from = function(h, c, w) {
+    if (typeof h == "number")
+      throw new TypeError("Argument must not be a number");
+    return s(h, c, w);
+  }, u.alloc = function(h, c, w) {
+    if (typeof h != "number")
+      throw new TypeError("Argument must be a number");
+    var y = s(h);
+    return c !== void 0 ? typeof w == "string" ? y.fill(c, w) : y.fill(c) : y.fill(0), y;
+  }, u.allocUnsafe = function(h) {
+    if (typeof h != "number")
+      throw new TypeError("Argument must be a number");
+    return s(h);
+  }, u.allocUnsafeSlow = function(h) {
+    if (typeof h != "number")
+      throw new TypeError("Argument must be a number");
+    return o.SlowBuffer(h);
+  };
+})(mt, mt.exports);
+var Vt = mt.exports, Kt = Vt.Buffer;
+function at(n, r) {
+  this._block = Kt.alloc(n), this._finalSize = r, this._blockSize = n, this._len = 0;
+}
+at.prototype.update = function(n, r) {
+  typeof n == "string" && (r = r || "utf8", n = Kt.from(n, r));
+  for (var o = this._block, s = this._blockSize, f = n.length, u = this._len, h = 0; h < f; ) {
+    for (var c = u % s, w = Math.min(f - h, s - c), y = 0; y < w; y++)
+      o[c + y] = n[h + y];
+    u += w, h += w, u % s === 0 && this._update(o);
+  }
+  return this._len += f, this;
+};
+at.prototype.digest = function(n) {
+  var r = this._len % this._blockSize;
+  this._block[r] = 128, this._block.fill(0, r + 1), r >= this._finalSize && (this._update(this._block), this._block.fill(0));
+  var o = this._len * 8;
+  if (o <= 4294967295)
+    this._block.writeUInt32BE(o, this._blockSize - 4);
+  else {
+    var s = (o & 4294967295) >>> 0, f = (o - s) / 4294967296;
+    this._block.writeUInt32BE(f, this._blockSize - 8), this._block.writeUInt32BE(s, this._blockSize - 4);
+  }
+  this._update(this._block);
+  var u = this._hash();
+  return n ? u.toString(n) : u;
+};
+at.prototype._update = function() {
+  throw new Error("_update must be implemented by subclass");
+};
+var pr = at, dr = ir, Jt = pr, wr = Vt.Buffer, yr = [
+  1518500249,
+  1859775393,
+  -1894007588,
+  -899497514
+], gr = new Array(80);
+function rt() {
+  this.init(), this._w = gr, Jt.call(this, 64, 56);
+}
+dr(rt, Jt);
+rt.prototype.init = function() {
+  return this._a = 1732584193, this._b = 4023233417, this._c = 2562383102, this._d = 271733878, this._e = 3285377520, this;
+};
+function mr(n) {
+  return n << 1 | n >>> 31;
+}
+function br(n) {
+  return n << 5 | n >>> 27;
+}
+function xr(n) {
+  return n << 30 | n >>> 2;
+}
+function Br(n, r, o, s) {
+  return n === 0 ? r & o | ~r & s : n === 2 ? r & o | r & s | o & s : r ^ o ^ s;
+}
+rt.prototype._update = function(n) {
+  for (var r = this._w, o = this._a | 0, s = this._b | 0, f = this._c | 0, u = this._d | 0, h = this._e | 0, c = 0; c < 16; ++c)
+    r[c] = n.readInt32BE(c * 4);
+  for (; c < 80; ++c)
+    r[c] = mr(r[c - 3] ^ r[c - 8] ^ r[c - 14] ^ r[c - 16]);
+  for (var w = 0; w < 80; ++w) {
+    var y = ~~(w / 20), g = br(o) + Br(y, s, f, u) + h + r[w] + yr[y] | 0;
+    h = u, u = f, f = xr(s), s = o, o = g;
+  }
+  this._a = o + this._a | 0, this._b = s + this._b | 0, this._c = f + this._c | 0, this._d = u + this._d | 0, this._e = h + this._e | 0;
+};
+rt.prototype._hash = function() {
+  var n = wr.allocUnsafe(20);
+  return n.writeInt32BE(this._a | 0, 0), n.writeInt32BE(this._b | 0, 4), n.writeInt32BE(this._c | 0, 8), n.writeInt32BE(this._d | 0, 12), n.writeInt32BE(this._e | 0, 16), n;
+};
+var Er = rt;
+const Ir = /* @__PURE__ */ nr(Er);
+function _r(n) {
+  let r = "";
+  for (const o of new Uint8Array(n))
+    o < 16 && (r += "0"), r += o.toString(16);
+  return r;
+}
+let dt = null;
+async function jt(n) {
+  return dt === null && (dt = await Fr()), dt ? Xt(n) : Ar(n);
+}
+function Ar(n) {
+  return new Ir().update(n).digest("hex");
+}
+async function Xt(n) {
+  const r = await crypto.subtle.digest("SHA-1", n);
+  return _r(r);
+}
+async function Fr() {
+  try {
+    if (await Xt(new Uint8Array([])) === "da39a3ee5e6b4b0d3255bfef95601890afd80709")
+      return !0;
+  } catch {
+  }
+  return !1;
+}
+function Ur(n) {
+  const r = [];
+  let o = 0, s = 0;
+  do {
+    o = n.readUInt8();
+    const f = o & 127;
+    r.push(f), s = o & 128;
+  } while (s);
+  return r.reduce((f, u) => f + 1 << 7 | u, -1);
+}
+function Sr(n, r) {
+  let o = r, s = 4, f = null;
+  do
+    f = n.readUInt8(), o |= (f & 127) << s, s += 7;
+  while (f & 128);
+  return o;
+}
+class Q {
+  constructor(r) {
+    Object.assign(this, r), this.offsetCache = {};
+  }
+  static async fromIdx({ idx: r, getExternalRefDelta: o }) {
+    const s = new z(r);
+    if (s.slice(4).toString("hex") !== "ff744f63")
+      return;
+    const u = s.readUInt32BE();
+    if (u !== 2)
+      throw new _(
+        `Unable to read version ${u} packfile IDX. (Only version 2 supported)`
+      );
+    if (r.byteLength > 2048 * 1024 * 1024)
+      throw new _(
+        "To keep implementation simple, I haven't implemented the layer 5 feature needed to support packfiles > 2GB in size."
+      );
+    s.seek(s.tell() + 4 * 255);
+    const h = s.readUInt32BE(), c = [];
+    for (let g = 0; g < h; g++) {
+      const m = s.slice(20).toString("hex");
+      c[g] = m;
+    }
+    s.seek(s.tell() + 4 * h);
+    const w = /* @__PURE__ */ new Map();
+    for (let g = 0; g < h; g++)
+      w.set(c[g], s.readUInt32BE());
+    const y = s.slice(20).toString("hex");
+    return new Q({
+      hashes: c,
+      crcs: {},
+      offsets: w,
+      packfileSha: y,
+      getExternalRefDelta: o
+    });
+  }
+  static async fromPack({ pack: r, getExternalRefDelta: o, onProgress: s }) {
+    const f = {
+      1: "commit",
+      2: "tree",
+      3: "blob",
+      4: "tag",
+      6: "ofs-delta",
+      7: "ref-delta"
+    }, u = {}, h = r.slice(-20).toString("hex"), c = [], w = {}, y = /* @__PURE__ */ new Map();
+    let g = null, m = null;
+    await Ze([r], async ({ data: D, type: U, reference: M, offset: $, num: G }) => {
+      g === null && (g = G);
+      const R = Math.floor(
+        (g - G) * 100 / g
+      );
+      R !== m && s && await s({
+        phase: "Receiving objects",
+        loaded: g - G,
+        total: g
+      }), m = R, U = f[U], ["commit", "tree", "blob", "tag"].includes(U) ? u[$] = {
+        type: U,
+        offset: $
+      } : U === "ofs-delta" ? u[$] = {
+        type: U,
+        offset: $
+      } : U === "ref-delta" && (u[$] = {
+        type: U,
+        offset: $
+      });
+    });
+    const b = Object.keys(u).map(Number);
+    for (const [D, U] of b.entries()) {
+      const M = D + 1 === b.length ? r.byteLength - 20 : b[D + 1], $ = u[U], G = Ae.buf(r.slice(U, M)) >>> 0;
+      $.end = M, $.crc = G;
+    }
+    const B = new Q({
+      pack: Promise.resolve(r),
+      packfileSha: h,
+      crcs: w,
+      hashes: c,
+      offsets: y,
+      getExternalRefDelta: o
+    });
+    m = null;
+    let T = 0;
+    const L = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0];
+    for (let D in u) {
+      D = Number(D);
+      const U = Math.floor(T * 100 / g);
+      U !== m && s && await s({
+        phase: "Resolving deltas",
+        loaded: T,
+        total: g
+      }), T++, m = U;
+      const M = u[D];
+      if (!M.oid)
+        try {
+          B.readDepth = 0, B.externalReadDepth = 0;
+          const { type: $, object: G } = await B.readSlice({ start: D });
+          L[B.readDepth] += 1;
+          const R = await jt(Je.wrap({ type: $, object: G }));
+          M.oid = R, c.push(R), y.set(R, D), w[R] = M.crc;
+        } catch {
+          continue;
+        }
+    }
+    return c.sort(), B;
+  }
+  async toBuffer() {
+    const r = [], o = (y, g) => {
+      r.push(Buffer.from(y, g));
+    };
+    o("ff744f63", "hex"), o("00000002", "hex");
+    const s = new z(Buffer.alloc(256 * 4));
+    for (let y = 0; y < 256; y++) {
+      let g = 0;
+      for (const m of this.hashes)
+        parseInt(m.slice(0, 2), 16) <= y && g++;
+      s.writeUInt32BE(g);
+    }
+    r.push(s.buffer);
+    for (const y of this.hashes)
+      o(y, "hex");
+    const f = new z(Buffer.alloc(this.hashes.length * 4));
+    for (const y of this.hashes)
+      f.writeUInt32BE(this.crcs[y]);
+    r.push(f.buffer);
+    const u = new z(Buffer.alloc(this.hashes.length * 4));
+    for (const y of this.hashes)
+      u.writeUInt32BE(this.offsets.get(y));
+    r.push(u.buffer), o(this.packfileSha, "hex");
+    const h = Buffer.concat(r), c = await jt(h), w = Buffer.alloc(20);
+    return w.write(c, "hex"), Buffer.concat([h, w]);
+  }
+  async load({ pack: r }) {
+    this.pack = r;
+  }
+  async unload() {
+    this.pack = null;
+  }
+  async read({ oid: r }) {
+    if (!this.offsets.get(r)) {
+      if (this.getExternalRefDelta)
+        return this.externalReadDepth++, this.getExternalRefDelta(r);
+      throw new _(`Could not read object ${r} from packfile`);
+    }
+    const o = this.offsets.get(r);
+    return this.readSlice({ start: o });
+  }
+  async readSlice({ start: r }) {
+    if (this.offsetCache[r])
+      return Object.assign({}, this.offsetCache[r]);
+    this.readDepth++;
+    const o = {
+      16: "commit",
+      32: "tree",
+      48: "blob",
+      64: "tag",
+      96: "ofs_delta",
+      112: "ref_delta"
+    };
+    if (!this.pack)
+      throw new _(
+        "Tried to read from a GitPackIndex with no packfile loaded into memory"
+      );
+    const s = (await this.pack).slice(r), f = new z(s), u = f.readUInt8(), h = u & 112;
+    let c = o[h];
+    if (c === void 0)
+      throw new _("Unrecognized type: 0b" + h.toString(2));
+    const w = u & 15;
+    let y = w;
+    u & 128 && (y = Sr(f, w));
+    let m = null, b = null;
+    if (c === "ofs_delta") {
+      const T = Ur(f), L = r - T;
+      ({ object: m, type: c } = await this.readSlice({ start: L }));
+    }
+    if (c === "ref_delta") {
+      const T = f.slice(20).toString("hex");
+      ({ object: m, type: c } = await this.read({ oid: T }));
+    }
+    const B = s.slice(f.tell());
+    if (b = Buffer.from(await er(B)), b.byteLength !== y)
+      throw new _(
+        `Packfile told us object would have length ${y} but it had length ${b.byteLength}`
+      );
+    return m && (b = Buffer.from(Xe(b, m))), this.readDepth > 3 && (this.offsetCache[r] = { type: c, object: b }), { type: c, format: "content", object: b };
+  }
+}
+class tt extends J {
+  /**
+   * @param {string} value
+   */
+  constructor(r) {
+    super(`Expected a 40-char hex object id but saw "${r}".`), this.code = this.name = tt.code, this.data = { value: r };
+  }
+}
+tt.code = "InvalidOidError";
+class ct extends J {
+  /**
+   * @param {string} oid
+   * @param {'blob'|'commit'|'tag'|'tree'} actual
+   * @param {'blob'|'commit'|'tag'|'tree'} expected
+   * @param {string} [filepath]
+   */
+  constructor(r, o, s, f) {
+    super(
+      `Object ${r} ${f ? `at ${f}` : ""}was anticipated to be a ${s} but it is a ${o}.`
+    ), this.code = this.name = ct.code, this.data = { oid: r, actual: o, expected: s, filepath: f };
+  }
+}
+ct.code = "ObjectTypeError";
+async function Zt(n, r) {
+  const o = qt(n);
+  for (; ; ) {
+    const { value: s, done: f } = await o.next();
+    if (s && await r(s), f)
+      break;
+  }
+  o.return && o.return();
+}
+async function et(n) {
+  let r = 0;
+  const o = [];
+  await Zt(n, (u) => {
+    o.push(u), r += u.byteLength;
+  });
+  const s = new Uint8Array(r);
+  let f = 0;
+  for (const u of o)
+    s.set(u, f), f += u.byteLength;
+  return s;
+}
+class wt {
+  constructor() {
+    this._queue = [];
+  }
+  write(r) {
+    if (this._ended)
+      throw Error("You cannot write to a FIFO that has already been ended!");
+    if (this._waiting) {
+      const o = this._waiting;
+      this._waiting = null, o({ value: r });
+    } else
+      this._queue.push(r);
+  }
+  end() {
+    if (this._ended = !0, this._waiting) {
+      const r = this._waiting;
+      this._waiting = null, r({ done: !0 });
+    }
+  }
+  destroy(r) {
+    this.error = r, this.end();
+  }
+  async next() {
+    if (this._queue.length > 0)
+      return { value: this._queue.shift() };
+    if (this._ended)
+      return { done: !0 };
+    if (this._waiting)
+      throw Error(
+        "You cannot call read until the previous call to read has returned!"
+      );
+    return new Promise((r) => {
+      this._waiting = r;
+    });
+  }
+}
+class kr {
+  static demux(r) {
+    const o = k.streamReader(r), s = new wt(), f = new wt(), u = new wt(), h = async function() {
+      const c = await o();
+      if (c === null)
+        return h();
+      if (c === !0) {
+        s.end(), u.end(), r.error ? f.destroy(r.error) : f.end();
+        return;
+      }
+      switch (c[0]) {
+        case 1: {
+          f.write(c.slice(1));
+          break;
+        }
+        case 2: {
+          u.write(c.slice(1));
+          break;
+        }
+        case 3: {
+          const w = c.slice(1);
+          u.write(w), s.end(), u.end(), f.destroy(new Error(w.toString("utf8")));
+          return;
+        }
+        default:
+          s.write(c);
+      }
+      h();
+    };
+    return h(), {
+      packetlines: s,
+      packfile: f,
+      progress: u
+    };
+  }
+  // static mux ({
+  //   protocol, // 'side-band' or 'side-band-64k'
+  //   packetlines,
+  //   packfile,
+  //   progress,
+  //   error
+  // }) {
+  //   const MAX_PACKET_LENGTH = protocol === 'side-band-64k' ? 999 : 65519
+  //   let output = new PassThrough()
+  //   packetlines.on('data', data => {
+  //     if (data === null) {
+  //       output.write(GitPktLine.flush())
+  //     } else {
+  //       output.write(GitPktLine.encode(data))
+  //     }
+  //   })
+  //   let packfileWasEmpty = true
+  //   let packfileEnded = false
+  //   let progressEnded = false
+  //   let errorEnded = false
+  //   let goodbye = Buffer.concat([
+  //     GitPktLine.encode(Buffer.from('010A', 'hex')),
+  //     GitPktLine.flush()
+  //   ])
+  //   packfile
+  //     .on('data', data => {
+  //       packfileWasEmpty = false
+  //       const buffers = splitBuffer(data, MAX_PACKET_LENGTH)
+  //       for (const buffer of buffers) {
+  //         output.write(
+  //           GitPktLine.encode(Buffer.concat([Buffer.from('01', 'hex'), buffer]))
+  //         )
+  //       }
+  //     })
+  //     .on('end', () => {
+  //       packfileEnded = true
+  //       if (!packfileWasEmpty) output.write(goodbye)
+  //       if (progressEnded && errorEnded) output.end()
+  //     })
+  //   progress
+  //     .on('data', data => {
+  //       const buffers = splitBuffer(data, MAX_PACKET_LENGTH)
+  //       for (const buffer of buffers) {
+  //         output.write(
+  //           GitPktLine.encode(Buffer.concat([Buffer.from('02', 'hex'), buffer]))
+  //         )
+  //       }
+  //     })
+  //     .on('end', () => {
+  //       progressEnded = true
+  //       if (packfileEnded && errorEnded) output.end()
+  //     })
+  //   error
+  //     .on('data', data => {
+  //       const buffers = splitBuffer(data, MAX_PACKET_LENGTH)
+  //       for (const buffer of buffers) {
+  //         output.write(
+  //           GitPktLine.encode(Buffer.concat([Buffer.from('03', 'hex'), buffer]))
+  //         )
+  //       }
+  //     })
+  //     .on('end', () => {
+  //       errorEnded = true
+  //       if (progressEnded && packfileEnded) output.end()
+  //     })
+  //   return output
+  // }
+}
+async function Qt(n) {
+  const { packetlines: r, packfile: o, progress: s } = kr.demux(n), f = [], u = [], h = [];
+  let c = !1, w = !1;
+  return new Promise((y, g) => {
+    Zt(r, (m) => {
+      const b = m.toString("utf8").trim();
+      if (b.startsWith("shallow")) {
+        const B = b.slice(-41).trim();
+        B.length !== 40 && g(new tt(B)), f.push(B);
+      } else if (b.startsWith("unshallow")) {
+        const B = b.slice(-41).trim();
+        B.length !== 40 && g(new tt(B)), u.push(B);
+      } else if (b.startsWith("ACK")) {
+        const [, B, T] = b.split(" ");
+        h.push({ oid: B, status: T }), T || (w = !0);
+      } else
+        b.startsWith("NAK") ? (c = !0, w = !0) : (w = !0, c = !0);
+      w && (n.error ? g(n.error) : y({ shallows: f, unshallows: u, acks: h, nak: c, packfile: o, progress: s }));
+    }).finally(() => {
+      w || (n.error ? g(n.error) : y({ shallows: f, unshallows: u, acks: h, nak: c, packfile: o, progress: s }));
+    });
+  });
+}
+typeof window < "u" && (window.Buffer = q.Buffer);
+async function Xr(n, r, o) {
+  const f = (await ee(n, r))[r], u = await re(n, f), h = await $r(u, f, o), c = await Rr(
+    n,
+    o.map((y) => h[y].oid)
+  ), w = {};
+  return await Promise.all(
+    o.map(async (y) => {
+      w[y] = await ne(
+        c,
+        h[y].oid
+      );
+    })
+  ), w;
+}
+async function Zr(n, r) {
+  const o = await ee(n, r);
+  if (!(r in o))
+    throw new Error(`Branch ${r} not found`);
+  const s = o[r], f = await re(n, s), u = await Tr(f, s);
+  return u != null && u.object ? te(u) : [];
+}
+function te(n) {
+  return n.object.map((r) => {
+    if (r.type === "blob")
+      return {
+        name: r.path,
+        type: "file"
+      };
+    if (r.type === "tree" && r.object)
+      return {
+        name: r.path,
+        type: "folder",
+        children: te(r)
+      };
+  }).filter((r) => !!(r != null && r.name));
+}
+async function ee(n, r) {
+  const o = q.Buffer.from(
+    await et([
+      k.encode(`command=ls-refs
+`),
+      k.encode(`agent=git/2.37.3
+`),
+      k.encode(`object-format=sha1
+`),
+      k.delim(),
+      k.encode(`peel
+`),
+      k.encode(`ref-prefix ${r}
+`),
+      k.flush()
+    ])
+  ), s = await fetch(n + "/git-upload-pack", {
+    method: "POST",
+    headers: {
+      Accept: "application/x-git-upload-pack-advertisement",
+      "content-type": "application/x-git-upload-pack-request",
+      "Content-Length": `${o.length}`,
+      "Git-Protocol": "version=2"
+    },
+    body: o
+  }), f = {};
+  for await (const u of Cr(s)) {
+    const h = u.indexOf(" "), c = u.slice(0, h), w = u.slice(h + 1, u.length - 1);
+    f[w] = c;
+  }
+  return f;
+}
+async function re(n, r) {
+  const o = q.Buffer.from(
+    await et([
+      k.encode(
+        `want ${r} multi_ack_detailed no-done side-band-64k thin-pack ofs-delta agent=git/2.37.3 filter 
+`
+      ),
+      k.encode(`filter blob:none
+`),
+      k.encode(`shallow ${r}
+`),
+      k.encode(`deepen 1
+`),
+      k.flush(),
+      k.encode(`done
+`),
+      k.encode(`done
+`)
+    ])
+  ), s = await fetch(n + "/git-upload-pack", {
+    method: "POST",
+    headers: {
+      Accept: "application/x-git-upload-pack-advertisement",
+      "content-type": "application/x-git-upload-pack-request",
+      "Content-Length": `${o.length}`
+    },
+    body: o
+  }), f = ie(s.body), u = await Qt(f), h = q.Buffer.from(await et(u.packfile)), c = await Q.fromPack({
+    pack: h
+  }), w = c.read;
+  return c.read = async function({ oid: y, ...g }) {
+    const m = await w.call(this, { oid: y, ...g });
+    return m.oid = y, m;
+  }, c;
+}
+async function Tr(n, r) {
+  const o = await n.read({
+    oid: r
+  });
+  W(o);
+  const s = await n.read({ oid: o.object.tree }), f = [s];
+  for (; f.length > 0; ) {
+    const u = f.pop(), h = await n.read({ oid: u.oid });
+    if (W(h), u.object = h.object, h.type === "tree")
+      for (const c of h.object)
+        c.type === "tree" && f.push(c);
+  }
+  return s;
+}
+async function $r(n, r, o) {
+  const s = await n.read({
+    oid: r
+  });
+  W(s);
+  const f = await n.read({ oid: s.object.tree });
+  W(f);
+  const u = {};
+  for (const h of o) {
+    let c = f;
+    const w = h.split("/");
+    for (const y of w) {
+      if (c.type !== "tree")
+        throw new Error(`Path not found in the repo: ${h}`);
+      let g = !1;
+      for (const m of c.object)
+        if (m.path === y) {
+          try {
+            c = await n.read({ oid: m.oid }), W(c);
+          } catch {
+            c = m;
+          }
+          g = !0;
+          break;
+        }
+      if (!g)
+        throw new Error(`Path not found in the repo: ${h}`);
+    }
+    u[h] = c;
+  }
+  return u;
+}
+async function Rr(n, r) {
+  const o = q.Buffer.from(
+    await et([
+      ...r.map(
+        (c) => k.encode(
+          `want ${c} multi_ack_detailed no-done side-band-64k thin-pack ofs-delta agent=git/2.37.3 
+`
+        )
+      ),
+      k.flush(),
+      k.encode(`done
+`)
+    ])
+  ), s = await fetch(n + "/git-upload-pack", {
+    method: "POST",
+    headers: {
+      Accept: "application/x-git-upload-pack-advertisement",
+      "content-type": "application/x-git-upload-pack-request",
+      "Content-Length": `${o.length}`
+    },
+    body: o
+  }), f = ie(s.body), u = await Qt(f), h = q.Buffer.from(await et(u.packfile));
+  return await Q.fromPack({
+    pack: h
+  });
+}
+async function ne(n, r) {
+  const o = await n.read({ oid: r });
+  if (W(o), o.type === "blob")
+    return o.object;
+  const s = {};
+  for (const { path: f, oid: u, type: h } of o.object)
+    if (h === "blob") {
+      const c = await n.read({ oid: u });
+      W(c), s[f] = c.object;
+    } else
+      h === "tree" && (s[f] = await ne(n, u));
+  return s;
+}
+function W(n) {
+  if (n.object instanceof q.Buffer)
+    switch (n.type) {
+      case "commit":
+        n.object = O.from(n.object).parse();
+        break;
+      case "tree":
+        n.object = bt.from(n.object).entries();
+        break;
+      case "blob":
+        n.object = new Uint8Array(n.object), n.format = "content";
+        break;
+      case "tag":
+        n.object = Z.from(n.object).parse();
+        break;
+      default:
+        throw new ct(
+          n.oid,
+          n.type,
+          "blob|commit|tag|tree"
+        );
+    }
+}
+async function* Cr(n) {
+  const r = await n.text();
+  let o = 0;
+  for (; o <= r.length; ) {
+    const s = parseInt(r.substring(o, o + 4), 16);
+    if (s === 0)
+      break;
+    yield r.substring(o + 4, o + s), o += s;
+  }
+}
+function ie(n) {
+  if (n[Symbol.asyncIterator])
+    return n;
+  const r = n.getReader();
+  return {
+    next() {
+      return r.read();
+    },
+    return() {
+      return r.releaseLock(), {};
+    },
+    [Symbol.asyncIterator]() {
+      return this;
+    }
+  };
+}
+function Qr(n, r) {
+  r = Mt(r);
+  const o = ["", ".", "/"].includes(r);
+  let s = n;
+  if (o)
+    r = "";
+  else {
+    const h = r.split("/");
+    for (const c of h) {
+      const w = s == null ? void 0 : s.find(
+        (y) => y.name === c
+      );
+      if ((w == null ? void 0 : w.type) === "folder")
+        s = w.children;
+      else
+        return w ? [w.name] : [];
+    }
+  }
+  const f = [], u = [{ tree: s, path: r }];
+  for (; u.length > 0; ) {
+    const { tree: h, path: c } = u.pop();
+    for (const w of h) {
+      const y = `${c}${c ? "/" : ""}${w.name}`;
+      w.type === "folder" ? u.push({
+        tree: w.children,
+        path: y
+      }) : f.push(y);
+    }
+  }
+  return f;
+}
 export {
-  U as changeset,
-  $ as clearContentsFromMountDevice,
-  B as createClient,
-  j as createCommit,
-  R as createOrUpdateBranch,
-  G as createTree,
-  h as createTreeNode,
-  q as createTreeNodes,
-  E as deleteFile,
-  S as directoryHandleFromMountDevice,
-  W as directoryHandleToOpfsPath,
-  H as filesListToObject,
-  _ as fork,
-  M as getArtifact,
-  F as getFilesFromDirectory,
-  N as iterateFiles,
-  k as mayPush,
-  O as opfsPathToDirectoryHandle
+  Yr as changeset,
+  Kr as clearContentsFromMountDevice,
+  jr as createClient,
+  vr as createCommit,
+  Hr as createOrUpdateBranch,
+  zr as createTree,
+  Ct as createTreeNode,
+  Te as createTreeNodes,
+  $e as deleteFile,
+  Oe as directoryHandleFromMountDevice,
+  Vr as directoryHandleToOpfsPath,
+  Lr as filesListToObject,
+  qr as fork,
+  Mr as getArtifact,
+  Fe as getFilesFromDirectory,
+  Wr as iterateFiles,
+  Qr as listDescendantFiles,
+  Zr as listGitFiles,
+  ee as listGitRefs,
+  Gr as mayPush,
+  Pe as opfsPathToDirectoryHandle,
+  Xr as sparseCheckout
 };