@poe-platform/safe-bash 0.1.798 → 0.1.800

package/dist/safe-bash/command-chunks/{chunk-RECJB2BO.js → chunk-7BS66BXN.js}

@@ -2,7 +2,7 @@ import {
   TsortError,
   fileQuote,
   raw
-} from "./chunk-CZVBYCB5.js";
+} from "./chunk-IL53SJL4.js";
 import {
   init_buffer
 } from "./chunk-HX3SHTCE.js";

package/dist/safe-bash/command-chunks/{chunk-GRWOVSFK.js → chunk-7D7JRRML.js}

@@ -1,6 +1,6 @@
 import {
   IconvError
-} from "./chunk-LW34AKDM.js";
+} from "./chunk-AB4MXHVS.js";
 import {
   init_buffer
 } from "./chunk-HX3SHTCE.js";

package/dist/safe-bash/command-chunks/chunk-7K6JYKPJ.js

@@ -0,0 +1,422 @@
+import {
+  init_buffer
+} from "./chunk-HX3SHTCE.js";
+
+// packages/safe-bash-command-awk/src/awk-reader.ts
+init_buffer();
+import { readBytes } from "../../safe-bash-contracts/index.js";
+import { latin1Text } from "../../safe-bash-io-engine/byte-encoding.js";
+import { ProgramError, getCachedLatin1Batch } from "../../safe-bash-io-engine/commands/text-programs/shared.js";
+var resolvedVoid = Promise.resolve();
+var RELEASED_READER_ITERATOR = {
+  next() {
+    return Promise.resolve({ done: true, value: void 0 });
+  }
+};
+var memoryReaderPool = { reader: void 0 };
+function clearAwkReaderPool() {
+  memoryReaderPool.reader = void 0;
+}
+var Reader = class _Reader {
+  constructor(source, budget, retention) {
+    this.budget = budget;
+    this.retention = retention;
+    this.iterator = source === void 0 ? RELEASED_READER_ITERATOR : typeof source.tryNextSync === "function" ? source[Symbol.asyncIterator]() : readBytes(source, budget.context.signal)[Symbol.asyncIterator]();
+  }
+  budget;
+  retention;
+  iterator;
+  blocks = [];
+  blockStrings = [];
+  blockEnds = [];
+  blocksLen = 0;
+  blockEndIdx = 0;
+  head = 0;
+  offset = 0;
+  buffered = 0;
+  ownedBytes = 0;
+  ended = false;
+  closed = false;
+  closing;
+  isPooledMemory = false;
+  activeReads = 0;
+  static fromMemoryView(chunk, budget, retention) {
+    let reader = memoryReaderPool.reader;
+    if (reader !== void 0) {
+      memoryReaderPool.reader = void 0;
+      reader.budget = budget;
+      reader.retention = retention;
+      reader.iterator = RELEASED_READER_ITERATOR;
+      reader.blocksLen = 0;
+      reader.blockEndIdx = 0;
+      reader.head = 0;
+      reader.offset = 0;
+      reader.buffered = 0;
+      reader.ownedBytes = 0;
+      reader.ended = true;
+      reader.closed = false;
+      reader.closing = void 0;
+      reader.isPooledMemory = true;
+    } else {
+      reader = new _Reader(void 0, budget, retention);
+      reader.ended = true;
+      reader.isPooledMemory = true;
+    }
+    budget.step();
+    const length = chunk.byteLength;
+    if (length > budget.maxBufferBytes) throw new ProgramError("text buffer limit exceeded");
+    if (length > 0) {
+      retention.admit(0, length);
+      try {
+        const batch = getCachedLatin1Batch(chunk);
+        const block = chunk;
+        reader.blocks[0] = block;
+        reader.blockStrings[0] = batch?.text;
+        reader.blockEnds[0] = batch?.ends;
+        reader.blocksLen = 1;
+      } catch (error) {
+        retention.release(length);
+        throw error;
+      }
+      reader.buffered = length;
+      reader.ownedBytes = length;
+    }
+    return reader;
+  }
+  get isEnded() {
+    return this.ended && this.buffered === 0;
+  }
+  retain(chunk) {
+    const length = chunk.byteLength;
+    if (length > this.budget.maxBufferBytes - this.buffered) throw new ProgramError("text buffer limit exceeded");
+    if (length === 0) return;
+    this.retention.admit(0, length);
+    try {
+      const block = chunk;
+      const batch = getCachedLatin1Batch(chunk);
+      const idx = this.blocksLen++;
+      this.blocks[idx] = block;
+      this.blockStrings[idx] = batch?.text;
+      this.blockEnds[idx] = batch?.ends;
+    } catch (error) {
+      this.retention.release(length);
+      throw error;
+    }
+    this.buffered += length;
+    this.ownedBytes += length;
+  }
+  tryFillSync() {
+    const syncIter = this.iterator;
+    if (typeof syncIter.tryNextSync !== "function") return false;
+    const signal = this.budget.context.signal;
+    while (!this.ended && !this.closed) {
+      this.budget.step();
+      if (this.head < this.blocksLen) {
+        const lastIdx = this.blocksLen - 1;
+        this.blocks[lastIdx] = new Uint8Array(this.blocks[lastIdx]);
+      }
+      const next = syncIter.tryNextSync();
+      if (this.closed) return true;
+      if (next === void 0) return false;
+      signal.throwIfAborted();
+      if (this.closed) return false;
+      if (next.done) {
+        this.ended = true;
+        return true;
+      }
+      if (next.value.byteLength === 0) continue;
+      this.retain(next.value);
+      return true;
+    }
+    return true;
+  }
+  async fill() {
+    this.budget.step();
+    const signal = this.budget.context.signal;
+    if (this.head < this.blocksLen) {
+      const lastIdx = this.blocksLen - 1;
+      this.blocks[lastIdx] = new Uint8Array(this.blocks[lastIdx]);
+    }
+    const next = await this.iterator.next();
+    signal.throwIfAborted();
+    if (this.closed) return;
+    if (next.done) {
+      this.ended = true;
+      return;
+    }
+    this.retain(next.value);
+  }
+  consume(length) {
+    this.buffered -= length;
+    while (length > 0) {
+      const block = this.blocks[this.head];
+      const available = block.length - this.offset;
+      if (length < available) {
+        this.offset += length;
+        break;
+      }
+      length -= available;
+      this.retention.release(block.length);
+      this.ownedBytes -= block.length;
+      this.blocks[this.head] = void 0;
+      this.blockStrings[this.head] = void 0;
+      this.blockEnds[this.head] = void 0;
+      this.blockEndIdx = 0;
+      this.head++;
+      this.offset = 0;
+    }
+    if (this.head === this.blocksLen) {
+      this.blocksLen = 0;
+      this.blockEndIdx = 0;
+      this.head = 0;
+    } else if (this.head >= 256 && this.head * 2 >= this.blocksLen) {
+      const rem = this.blocksLen - this.head;
+      this.blocks.copyWithin(0, this.head, this.blocksLen);
+      this.blockStrings.copyWithin(0, this.head, this.blocksLen);
+      this.blockEnds.copyWithin(0, this.head, this.blocksLen);
+      this.blocks.fill(void 0, rem, this.blocksLen);
+      this.blockStrings.fill(void 0, rem, this.blocksLen);
+      this.blockEnds.fill(void 0, rem, this.blocksLen);
+      this.blocksLen = rem;
+      this.head = 0;
+    }
+  }
+  finish(length, consumed) {
+    const firstBlock = this.blocks[this.head];
+    if (length <= firstBlock.length - this.offset) {
+      const str = this.blockStrings[this.head] ??= latin1Text(firstBlock);
+      const record2 = str.slice(this.offset, this.offset + length);
+      this.consume(consumed);
+      return record2;
+    }
+    const bytes = new Uint8Array(length);
+    let written = 0;
+    for (let index = this.head; written < length; index++) {
+      const block = this.blocks[index];
+      const start = index === this.head ? this.offset : 0;
+      const count = Math.min(length - written, block.length - start);
+      bytes.set(block.subarray(start, start + count), written);
+      written += count;
+    }
+    const record = latin1Text(bytes);
+    this.consume(consumed);
+    return record;
+  }
+  trimLeading() {
+    const block = this.blocks[this.head];
+    if (!block) return false;
+    let end = this.offset;
+    const stop = Math.min(block.length, end + 4096);
+    while (end < stop && block[end] === 10) end++;
+    const found = end < block.length && block[end] !== 10;
+    this.consume(end - this.offset);
+    return found;
+  }
+  scan(separator, state) {
+    let work = 4096;
+    while (state.block < this.blocksLen && work > 0) {
+      const block = this.blocks[state.block];
+      while (state.offset < block.length && work-- > 0) {
+        const byte = block[state.offset++];
+        const index = state.bytes++;
+        if (separator === "") {
+          if (state.paragraphEnd >= 0) {
+            if (byte !== 10) return { length: state.paragraphEnd, consumed: index };
+          } else {
+            if (byte === 10 && state.newline === index - 1) state.paragraphEnd = index - 1;
+            state.newline = byte === 10 ? index : -1;
+          }
+        } else if (byte === separator.charCodeAt(0)) return { length: index, consumed: index + 1 };
+      }
+      if (state.offset === block.length) {
+        state.block++;
+        state.offset = 0;
+      }
+    }
+    return void 0;
+  }
+  readSync(separator) {
+    if (this.closed) return void 0;
+    if (this.budget.context.signal.aborted) this.budget.context.signal.throwIfAborted();
+    if (separator.length > 1) throw new ProgramError("RS must be one byte or empty for paragraph records");
+    if (separator.length === 1 && !this.closed && this.head < this.blocksLen) {
+      const headBlock = this.blocks[this.head];
+      const idx = headBlock.indexOf(separator.charCodeAt(0), this.offset);
+      if (idx >= 0 && idx - this.offset < 4096) {
+        this.budget.step();
+        const str = this.blockStrings[this.head] ??= latin1Text(headBlock);
+        const record = str.slice(this.offset, idx);
+        this.consume(idx - this.offset + 1);
+        return record;
+      }
+    }
+    return this.read(separator);
+  }
+  readSliceSync(separator, out) {
+    if (this.closed) return false;
+    if (this.budget.context.signal.aborted) this.budget.context.signal.throwIfAborted();
+    if (separator.length === 1 && !this.closed) {
+      if (this.head >= this.blocksLen && !this.ended) {
+        this.tryFillSync();
+      }
+      if (this.head < this.blocksLen) {
+        const headBlock = this.blocks[this.head];
+        const sepCode = separator.charCodeAt(0);
+        const cachedEnds = sepCode === 10 ? this.blockEnds[this.head] : void 0;
+        if (cachedEnds !== void 0) {
+          let eIdx = this.blockEndIdx;
+          while (eIdx < cachedEnds.length && cachedEnds[eIdx] < this.offset) eIdx++;
+          if (eIdx < cachedEnds.length) {
+            const idx2 = cachedEnds[eIdx];
+            if (idx2 - this.offset < 4096) {
+              this.blockEndIdx = eIdx + 1;
+              out.source = this.blockStrings[this.head] ??= latin1Text(headBlock);
+              out.start = this.offset;
+              out.end = idx2;
+              this.consume(idx2 - this.offset + 1);
+              return true;
+            }
+          }
+        }
+        const idx = headBlock.indexOf(sepCode, this.offset);
+        if (idx >= 0 && idx - this.offset < 4096) {
+          out.source = this.blockStrings[this.head] ??= latin1Text(headBlock);
+          out.start = this.offset;
+          out.end = idx;
+          this.consume(idx - this.offset + 1);
+          return true;
+        }
+        if (idx < 0 && this.head + 1 === this.blocksLen && !this.ended) {
+          this.tryFillSync();
+          if (this.head + 1 === this.blocksLen && this.ended && headBlock.length - this.offset < 4096) {
+            out.source = this.blockStrings[this.head] ??= latin1Text(headBlock);
+            out.start = this.offset;
+            out.end = headBlock.length;
+            this.consume(headBlock.length - this.offset);
+            return true;
+          }
+        }
+      }
+    }
+    return false;
+  }
+  async read(separator) {
+    this.activeReads++;
+    try {
+      if (this.closed) return void 0;
+      const budget = this.budget;
+      budget.context.signal.throwIfAborted();
+      if (separator.length > 1) throw new ProgramError("RS must be one byte or empty for paragraph records");
+      if (separator.length === 1 && !this.closed && this.head < this.blocksLen) {
+        const headBlock = this.blocks[this.head];
+        const idx = headBlock.indexOf(separator.charCodeAt(0), this.offset);
+        if (idx >= 0 && idx - this.offset < 4096) {
+          budget.step();
+          const record = latin1Text(headBlock.subarray(this.offset, idx));
+          this.consume(idx - this.offset + 1);
+          return record;
+        }
+      }
+      if (separator === "") {
+        while (!this.closed) {
+          budget.step();
+          if (this.trimLeading()) break;
+          if (this.buffered === 0) {
+            if (this.ended) return void 0;
+            await this.fill();
+          }
+          if (this.closed) return void 0;
+          const pendingCheck = budget.checkpointSync();
+          if (pendingCheck) await pendingCheck;
+        }
+      }
+      const state = { block: this.head, offset: this.offset, bytes: 0, newline: -1, paragraphEnd: -1 };
+      while (true) {
+        if (this.closed) return void 0;
+        budget.step();
+        const found = this.scan(separator, state);
+        if (found) return this.finish(found.length, found.consumed);
+        if (state.block === this.blocksLen) {
+          if (this.ended) {
+            if (this.buffered === 0) return void 0;
+            const length = separator !== "" ? this.buffered : state.paragraphEnd >= 0 ? state.paragraphEnd : state.newline === this.buffered - 1 ? this.buffered - 1 : this.buffered;
+            return this.finish(length, this.buffered);
+          }
+          await this.fill();
+        }
+        if (this.closed) return void 0;
+        const pendingCheck = budget.checkpointSync();
+        if (pendingCheck) await pendingCheck;
+      }
+    } finally {
+      this.activeReads--;
+    }
+  }
+  close() {
+    if (this.closing) return this.closing;
+    const wasEnded = this.ended;
+    this.closed = true;
+    this.ended = true;
+    if (this.blocksLen > 0) {
+      this.blocks.fill(void 0, 0, this.blocksLen);
+      this.blockStrings.fill(void 0, 0, this.blocksLen);
+      this.blockEnds.fill(void 0, 0, this.blocksLen);
+      this.blocksLen = 0;
+    }
+    this.head = this.offset = this.buffered = 0;
+    this.retention.release(this.ownedBytes);
+    this.ownedBytes = 0;
+    const origIter = this.iterator;
+    this.iterator = RELEASED_READER_ITERATOR;
+    this.budget = void 0;
+    this.retention = void 0;
+    if (this.isPooledMemory && this.activeReads === 0 && memoryReaderPool.reader === void 0) {
+      this.isPooledMemory = false;
+      memoryReaderPool.reader = this;
+    }
+    if (wasEnded || !origIter.return) {
+      this.closing = resolvedVoid;
+      return resolvedVoid;
+    }
+    this.closing = Promise.resolve().then(async () => {
+      await origIter.return?.();
+    });
+    return this.closing;
+  }
+  closeSyncOrAsync() {
+    if (this.closing) return this.closing === resolvedVoid ? void 0 : this.closing;
+    const wasEnded = this.ended;
+    this.closed = true;
+    this.ended = true;
+    if (this.blocksLen > 0) {
+      this.blocks.fill(void 0, 0, this.blocksLen);
+      this.blockStrings.fill(void 0, 0, this.blocksLen);
+      this.blockEnds.fill(void 0, 0, this.blocksLen);
+      this.blocksLen = 0;
+    }
+    this.head = this.offset = this.buffered = 0;
+    this.retention.release(this.ownedBytes);
+    this.ownedBytes = 0;
+    const origIter = this.iterator;
+    this.iterator = RELEASED_READER_ITERATOR;
+    this.budget = void 0;
+    this.retention = void 0;
+    if (this.isPooledMemory && this.activeReads === 0 && memoryReaderPool.reader === void 0) {
+      this.isPooledMemory = false;
+      memoryReaderPool.reader = this;
+    }
+    if (wasEnded || !origIter.return) {
+      this.closing = resolvedVoid;
+      return void 0;
+    }
+    this.closing = Promise.resolve().then(async () => {
+      await origIter.return?.();
+    });
+    return this.closing;
+  }
+};
+
+export {
+  clearAwkReaderPool,
+  Reader
+};

