create-expo 5.0.0 → 5.0.1

package/build/{525.index.js → 223.index.js}

@@ -1,5 +1,5 @@
-exports.id = 525;
-exports.ids = [525];
+exports.id = 223;
+exports.ids = [223];
 exports.modules = {
 
 /***/ 2671:
@@ -11726,12 +11726,12 @@ globstar while`,t,d,e,f,m),this.matchOne(t.slice(d),e.slice(f),s))return this.de
 
 /***/ }),
 
-/***/ 912:
+/***/ 6378:
 /***/ ((__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) => {
 
 "use strict";
 /* harmony export */ __webpack_require__.d(__webpack_exports__, {
-/* harmony export */   Aq: () => (/* binding */ y),
+/* harmony export */   Aq: () => (/* binding */ p),
 /* harmony export */   PJ: () => (/* binding */ untar),
 /* harmony export */   WT: () => (/* binding */ streamToAsyncIterable)
 /* harmony export */ });
@@ -11744,15 +11744,18 @@ function createReadableStream(t) {
   const {pull: n, cancel: i} = t;
   if (n && i) {
     let e;
+    let a;
     t.pull = function wrappedPull(t) {
       return e = n(t);
     };
     t.cancel = function wrappedCancel() {
-      if (null != e) {
+      if (null != a) {
+        return a;
+      } else if (null != e) {
         const settle = () => i();
-        return Promise.resolve(e).then(settle, settle);
+        return a = Promise.resolve(e).then(settle, settle);
       }
-      return i();
+      return a = Promise.resolve(i());
     };
   }
   const a = new ReadableStream(t, e);
@@ -11769,12 +11772,24 @@ function streamToAsyncIterable(e) {
   if (!e[Symbol.asyncIterator]) {
     return async function*() {
       const t = e.getReader();
-      while (1) {
-        const e = await t.read();
-        if (e.done) {
-          return e.value;
+      let n = !1;
+      try {
+        while (1) {
+          const e = await t.read();
+          if (e.done) {
+            n = !0;
+            return e.value;
+          }
+          yield e.value;
+        }
+      } finally {
+        try {
+          if (!n) {
+            await t.cancel();
+          }
+        } finally {
+          t.releaseLock();
         }
-        yield e.value;
       }
     }();
   } else {
@@ -11782,20 +11797,75 @@ function streamToAsyncIterable(e) {
   }
 }
 
-function streamLikeToIterator(e) {
-  if ("getReader" in e && "function" == typeof e.getReader) {
-    const t = e.getReader();
-    return async function read() {
-      return await t.read();
-    };
+async function* streamToSizedAsyncIterable(e, t, n) {
+  if (null == t) {
+    yield* streamToAsyncIterable(e);
   } else {
-    const t = e[Symbol.asyncIterator] ? e[Symbol.asyncIterator]() : e[Symbol.iterator]();
-    return async function next() {
-      return await t.next();
-    };
+    const i = e.getReader();
+    let a = t;
+    let r = !1;
+    try {
+      while (1) {
+        const e = await i.read();
+        if (e.done) {
+          r = !0;
+          break;
+        }
+        a -= e.value.byteLength;
+        if (a < 0) {
+          throw new Error(`${n} body exceeds declared size`);
+        }
+        yield e.value;
+      }
+      if (a > 0) {
+        throw new Error(`${n} body is shorter than declared size`);
+      }
+    } finally {
+      try {
+        if (!r) {
+          await i.cancel();
+        }
+      } finally {
+        i.releaseLock();
+      }
+    }
   }
 }
 
+function streamLikeToIterator(e) {
+  const t = "getReader" in e && "function" == typeof e.getReader ? streamToAsyncIterable(e) : e;
+  const n = t[Symbol.asyncIterator] ? t[Symbol.asyncIterator]() : t[Symbol.iterator]();
+  let i = !1;
+  const a = {
+    [Symbol.asyncIterator]: () => a,
+    async next() {
+      if (i) {
+        return {
+          done: !0,
+          value: void 0
+        };
+      }
+      const e = await n.next();
+      i = !!e.done;
+      return e.done ? {
+        done: !0,
+        value: void 0
+      } : e;
+    },
+    async return() {
+      if (!i) {
+        i = !0;
+        await (n.return?.());
+      }
+      return {
+        done: !0,
+        value: void 0
+      };
+    }
+  };
+  return a;
+}
+
 function iterableToStream(e, t) {
   const n = t?.signal;
   const i = new AbortController;
@@ -11941,6 +12011,9 @@ class ReadableStreamBlockReader {
     this.block = new Uint8Array(t);
     this.buffer = null;
   }
+  async close() {
+    await this.next.return();
+  }
   async read() {
     const {blockSize: e, block: t} = this;
     let n = 0;
@@ -11962,7 +12035,7 @@ class ReadableStreamBlockReader {
       }
     }
     while ((i = e - n) > 0) {
-      const {done: e, value: a} = await this.next();
+      const {done: e, value: a} = await this.next.next();
       if (e || !a?.byteLength) {
         break;
       } else if (a.byteLength > i) {
@@ -12000,7 +12073,7 @@ class ReadableStreamBlockReader {
       }
     }
     this.blockLocked = !1;
-    const {done: i, value: a} = await this.next();
+    const {done: i, value: a} = await this.next.next();
     if (i) {
       return null;
     } else if (a.byteLength > e) {
@@ -12030,7 +12103,7 @@ class ReadableStreamBlockReader {
       }
     }
     while (t > 0) {
-      const {done: e, value: n} = await this.next();
+      const {done: e, value: n} = await this.next.next();
       if (e) {
         return t;
       } else if (n.byteLength > t) {
@@ -12260,29 +12333,34 @@ async function expectTrailer(e, t) {
 async function decodeHeaders(e) {
   let t = 0;
   const n = Object.create(null);
-  while (t < 32e3) {
+  while (t <= 32e3) {
     let i = "";
+    let a = 0;
     for await (const n of readUntilBoundary(e, s, l)) {
       if (null == n) {
         throw new Error("Invalid Multipart Headers: Unexpected EOF");
       } else if (!t && !i && 45 === n[0] && 45 === n[1]) {
         return null;
       } else {
-        i += d.decode(n);
-        if (i.length > 16e3) {
+        a += n.byteLength;
+        if (a > 16e3) {
           throw new Error("Invalid Multipart Headers: A header exceeded its maximum length of 16kB");
         }
+        i += d.decode(n, {
+          stream: !0
+        });
       }
     }
+    i += d.decode();
     if (i) {
       const e = i.indexOf(":");
       if (e > -1) {
-        const a = i.slice(0, e).trim().toLowerCase();
-        const r = i.slice(e + 1).trim();
-        if (r) {
-          n[a] = r;
+        const r = i.slice(0, e).trim().toLowerCase();
+        const o = i.slice(e + 1).trim();
+        if (o) {
+          n[r] = o;
         }
-        t += i.length + s.byteLength;
+        t += a + s.byteLength;
       } else {
         throw new Error("Invalid Multipart Headers: Invalid header value missing `:`");
       }
@@ -12290,113 +12368,119 @@ async function decodeHeaders(e) {
       break;
     }
   }
-  if (t > 16e3) {
+  if (t > 32e3) {
     throw new Error("Invalid Multipart Headers: Headers exceeded their maximum length of 32kB");
   }
   return n;
 }
 
 async function* parseMultipart(e, t) {
-  const n = function convertToBoundaryBytes(e) {
-    const t = e.match(c);
-    const n = `--${t?.[1] || "-"}`;
-    const i = `\r\n${n}`;
-    const a = utf8Encode(n);
-    const r = utf8Encode(i);
-    return {
-      raw: a,
-      rawSkipTable: bytesToSkipTable(a),
-      trailer: r,
-      trailerSkipTable: bytesToSkipTable(r)
-    };
-  }(t.contentType);
-  const i = new ReadableStreamBlockReader(e, 4096);
-  await async function expectPreamble(e, t) {
-    let n = 0;
-    for await (const i of readUntilBoundary(e, t.raw, t.rawSkipTable)) {
-      if (null == i) {
-        throw new Error("Invalid Multipart Preamble: Unexpected EOF");
-      } else if ((n += i?.byteLength) > 16e3) {
-        throw new Error("Invalid Multipart Preamble: Boundary not found within the first 16kB");
-      }
-    }
-  }(i, n);
-  let a;
-  while (a = await decodeHeaders(i)) {
-    const e = a["content-type"];
-    const t = parseContentDisposition(a["content-disposition"]);
-    const r = t?.filename || t?.name;
-    const o = parseContentLength(a["content-length"]);
-    if (!r) {
-      throw new Error("Invalid Multipart Part: Missing Content-Disposition name or filename parameter");
-    }
-    let s = !1;
-    let l = 0;
-    let c;
-    if (null !== o) {
-      l = o;
-      c = createReadableStream({
-        expectedLength: o,
-        async cancel() {
-          if (l > 0) {
-            l = await i.skip(l);
-            if (l > 0) {
-              throw new Error("Invalid Multipart Part: Unexpected EOF");
-            }
-          }
-          if (!s) {
-            await expectTrailer(i, n);
-            s = !0;
-          }
-        },
-        async pull(e) {
-          if (l) {
-            const t = await i.pull(l);
-            if (!t) {
-              throw new Error("Invalid Multipart Part: Unexpected EOF");
-            }
-            l -= t.byteLength;
-            e.enqueue(i.blockLocked ? t.slice() : t);
-          }
-          if (!l) {
-            await expectTrailer(i, n);
-            s = !0;
-            e.close();
+  const n = new ReadableStreamBlockReader(e, 4096);
+  try {
+    yield* async function* readMultipart(e, t) {
+      const n = function convertToBoundaryBytes(e) {
+        const t = e.match(c);
+        const n = `--${t?.[1] || "-"}`;
+        const i = `\r\n${n}`;
+        const a = utf8Encode(n);
+        const r = utf8Encode(i);
+        return {
+          raw: a,
+          rawSkipTable: bytesToSkipTable(a),
+          trailer: r,
+          trailerSkipTable: bytesToSkipTable(r)
+        };
+      }(t.contentType);
+      await async function expectPreamble(e, t) {
+        let n = 0;
+        for await (const i of readUntilBoundary(e, t.raw, t.rawSkipTable)) {
+          if (null == i) {
+            throw new Error("Invalid Multipart Preamble: Unexpected EOF");
+          } else if ((n += i?.byteLength) > 16e3) {
+            throw new Error("Invalid Multipart Preamble: Boundary not found within the first 16kB");
           }
         }
-      });
-    } else {
-      const e = readUntilBoundary(i, n.trailer, n.trailerSkipTable);
-      c = createReadableStream({
-        async cancel() {
-          for await (const t of e) {
-            if (!t) {
-              throw new Error("Invalid Multipart Part: Unexpected EOF");
+      }(e, n);
+      let i;
+      while (i = await decodeHeaders(e)) {
+        const t = i["content-type"];
+        const a = parseContentDisposition(i["content-disposition"]);
+        const r = a?.filename || a?.name;
+        const o = parseContentLength(i["content-length"]);
+        if (!r) {
+          throw new Error("Invalid Multipart Part: Missing Content-Disposition name or filename parameter");
+        }
+        let s = !1;
+        let l = 0;
+        let c;
+        if (null !== o) {
+          l = o;
+          c = createReadableStream({
+            expectedLength: o,
+            async cancel() {
+              if (l > 0) {
+                l = await e.skip(l);
+                if (l > 0) {
+                  throw new Error("Invalid Multipart Part: Unexpected EOF");
+                }
+              }
+              if (!s) {
+                await expectTrailer(e, n);
+                s = !0;
+              }
+            },
+            async pull(t) {
+              if (l) {
+                const n = await e.pull(l);
+                if (!n) {
+                  throw new Error("Invalid Multipart Part: Unexpected EOF");
+                }
+                l -= n.byteLength;
+                t.enqueue(e.blockLocked ? n.slice() : n);
+              }
+              if (!l) {
+                await expectTrailer(e, n);
+                s = !0;
+                t.close();
+              }
             }
-          }
-          s = !0;
-        },
-        async pull(t) {
-          const n = await e.next();
-          if (n.done) {
-            t.close();
-            s = !0;
-          } else if (!n.value) {
-            throw new Error("Invalid Multipart Part: Unexpected EOF");
-          } else {
-            t.enqueue(n.value.slice());
-          }
+          });
+        } else {
+          const t = readUntilBoundary(e, n.trailer, n.trailerSkipTable);
+          c = createReadableStream({
+            async cancel() {
+              for await (const e of t) {
+                if (!e) {
+                  throw new Error("Invalid Multipart Part: Unexpected EOF");
+                }
+              }
+              s = !0;
+            },
+            async pull(e) {
+              const n = await t.next();
+              if (n.done) {
+                e.close();
+                s = !0;
+              } else if (!n.value) {
+                throw new Error("Invalid Multipart Part: Unexpected EOF");
+              } else {
+                e.enqueue(n.value.slice());
+              }
+            }
+          });
         }
-      });
-    }
-    yield new MultipartPart(c, r, {
-      type: e ?? void 0,
-      size: o ?? void 0,
-      headers: a
-    });
-    if (l > 0 || !s) {
-      await c.cancel();
-    }
+        yield new MultipartPart(c, r, {
+          type: t ?? void 0,
+          size: o ?? void 0,
+          headers: i
+        });
+        if (l > 0 || !s) {
+          await c.cancel();
+        }
+      }
+    }(n, t);
+  } finally {
+    await n.close();
   }
 }
 
@@ -12410,9 +12494,10 @@ const isBlob = e => "object" == typeof e && null != e && (e instanceof Multipart
 
 const makeFormHeader = (e, t) => {
   let n = f + i + u;
-  n += `Content-Disposition: form-data; name="${encodeName(e.name)}"`;
+  const a = encodeName(e.name);
+  n += `Content-Disposition: form-data; name="${a}"`;
   if (null != e.filename) {
-    n += `; filename="${encodeName(e.filename)}"`;
+    n += `; filename="${e.filename === e.name ? a : encodeName(e.filename)}"`;
   }
   if (t) {
     if (t.type) {
@@ -12434,39 +12519,36 @@ const makeFormHeader = (e, t) => {
   return n;
 };
 
-const m = (/* unused pure expression or super */ null && (`multipart/form-data; boundary=${i}`));
+const y = (/* unused pure expression or super */ null && (`multipart/form-data; boundary=${i}`));
 
 async function* streamMultipart(e) {
-  const n = streamLikeToIterator(e);
-  let i;
-  while (!(i = await n()).done && i.value) {
-    const e = i.value[0];
-    const n = i.value[1];
-    if (isBlob(n)) {
+  for await (const [n, i] of streamLikeToIterator(e)) {
+    if (isBlob(i)) {
       yield t.encode(makeFormHeader({
-        name: e,
-        filename: "name" in n ? n.name : e
-      }, n));
-      yield* streamToAsyncIterable(n.stream());
+        name: n,
+        filename: "name" in i ? i.name : n
+      }, i));
+      const e = i.stream();
+      yield* streamToSizedAsyncIterable(e, i.size || null, "Invalid Multipart: Part");
     } else {
       yield t.encode(makeFormHeader({
-        name: e
+        name: n
       }, void 0));
-      yield "string" == typeof n ? t.encode(n) : n;
+      yield "string" == typeof i ? t.encode(i) : i;
     }
     yield t.encode(u);
   }
   yield t.encode(h);
 }
 
-const p = 512;
+const m = 512;
 
 function blockPad(e) {
   const t = 511 & e;
-  return t && p - t;
+  return t && m - t;
 }
 
-let y = function(e) {
+let p = function(e) {
   e[e.FILE = 48] = "FILE";
   e[e.LINK = 49] = "LINK";
   e[e.SYMLINK = 50] = "SYMLINK";
@@ -12482,12 +12564,13 @@ function initTarHeader(e) {
     gid: e?.gid || 0,
     size: e?.size || 0,
     mtime: e?.mtime || 0,
-    typeflag: e?.typeflag || y.FILE,
+    typeflag: e?.typeflag || p.FILE,
     linkname: e?.linkname || null,
     uname: e?.uname || null,
     gname: e?.gname || null,
     devmajor: e?.devmajor || 0,
-    devminor: e?.devminor || 0
+    devminor: e?.devminor || 0,
+    _paxSize: e?._paxSize
   };
 }
 
@@ -12503,7 +12586,7 @@ const getTarName = e => {
   }
 };
 
-const getTarSize = e => e._paxSize || e.size;
+const getTarSize = e => e._paxSize ?? e.size;
 
 class TarChunk extends StreamFile {
   constructor(e, t) {
@@ -12541,7 +12624,7 @@ class TarFile extends StreamFile {
     this.uid = t.uid;
     this.gid = t.gid;
     this.mtime = t.mtime;
-    this.typeflag = y.FILE;
+    this.typeflag = p.FILE;
     this.linkname = null;
     this.uname = t.uname;
     this.gname = t.gname;
@@ -12552,59 +12635,60 @@ class TarFile extends StreamFile {
 
 async function decodePax(e, t, i) {
   let a = i.size;
-  let r = "";
+  const r = [];
   while (a > 0) {
-    let t = await e.read();
+    const t = await e.read();
     if (!t || t.byteLength !== e.blockSize) {
       throw new Error("Invalid Tar: Unexpected EOF while parsing PAX data");
     }
-    a -= t.byteLength;
-    if (a < 0) {
-      t = t.subarray(0, a);
-    }
-    r += n.decode(t, {
-      stream: !0
-    });
+    const n = Math.min(a, t.byteLength);
+    r.push(t.slice(0, n));
+    a -= n;
+  }
+  const o = new Uint8Array(i.size);
+  for (let e = 0, t = 0; e < r.length; e++) {
+    o.set(r[e], t);
+    t += r[e].byteLength;
   }
-  for (let e = 0, n = 0; e < r.length; n = 0) {
-    while (n < r.length && 32 !== r.charCodeAt(n)) {
-      n++;
+  for (let e = 0, a = 0; e < o.byteLength; a = e) {
+    while (a < o.byteLength && 32 !== o[a]) {
+      a++;
     }
-    const a = parseInt(r.slice(e, n), 10);
-    if (!a || a != a) {
+    const r = parseInt(n.decode(o.subarray(e, a)), 10);
+    if (!r || r != r) {
       break;
     }
-    if (10 !== r.charCodeAt(e + a - 1)) {
+    if (10 !== o[e + r - 1]) {
       break;
     }
-    const o = r.slice(n + 1, e + a - 1);
-    const s = o.indexOf("=");
-    if (-1 === s) {
+    const s = n.decode(o.subarray(a + 1, e + r - 1));
+    const l = s.indexOf("=");
+    if (-1 === l) {
       break;
     }
-    const l = o.slice(0, s);
-    const c = o.slice(s + 1);
-    e += a;
-    switch (l) {
+    const c = s.slice(0, l);
+    const d = s.slice(l + 1);
+    e += r;
+    switch (c) {
      case "path":
       if (t) {
-        t._paxName = c;
+        t._paxName = d;
       }
-      i._paxName = c;
+      i._paxName = d;
       break;
 
      case "linkpath":
       if (t) {
-        t._paxLinkName = c;
+        t._paxLinkName = d;
       }
-      i._paxLinkName = c;
+      i._paxLinkName = d;
       break;
 
      case "size":
       if (t) {
-        t._paxSize = +c;
+        t._paxSize = +d;
       }
-      i._paxSize = +c;
+      i._paxSize = +d;
       break;
 
      case "gid":
@@ -12612,17 +12696,17 @@ async function decodePax(e, t, i) {
      case "mode":
      case "mtime":
       if (t) {
-        t[l] = +c;
+        t[c] = +d;
       }
-      i[l] = +c;
+      i[c] = +d;
       break;
 
      case "uname":
      case "gname":
       if (t) {
-        t[l] = c;
+        t[c] = d;
       }
-      i[l] = c;
+      i[c] = d;
     }
   }
 }
@@ -12730,7 +12814,7 @@ function decodeBase(e, t) {
     e._prefix = decodeString(t, 345, 500);
   }
   if (0 === e.typeflag && e.name.endsWith("/")) {
-    e.typeflag = y.DIRECTORY;
+    e.typeflag = p.DIRECTORY;
   }
 }
 
@@ -12765,10 +12849,10 @@ async function decodeHeader(e, t) {
 
      case 0:
      case 55:
-     case y.FILE:
-     case y.LINK:
-     case y.SYMLINK:
-     case y.DIRECTORY:
+     case p.FILE:
+     case p.LINK:
+     case p.SYMLINK:
+     case p.DIRECTORY:
       decodeBase(i, n);
       return i;
 
@@ -12789,79 +12873,91 @@ async function decodeHeader(e, t) {
 }
 
 async function* untar(e) {
-  const t = initTarHeader(null);
-  const n = new ReadableStreamBlockReader(e, p);
-  let i;
-  while (null != (i = await decodeHeader(n, t))) {
-    const e = blockPad(i.size);
-    let t = 0 === e;
-    let a = i._paxSize || i.size;
-    const r = createReadableStream({
-      expectedLength: i.size,
-      async cancel() {
-        if (!t) {
-          t = !0;
-          a += e;
-        }
-        if (a > 0) {
-          if (await n.skip(a) > 0) {
-            throw new Error("Invalid Tar: Unexpected EOF");
-          }
-          a = 0;
-        }
-      },
-      async pull(i) {
-        if (a) {
-          const e = await n.pull(a);
-          if (!e) {
-            throw new Error("Invalid Tar: Unexpected EOF");
-          }
-          a -= e.byteLength;
-          i.enqueue(n.blockLocked ? e.slice() : e);
+  const t = new ReadableStreamBlockReader(e, m);
+  try {
+    yield* async function* readTar(e) {
+      const t = initTarHeader(null);
+      let n;
+      while (null != (n = await decodeHeader(e, t))) {
+        const t = n._paxSize ?? n.size;
+        if (!Number.isSafeInteger(t) || t < 0) {
+          throw new Error(`Invalid Tar: Invalid entry size ${t}`);
         }
-        if (!a) {
-          if (!t) {
-            t = !0;
-            if (await n.skip(e) > 0) {
-              throw new Error("Invalid Tar: Unexpected EOF");
+        const i = blockPad(t);
+        let a = 0 === i;
+        let r = t;
+        const o = createReadableStream({
+          expectedLength: t,
+          async cancel() {
+            if (!a) {
+              r += i;
+            }
+            if (r > 0) {
+              if (await e.skip(r) > 0) {
+                throw new Error("Invalid Tar: Unexpected EOF");
+              }
+              r = 0;
+            }
+            a = !0;
+          },
+          async pull(t) {
+            if (r) {
+              const n = await e.pull(r);
+              if (!n) {
+                throw new Error("Invalid Tar: Unexpected EOF");
+              }
+              r -= n.byteLength;
+              t.enqueue(e.blockLocked ? n.slice() : n);
+            }
+            if (!r) {
+              if (!a) {
+                if (await e.skip(i) > 0) {
+                  throw new Error("Invalid Tar: Unexpected EOF");
+                }
+                a = !0;
+              }
+              t.close();
             }
           }
-          i.close();
-        }
-      }
-    });
-    let o;
-    switch (i.typeflag) {
-     case 0:
-     case 55:
-     case y.FILE:
-      o = new TarFile(r, i);
-      break;
+        });
+        let s;
+        switch (n.typeflag) {
+         case 0:
+         case 55:
+         case p.FILE:
+          s = new TarFile(o, n);
+          break;
 
-     case y.LINK:
-     case y.SYMLINK:
-     case y.DIRECTORY:
-      o = new TarChunk(r, i);
-      break;
+         case p.LINK:
+         case p.SYMLINK:
+         case p.DIRECTORY:
+          s = new TarChunk(o, n);
+          break;
 
-     default:
-      await r.cancel();
-      continue;
-    }
-    yield o;
-    if (a > 0 || !t) {
-      await r.cancel();
-    }
+         default:
+          await o.cancel();
+          continue;
+        }
+        yield s;
+        if (r > 0 || !a) {
+          await o.cancel();
+        }
+      }
+    }(t);
+  } finally {
+    await t.close();
   }
 }
 
 const b = 100;
 
-const w = new Uint8Array(p);
+const w = new Uint8Array(m);
+
+const g = /[^\x00-\x7f]/;
 
 function encodeString(e, n, i, a) {
   if (a) {
-    t.encodeInto(`${a}\0`, e.subarray(n, i));
+    t.encodeInto(a, e.subarray(n, i));
   }
 }
 
@@ -12899,28 +12995,9 @@ function encodeOctal(e, t, n, i) {
   }
 }
 
-function indexOfPrefixEnd(e) {
-  if (e.length <= 255) {
-    let t = e.length - 1;
-    while ((t = e.lastIndexOf("/", t - 1)) > -1) {
-      if (t < 155 && e.length - t - 1 < b) {
-        return t;
-      }
-    }
-  }
-  return -1;
-}
-
 function encodeHeader(e) {
-  const t = new Uint8Array(p);
+  const t = new Uint8Array(m);
   !function encodeBase(e, t) {
-    let n = t.name;
-    if (!t._paxName && !t._longName && n.length > b) {
-      const e = indexOfPrefixEnd(n);
-      if (e > -1) {
-        n = n.slice(e + 1);
-      }
-    }
     if (!t.typeflag) {
       t.typeflag = function modeToType(e) {
         switch (61440 & e) {
@@ -12931,26 +13008,26 @@ function encodeHeader(e) {
           return 51;
 
          case 16384:
-          return y.DIRECTORY;
+          return p.DIRECTORY;
 
          case 4096:
           return 54;
 
          case 40960:
-          return y.SYMLINK;
+          return p.SYMLINK;
 
          default:
-          return y.FILE;
+          return p.FILE;
         }
       }(t.mode);
     }
     if (!t.mode) {
-      t.mode = t.typeflag === y.DIRECTORY ? 493 : 420;
+      t.mode = t.typeflag === p.DIRECTORY ? 493 : 420;
     }
     if (!t.mtime) {
       t.mtime = Math.floor(Date.now() / 1e3);
     }
-    encodeString(e, 0, 100, n);
+    encodeString(e, 0, 100, t.name);
     encodeOctal(e, 100, 108, 4095 & t.mode);
     encodeOctal(e, 108, 116, t.uid);
     encodeOctal(e, 116, 124, t.gid);
@@ -12979,15 +13056,15 @@ function encodeHeader(e) {
 }
 
 function encodePax(e) {
-  function encodePaxEntry(e, t) {
-    const n = ` ${e}=${t}\n`;
-    let i = n.length;
-    const a = `${i}`;
-    i += a.length;
-    if (1 + Math.floor(Math.log10(i)) > a.length) {
-      i += 1;
+  function encodePaxEntry(e, n) {
+    const i = ` ${e}=${n}\n`;
+    let a = t.encode(i).byteLength;
+    const r = `${a}`;
+    a += r.length;
+    if (1 + Math.floor(Math.log10(a)) > r.length) {
+      a += 1;
     }
-    return `${i}${n}`;
+    return `${a}${i}`;
   }
   let n = "";
   if (e._paxName) {
@@ -12999,64 +13076,84 @@ function encodePax(e) {
   return n ? t.encode(n) : null;
 }
 
-function paxName(e) {
-  const t = e.lastIndexOf("/");
-  return `PaxHeader/${(t > -1 ? e.slice(t) : e).slice(-99)}`;
+function truncateHeaderString(e) {
+  let t = 99;
+  while (128 == (192 & e[t])) {
+    t--;
+  }
+  return n.decode(e.subarray(0, t));
 }
 
-async function* tar(e) {
-  const t = streamLikeToIterator(e);
-  let n;
-  while (!(n = await t()).done && n.value) {
-    const {value: e} = n;
-    const t = initTarHeader(e);
-    if (!Number.isSafeInteger(t.size) || t.size < 0) {
-      throw new Error(`Invalid Tar: Cannot safely encode part with size ${t.size}`);
-    }
-    if (e.lastModified && !t.mtime) {
-      t.mtime = Math.floor(e.lastModified / 1e3);
-    }
-    if (t.typeflag === y.DIRECTORY && !t.name.endsWith("/")) {
-      t.name += "/";
-    } else if (t.typeflag === y.SYMLINK) {
-      t.size = 0;
-    }
-    if (t.name.length > b) {
-      const e = indexOfPrefixEnd(t.name);
-      if (e > -1) {
-        t._prefix = t.name.slice(0, e);
-        t.name = t.name.slice(e + 1);
+function prepareHeaderStrings(e) {
+  if (e.name.length > 33 && (e.name.length > b || g.test(e.name))) {
+    const i = t.encode(e.name);
+    if (i.byteLength > b) {
+      const t = function indexOfPrefixEnd(e) {
+        if (e.byteLength <= 255) {
+          let t = e.byteLength;
+          while ((t = e.lastIndexOf(47, t - 1)) > 0) {
+            if (t < 155 && e.byteLength - t - 1 < b) {
+              return t;
+            }
+          }
+        }
+        return -1;
+      }(i);
+      if (t > -1) {
+        e._prefix = n.decode(i.subarray(0, t));
+        e.name = n.decode(i.subarray(t + 1));
       } else {
-        t._paxName = t.name;
-        t.name = paxName(t.name);
+        e._paxName = e.name;
+        e.name = truncateHeaderString(i);
       }
     }
-    if (t.linkname && t.linkname.length > b) {
-      t._paxLinkName = t.linkname;
-      t.linkname = paxName(t.name);
+  }
+  if (e.linkname && e.linkname.length > 33 && (e.linkname.length > b || g.test(e.linkname))) {
+    const n = t.encode(e.linkname);
+    if (n.byteLength > b) {
+      e._paxLinkName = e.linkname;
+      e.linkname = truncateHeaderString(n);
     }
-    const i = encodePax(t);
-    if (i) {
+  }
+}
+
+async function* tar(e) {
+  for await (const t of streamLikeToIterator(e)) {
+    const e = initTarHeader(t);
+    if (!Number.isSafeInteger(e.size) || e.size < 0) {
+      throw new Error(`Invalid Tar: Cannot safely encode part with size ${e.size}`);
+    }
+    if (t.lastModified && !e.mtime) {
+      e.mtime = Math.floor(t.lastModified / 1e3);
+    }
+    if (e.typeflag === p.DIRECTORY && !e.name.endsWith("/")) {
+      e.name += "/";
+    } else if (e.typeflag === p.SYMLINK) {
+      e.size = 0;
+    }
+    prepareHeaderStrings(e);
+    const n = encodePax(e);
+    if (n) {
       const e = initTarHeader(null);
       e.typeflag = 120;
-      e.size = i.byteLength;
+      e.size = n.byteLength;
       yield encodeHeader(e);
-      yield i;
-      const t = blockPad(i.byteLength);
+      yield n;
+      const t = blockPad(n.byteLength);
       if (t) {
         yield w.subarray(0, t);
       }
     }
-    yield encodeHeader(t);
-    const a = e.stream();
-    if (t.size) {
-      yield* streamToAsyncIterable(a);
-    } else if (!a.locked) {
-      await a.cancel();
+    yield encodeHeader(e);
+    const i = t.stream();
+    if (e.size) {
+      yield* streamToSizedAsyncIterable(i, e.size, "Invalid Tar: Entry");
+    } else if (!i.locked) {
+      await i.cancel();
     }
-    const r = blockPad(e.size);
-    if (r) {
-      yield w.subarray(0, r);
+    const a = blockPad(e.size);
+    if (a) {
+      yield w.subarray(0, a);
     }
   }
   yield new Uint8Array(1024);