package/dist/safe-bash/command-chunks/{chunk-E6IYUYVA.js → chunk-7L24L4UO.js}

@@ -1,9 +1,9 @@
 import {
   htmlSpace
-} from "./chunk-5EWTQJSC.js";
+} from "./chunk-HHP343KT.js";
 import {
   Builder
-} from "./chunk-25BLI6S6.js";
+} from "./chunk-4Y3WVMK4.js";
 import {
   init_buffer
 } from "./chunk-HX3SHTCE.js";

package/dist/safe-bash/command-chunks/chunk-7N2LI2KO.js

@@ -0,0 +1,206 @@
+import {
+  init_buffer
+} from "./chunk-HX3SHTCE.js";
+
+// packages/safe-bash-command-tar/src/format.ts
+init_buffer();
+import { byteLength, concatBytes, decodeBytes, encodeBytes } from "../../safe-bash-io-engine/byte-encoding.js";
+import { checkPath, fail, text } from "../../safe-bash-io-engine/commands/archive/internal.js";
+function numberField(header, offset, width, signed = false) {
+  const bytes = header.subarray(offset, offset + width);
+  let value;
+  if (bytes[0] & 128) {
+    value = BigInt(bytes[0] & 127);
+    for (const byte of bytes.subarray(1)) value = value * 256n + BigInt(byte);
+    if (bytes[0] & 64) value -= 1n << BigInt(width * 8 - 1);
+  } else {
+    const digits = decodeBytes(encodeBytes(bytes), "latin1").replace(/^[ \0]+|[ \0]+$/gu, "");
+    if (digits && !/^[0-7]+$/u.test(digits)) fail("invalid octal numeric field");
+    value = digits ? BigInt(`0o${digits}`) : 0n;
+  }
+  const result = Number(value);
+  if (!Number.isSafeInteger(result) || !signed && result < 0) fail("invalid or oversized numeric field");
+  return result;
+}
+function stringField(header, offset, width) {
+  const bytes = header.subarray(offset, offset + width);
+  const end = bytes.indexOf(0);
+  return text(end === -1 ? bytes : bytes.subarray(0, end));
+}
+function parseHeader(header) {
+  if (header.length !== 512) fail("invalid header size");
+  const expected = numberField(header, 148, 8);
+  let actual = 0;
+  for (let offset = 0; offset < 512; offset++) actual += offset >= 148 && offset < 156 ? 32 : header[offset];
+  if (actual !== expected) fail("header checksum mismatch");
+  const magic = decodeBytes(encodeBytes(header.subarray(257, 265)), "latin1");
+  const posix = magic === "ustar\x0000";
+  if (!posix && magic !== "ustar  \0") fail("unsupported archive format (expected USTAR, PAX, or GNU basic headers)");
+  const entry = {
+    bytes: header,
+    posix,
+    type: header[156] === 0 ? "0" : String.fromCharCode(header[156]),
+    mode: numberField(header, 100, 8)
+  };
+  numberField(header, 329, 8);
+  numberField(header, 337, 8);
+  if (entry.mode > 4095) fail("invalid archive permission bits");
+  return entry;
+}
+function octal(header, offset, width, value) {
+  if (!Number.isSafeInteger(value) || value < 0 || value.toString(8).length >= width) fail("number does not fit USTAR field");
+  header.set(encodeBytes(value.toString(8).padStart(width - 1, "0")), offset);
+}
+function splitName(name) {
+  if (!/^[\x01-\x7f]*$/u.test(name)) return void 0;
+  if (byteLength(name) <= 100) return [name, ""];
+  for (let offset = name.length - 2; offset > 0; offset--) {
+    if (name[offset] === "/" && byteLength(name.slice(0, offset)) <= 155 && byteLength(name.slice(offset + 1)) <= 100) {
+      return [name.slice(offset + 1), name.slice(0, offset)];
+    }
+  }
+  return void 0;
+}
+function headerBytes(entry) {
+  const split = splitName(entry.name);
+  if (!split) fail("name does not fit USTAR header");
+  if (byteLength(entry.linkname) > 100) fail("link does not fit USTAR header");
+  const header = new Uint8Array(512);
+  header.set(encodeBytes(split[0]), 0);
+  header.set(encodeBytes(split[1]), 345);
+  octal(header, 100, 8, entry.mode);
+  octal(header, 108, 8, entry.uid);
+  octal(header, 116, 8, entry.gid);
+  octal(header, 124, 12, entry.size);
+  octal(header, 136, 12, entry.mtime);
+  header.fill(32, 148, 156);
+  header[156] = entry.type.charCodeAt(0);
+  header.set(encodeBytes(entry.linkname), 157);
+  header.set(encodeBytes("ustar\x0000"), 257);
+  octal(header, 329, 8, 0);
+  octal(header, 337, 8, 0);
+  const checksum = header.reduce((sum, byte) => sum + byte, 0);
+  header.set(encodeBytes(`${checksum.toString(8).padStart(6, "0")}\0 `), 148);
+  return header;
+}
+function paxRecord(key, value) {
+  const payload = ` ${key}=${value}
+`;
+  const bytes = byteLength(payload);
+  let size = bytes + 1;
+  while (size !== bytes + String(size).length) size = bytes + String(size).length;
+  return encodeBytes(`${size}${payload}`);
+}
+function encodeEntry(entry, limits) {
+  checkPath(entry.name, limits);
+  if (entry.linkname) checkPath(entry.linkname, limits);
+  const base = { ...entry };
+  if (!Number.isFinite(entry.mtime) || Math.abs(entry.mtime * 1e3) > 864e13) fail("invalid source mtime");
+  const records = [];
+  if (!splitName(base.name)) {
+    records.push(paxRecord("path", base.name));
+    base.name = "PaxEntry";
+  }
+  if (byteLength(base.linkname) > 100 || /[^\x01-\x7f]/u.test(base.linkname)) {
+    records.push(paxRecord("linkpath", base.linkname));
+    base.linkname = "PaxLink";
+  }
+  for (const key of ["uid", "gid", "size", "mtime"]) {
+    const value = base[key];
+    const maximum = key === "uid" || key === "gid" ? 2097151 : 8589934591;
+    if (!Number.isFinite(value) || key !== "mtime" && (!Number.isSafeInteger(value) || value < 0)) fail(`invalid source ${key}`);
+    if (!Number.isInteger(value) || value < 0 || value > maximum) {
+      records.push(paxRecord(key, key === "mtime" ? decimalTime(value) : String(value)));
+      base[key] = 0;
+    }
+  }
+  if (entry.atime !== void 0) {
+    if (!Number.isFinite(entry.atime) || Math.abs(entry.atime * 1e3) > 864e13) fail("invalid source atime");
+    records.push(paxRecord("atime", decimalTime(entry.atime)));
+  }
+  if (!records.length) return [headerBytes(base)];
+  const payload = concatBytes(records);
+  if (payload.length > limits.maxPaxBytes) fail("PAX header byte limit exceeded");
+  const extension = headerBytes({ ...base, name: "PaxHeader", linkname: "", type: "x", size: payload.length, mode: 420 });
+  return [extension, payload, new Uint8Array((512 - payload.length % 512) % 512), headerBytes(base)];
+}
+function decimalTime(value) {
+  return value.toFixed(9).replace(/(\.[0-9]*?)0+$/u, "$1").replace(/\.$/u, "");
+}
+var supportedKeywords = /* @__PURE__ */ new Set(["path", "linkpath", "size", "uid", "gid", "mtime", "atime", "ctime", "uname", "gname", "comment", "charset", "hdrcharset"]);
+var optionalKeywords = /* @__PURE__ */ new Set(["SCHILY.fflags", "LIBARCHIVE.creationtime"]);
+var optionalKeywordPrefixes = ["LIBARCHIVE.xattr.", "SCHILY.xattr."];
+function parsePax(payload) {
+  const result = /* @__PURE__ */ new Map();
+  let offset = 0;
+  while (offset < payload.length) {
+    let space = offset;
+    while (space < payload.length && payload[space] !== 32 && space - offset < 16) space++;
+    const digits = decodeBytes(encodeBytes(payload.subarray(offset, space)), "latin1");
+    if (!/^[1-9][0-9]*$/u.test(digits) || payload[space] !== 32) fail("invalid PAX record length");
+    const size = Number(digits);
+    if (!Number.isSafeInteger(size) || size <= space - offset + 3 || size > payload.length - offset || payload[offset + size - 1] !== 10) fail("invalid PAX record framing");
+    const record = payload.subarray(space + 1, offset + size - 1);
+    const equals = record.indexOf(61);
+    if (equals <= 0) fail("invalid PAX key/value");
+    const key = text(record.subarray(0, equals));
+    if (/[\0\n]/u.test(key)) fail("invalid PAX key/value");
+    offset += size;
+    if (optionalKeywords.has(key) || optionalKeywordPrefixes.some((prefix) => key.startsWith(prefix) && key.length > prefix.length)) continue;
+    if (!supportedKeywords.has(key)) fail(`unsupported PAX keyword: ${key}`);
+    const value = text(record.subarray(equals + 1));
+    if (value.includes("\0")) fail("invalid PAX key/value");
+    if (key === "hdrcharset" && value !== "" && value !== "ISO-IR 10646 2000 UTF-8") fail("unsupported PAX header charset");
+    result.set(key, value);
+  }
+  return result;
+}
+function applyPax(header, global, local, longName, longLink) {
+  const merged = new Map(global);
+  for (const [key, value] of local) merged.set(key, value);
+  for (const [key, value] of merged) {
+    if (value === "") continue;
+    if (key === "uid" || key === "gid" || key === "size") {
+      if (!/^[0-9]+$/u.test(value) || !Number.isSafeInteger(Number(value))) fail(`invalid PAX ${key}`);
+    } else if (key === "mtime" || key === "atime" || key === "ctime") {
+      if (!/^-?[0-9]+(?:\.[0-9]+)?$/u.test(value) || !Number.isFinite(Number(value)) || Math.abs(Number(value) * 1e3) > 864e13) fail(`invalid PAX ${key}`);
+    }
+  }
+  const numeric = (key, raw) => {
+    if (!merged.has(key)) return raw();
+    const value = merged.get(key);
+    return value === "" ? void 0 : Number(value);
+  };
+  const name = merged.has("path") ? merged.get("path") : longName ?? (() => {
+    const prefix = header.posix ? stringField(header.bytes, 345, 155) : "";
+    const raw = stringField(header.bytes, 0, 100);
+    return prefix ? `${prefix}/${raw}` : raw;
+  })();
+  if (!name) fail("missing effective path");
+  const linkname = merged.has("linkpath") ? merged.get("linkpath") : longLink ?? stringField(header.bytes, 157, 100);
+  if ((header.type === "1" || header.type === "2") && !linkname) fail("missing effective linkpath");
+  const size = numeric("size", () => numberField(header.bytes, 124, 12));
+  if (size === void 0) fail("missing effective size");
+  return {
+    name,
+    linkname,
+    size,
+    type: header.type,
+    mode: header.mode,
+    uid: numeric("uid", () => numberField(header.bytes, 108, 8)),
+    gid: numeric("gid", () => numberField(header.bytes, 116, 8)),
+    mtime: numeric("mtime", () => numberField(header.bytes, 136, 12, true)),
+    atime: numeric("atime", () => void 0),
+    atimeDeleted: merged.get("atime") === ""
+  };
+}
+
+export {
+  numberField,
+  parseHeader,
+  headerBytes,
+  paxRecord,
+  encodeEntry,
+  parsePax,
+  applyPax
+};