@gjsify/tar 0.3.12 → 0.3.14

package/lib/esm/extract.js

@@ -1,102 +1,105 @@
+import { parseTar } from "./parser.js";
 import * as fs from "node:fs";
 import * as path from "node:path";
-import { parseTar } from "./parser.js";
+
+//#region src/extract.ts
+/** Extract a `.tar` or `.tar.gz` buffer into `destDir`, creating dirs as needed. */
 async function extractTarball(input, destDir, opts = {}) {
-  const buf = input instanceof Uint8Array ? input : new Uint8Array(input);
-  const isGz = opts.gzip ?? (buf.length >= 2 && buf[0] === 31 && buf[1] === 139);
-  const tarBytes = isGz ? await gunzip(buf) : buf;
-  const entries = parseTar(tarBytes);
-  fs.mkdirSync(destDir, { recursive: true });
-  const strip = opts.strip ?? 1;
-  const preventEscape = opts.preventEscape ?? true;
-  const result = { files: [], directories: [], symlinks: [], skipped: 0 };
-  for (const entry of entries) {
-    const stripped = stripComponents(entry.name, strip);
-    if (stripped === null || stripped === "") {
-      result.skipped++;
-      continue;
-    }
-    const resolved = path.resolve(destDir, stripped);
-    if (preventEscape && !isInside(resolved, destDir)) {
-      throw new Error(
-        `tar: refusing to extract ${entry.name} outside ${destDir} (resolved=${resolved})`
-      );
-    }
-    if (opts.filter && !opts.filter(entry, resolved)) {
-      result.skipped++;
-      continue;
-    }
-    if (entry.type === "directory") {
-      fs.mkdirSync(resolved, { recursive: true });
-      result.directories.push(resolved);
-      continue;
-    }
-    if (entry.type === "file") {
-      fs.mkdirSync(path.dirname(resolved), { recursive: true });
-      fs.writeFileSync(resolved, entry.body);
-      const overrideMode = opts.chmod?.(entry, resolved);
-      const finalMode = overrideMode ?? entry.mode & 511;
-      if (finalMode > 0) {
-        try {
-          fs.chmodSync(resolved, finalMode);
-        } catch {
-        }
-      }
-      result.files.push(resolved);
-      continue;
-    }
-    if (entry.type === "symlink") {
-      fs.mkdirSync(path.dirname(resolved), { recursive: true });
-      try {
-        fs.symlinkSync(entry.linkname, resolved);
-        result.symlinks.push(resolved);
-      } catch {
-        fs.writeFileSync(resolved, entry.linkname);
-        result.files.push(resolved);
-      }
-      continue;
-    }
-    result.skipped++;
-  }
-  return result;
+	const buf = input instanceof Uint8Array ? input : new Uint8Array(input);
+	const isGz = opts.gzip ?? (buf.length >= 2 && buf[0] === 31 && buf[1] === 139);
+	const tarBytes = isGz ? await gunzip(buf) : buf;
+	const entries = parseTar(tarBytes);
+	fs.mkdirSync(destDir, { recursive: true });
+	const strip = opts.strip ?? 1;
+	const preventEscape = opts.preventEscape ?? true;
+	const result = {
+		files: [],
+		directories: [],
+		symlinks: [],
+		skipped: 0
+	};
+	for (const entry of entries) {
+		const stripped = stripComponents(entry.name, strip);
+		if (stripped === null || stripped === "") {
+			result.skipped++;
+			continue;
+		}
+		const resolved = path.resolve(destDir, stripped);
+		if (preventEscape && !isInside(resolved, destDir)) {
+			throw new Error(`tar: refusing to extract ${entry.name} outside ${destDir} (resolved=${resolved})`);
+		}
+		if (opts.filter && !opts.filter(entry, resolved)) {
+			result.skipped++;
+			continue;
+		}
+		if (entry.type === "directory") {
+			fs.mkdirSync(resolved, { recursive: true });
+			result.directories.push(resolved);
+			continue;
+		}
+		if (entry.type === "file") {
+			fs.mkdirSync(path.dirname(resolved), { recursive: true });
+			fs.writeFileSync(resolved, entry.body);
+			const overrideMode = opts.chmod?.(entry, resolved);
+			const finalMode = overrideMode ?? entry.mode & 511;
+			if (finalMode > 0) {
+				try {
+					fs.chmodSync(resolved, finalMode);
+				} catch {}
+			}
+			result.files.push(resolved);
+			continue;
+		}
+		if (entry.type === "symlink") {
+			fs.mkdirSync(path.dirname(resolved), { recursive: true });
+			try {
+				fs.symlinkSync(entry.linkname, resolved);
+				result.symlinks.push(resolved);
+			} catch {
+				fs.writeFileSync(resolved, entry.linkname);
+				result.files.push(resolved);
+			}
+			continue;
+		}
+		result.skipped++;
+	}
+	return result;
 }
+/** Decompress a gzip buffer using Web DecompressionStream (cross-platform). */
 async function gunzip(input) {
-  const Decomp = globalThis.DecompressionStream;
-  if (typeof Decomp !== "function") {
-    throw new Error(
-      "@gjsify/tar: globalThis.DecompressionStream is not available \u2014 import '@gjsify/compression-streams/register' on GJS to register it"
-    );
-  }
-  const stream = new Blob([new Uint8Array(input)]).stream().pipeThrough(new Decomp("gzip"));
-  const chunks = [];
-  let total = 0;
-  const reader = stream.getReader();
-  for (; ; ) {
-    const { value, done } = await reader.read();
-    if (done) break;
-    const chunk = value instanceof Uint8Array ? value : new Uint8Array(value);
-    chunks.push(chunk);
-    total += chunk.length;
-  }
-  const out = new Uint8Array(total);
-  let pos = 0;
-  for (const c of chunks) {
-    out.set(c, pos);
-    pos += c.length;
-  }
-  return out;
+	const Decomp = globalThis.DecompressionStream;
+	if (typeof Decomp !== "function") {
+		throw new Error("@gjsify/tar: globalThis.DecompressionStream is not available — " + "import '@gjsify/compression-streams/register' on GJS to register it");
+	}
+	const stream = new Blob([new Uint8Array(input)]).stream().pipeThrough(new Decomp("gzip"));
+	const chunks = [];
+	let total = 0;
+	const reader = stream.getReader();
+	for (;;) {
+		const { value, done } = await reader.read();
+		if (done) break;
+		const chunk = value instanceof Uint8Array ? value : new Uint8Array(value);
+		chunks.push(chunk);
+		total += chunk.length;
+	}
+	const out = new Uint8Array(total);
+	let pos = 0;
+	for (const c of chunks) {
+		out.set(c, pos);
+		pos += c.length;
+	}
+	return out;
 }
 function stripComponents(name, n) {
-  if (n <= 0) return name;
-  const parts = name.split("/").filter((s) => s !== "");
-  if (parts.length <= n) return null;
-  return parts.slice(n).join("/");
+	if (n <= 0) return name;
+	const parts = name.split("/").filter((s) => s !== "");
+	if (parts.length <= n) return null;
+	return parts.slice(n).join("/");
 }
 function isInside(child, parent) {
-  const rel = path.relative(parent, child);
-  return rel !== "" && !rel.startsWith("..") && !path.isAbsolute(rel);
+	const rel = path.relative(parent, child);
+	return rel !== "" && !rel.startsWith("..") && !path.isAbsolute(rel);
 }
-export {
-  extractTarball,
-  gunzip
-};
+
+//#endregion
+export { extractTarball, gunzip };

package/lib/esm/index.js

@@ -1,13 +1,4 @@
-import {
-  BLOCK_SIZE,
-  parseTar,
-  TarParseError
-} from "./parser.js";
+import { BLOCK_SIZE, TarParseError, parseTar } from "./parser.js";
 import { extractTarball, gunzip } from "./extract.js";
-export {
-  BLOCK_SIZE,
-  TarParseError,
-  extractTarball,
-  gunzip,
-  parseTar
-};
+
+export { BLOCK_SIZE, TarParseError, extractTarball, gunzip, parseTar };

package/lib/esm/parser.js

@@ -1,199 +1,188 @@
+//#region src/parser.ts
 const BLOCK_SIZE = 512;
+/** Parse a tar archive (already-uncompressed) into entries. */
 function parseTar(buf) {
-  const out = [];
-  let pendingPaxHeader = null;
-  let pendingLongName = null;
-  let pendingLongLink = null;
-  let offset = 0;
-  while (offset + BLOCK_SIZE <= buf.length) {
-    const header = buf.subarray(offset, offset + BLOCK_SIZE);
-    if (allZeros(header)) {
-      const next = buf.subarray(offset + BLOCK_SIZE, offset + 2 * BLOCK_SIZE);
-      if (next.length === BLOCK_SIZE && allZeros(next)) break;
-      offset += BLOCK_SIZE;
-      continue;
-    }
-    if (!validateChecksum(header)) {
-      throw new TarParseError(
-        `Bad header checksum at offset ${offset} \u2014 file is not a valid tar archive`
-      );
-    }
-    const rawName = readString(header, 0, 100);
-    const mode = parseOctal(header, 100, 8);
-    const size = parseOctal(header, 124, 12);
-    const mtime = parseOctal(header, 136, 12);
-    const typeflag = String.fromCharCode(header[156] || 0);
-    const linkname = readString(header, 157, 100);
-    const magic = readString(header, 257, 6);
-    const prefix = readString(header, 345, 155);
-    const uname = readString(header, 265, 32);
-    const gname = readString(header, 297, 32);
-    offset += BLOCK_SIZE;
-    const body = buf.subarray(offset, offset + size);
-    offset += alignToBlock(size);
-    if (typeflag === "x") {
-      pendingPaxHeader = parsePaxRecords(body);
-      continue;
-    }
-    if (typeflag === "g") {
-      continue;
-    }
-    if (typeflag === "L") {
-      pendingLongName = bytesToString(body).replace(/\0+$/, "");
-      continue;
-    }
-    if (typeflag === "K") {
-      pendingLongLink = bytesToString(body).replace(/\0+$/, "");
-      continue;
-    }
-    let name = rawName;
-    if (magic === "ustar" && prefix !== "") {
-      name = `${prefix}/${rawName}`;
-    }
-    if (pendingLongName !== null) {
-      name = pendingLongName;
-      pendingLongName = null;
-    }
-    let resolvedLink = linkname;
-    if (pendingLongLink !== null) {
-      resolvedLink = pendingLongLink;
-      pendingLongLink = null;
-    }
-    if (pendingPaxHeader !== null) {
-      const paxName = pendingPaxHeader.get("path");
-      if (paxName !== void 0) name = paxName;
-      const paxLink = pendingPaxHeader.get("linkpath");
-      if (paxLink !== void 0) resolvedLink = paxLink;
-      const paxSize = pendingPaxHeader.get("size");
-      if (paxSize !== void 0) {
-        const overrideSize = Number(paxSize);
-        if (Number.isFinite(overrideSize)) {
-          const realStart = offset - alignToBlock(size);
-          const sliced = buf.subarray(realStart, realStart + overrideSize);
-          offset = realStart + alignToBlock(overrideSize);
-          pendingPaxHeader = null;
-          out.push(buildEntry(name, resolvedLink, typeflag, mode, mtime, uname, gname, sliced));
-          continue;
-        }
-      }
-      pendingPaxHeader = null;
-    }
-    out.push(buildEntry(name, resolvedLink, typeflag, mode, mtime, uname, gname, body));
-  }
-  return out;
+	const out = [];
+	let pendingPaxHeader = null;
+	let pendingLongName = null;
+	let pendingLongLink = null;
+	let offset = 0;
+	while (offset + 512 <= buf.length) {
+		const header = buf.subarray(offset, offset + 512);
+		if (allZeros(header)) {
+			const next = buf.subarray(offset + 512, offset + 2 * 512);
+			if (next.length === 512 && allZeros(next)) break;
+			offset += 512;
+			continue;
+		}
+		if (!validateChecksum(header)) {
+			throw new TarParseError(`Bad header checksum at offset ${offset} — file is not a valid tar archive`);
+		}
+		const rawName = readString(header, 0, 100);
+		const mode = parseOctal(header, 100, 8);
+		const size = parseOctal(header, 124, 12);
+		const mtime = parseOctal(header, 136, 12);
+		const typeflag = String.fromCharCode(header[156] || 0);
+		const linkname = readString(header, 157, 100);
+		const magic = readString(header, 257, 6);
+		const prefix = readString(header, 345, 155);
+		const uname = readString(header, 265, 32);
+		const gname = readString(header, 297, 32);
+		offset += 512;
+		const body = buf.subarray(offset, offset + size);
+		offset += alignToBlock(size);
+		if (typeflag === "x") {
+			pendingPaxHeader = parsePaxRecords(body);
+			continue;
+		}
+		if (typeflag === "g") {
+			continue;
+		}
+		if (typeflag === "L") {
+			pendingLongName = bytesToString(body).replace(/\0+$/, "");
+			continue;
+		}
+		if (typeflag === "K") {
+			pendingLongLink = bytesToString(body).replace(/\0+$/, "");
+			continue;
+		}
+		let name = rawName;
+		if (magic === "ustar" && prefix !== "") {
+			name = `${prefix}/${rawName}`;
+		}
+		if (pendingLongName !== null) {
+			name = pendingLongName;
+			pendingLongName = null;
+		}
+		let resolvedLink = linkname;
+		if (pendingLongLink !== null) {
+			resolvedLink = pendingLongLink;
+			pendingLongLink = null;
+		}
+		if (pendingPaxHeader !== null) {
+			const paxName = pendingPaxHeader.get("path");
+			if (paxName !== undefined) name = paxName;
+			const paxLink = pendingPaxHeader.get("linkpath");
+			if (paxLink !== undefined) resolvedLink = paxLink;
+			const paxSize = pendingPaxHeader.get("size");
+			if (paxSize !== undefined) {
+				const overrideSize = Number(paxSize);
+				if (Number.isFinite(overrideSize)) {
+					const realStart = offset - alignToBlock(size);
+					const sliced = buf.subarray(realStart, realStart + overrideSize);
+					offset = realStart + alignToBlock(overrideSize);
+					pendingPaxHeader = null;
+					out.push(buildEntry(name, resolvedLink, typeflag, mode, mtime, uname, gname, sliced));
+					continue;
+				}
+			}
+			pendingPaxHeader = null;
+		}
+		out.push(buildEntry(name, resolvedLink, typeflag, mode, mtime, uname, gname, body));
+	}
+	return out;
 }
 function buildEntry(name, linkname, typeflag, mode, mtime, uname, gname, body) {
-  return {
-    name,
-    linkname,
-    type: typeflagToType(typeflag, name),
-    mode,
-    mtime,
-    body,
-    uname,
-    gname
-  };
+	return {
+		name,
+		linkname,
+		type: typeflagToType(typeflag, name),
+		mode,
+		mtime,
+		body,
+		uname,
+		gname
+	};
 }
 function typeflagToType(typeflag, name) {
-  switch (typeflag) {
-    case "0":
-    case "\0":
-    case "":
-      return name.endsWith("/") ? "directory" : "file";
-    case "1":
-      return "hardlink";
-    case "2":
-      return "symlink";
-    case "5":
-      return "directory";
-    case "x":
-      return "pax-header";
-    case "g":
-      return "pax-global";
-    case "L":
-      return "gnu-longname";
-    case "K":
-      return "gnu-longlink";
-    default:
-      return "unknown";
-  }
+	switch (typeflag) {
+		case "0":
+		case "\0":
+		case "": return name.endsWith("/") ? "directory" : "file";
+		case "1": return "hardlink";
+		case "2": return "symlink";
+		case "5": return "directory";
+		case "x": return "pax-header";
+		case "g": return "pax-global";
+		case "L": return "gnu-longname";
+		case "K": return "gnu-longlink";
+		default: return "unknown";
+	}
 }
 function parsePaxRecords(body) {
-  const out = /* @__PURE__ */ new Map();
-  let i = 0;
-  while (i < body.length) {
-    let space = i;
-    while (space < body.length && body[space] !== 32) space++;
-    if (space >= body.length) break;
-    const lenStr = bytesToString(body.subarray(i, space));
-    const len = Number(lenStr);
-    if (!Number.isFinite(len) || len <= 0) break;
-    const recordEnd = i + len;
-    if (recordEnd > body.length) break;
-    const recBytes = body.subarray(space + 1, recordEnd - 1);
-    const recText = bytesToString(recBytes);
-    const eq = recText.indexOf("=");
-    if (eq > 0) {
-      const key = recText.slice(0, eq);
-      const value = recText.slice(eq + 1);
-      out.set(key, value);
-    }
-    i = recordEnd;
-  }
-  return out;
+	const out = new Map();
+	let i = 0;
+	while (i < body.length) {
+		let space = i;
+		while (space < body.length && body[space] !== 32) space++;
+		if (space >= body.length) break;
+		const lenStr = bytesToString(body.subarray(i, space));
+		const len = Number(lenStr);
+		if (!Number.isFinite(len) || len <= 0) break;
+		const recordEnd = i + len;
+		if (recordEnd > body.length) break;
+		const recBytes = body.subarray(space + 1, recordEnd - 1);
+		const recText = bytesToString(recBytes);
+		const eq = recText.indexOf("=");
+		if (eq > 0) {
+			const key = recText.slice(0, eq);
+			const value = recText.slice(eq + 1);
+			out.set(key, value);
+		}
+		i = recordEnd;
+	}
+	return out;
 }
 function readString(buf, start, len) {
-  let end = start;
-  const limit = start + len;
-  while (end < limit && buf[end] !== 0) end++;
-  return bytesToString(buf.subarray(start, end));
+	let end = start;
+	const limit = start + len;
+	while (end < limit && buf[end] !== 0) end++;
+	return bytesToString(buf.subarray(start, end));
 }
 function bytesToString(buf) {
-  return new TextDecoder("utf-8", { fatal: false }).decode(buf);
+	return new TextDecoder("utf-8", { fatal: false }).decode(buf);
 }
 function parseOctal(buf, start, len) {
-  if (len > 0 && (buf[start] & 128) !== 0) {
-    let n = buf[start] & 127;
-    for (let i = 1; i < len; i++) n = n * 256 + buf[start + i];
-    return n;
-  }
-  let s = "";
-  for (let i = 0; i < len; i++) {
-    const c = buf[start + i];
-    if (c === 0 || c === 32) continue;
-    s += String.fromCharCode(c);
-  }
-  if (s === "") return 0;
-  return parseInt(s, 8);
+	if (len > 0 && (buf[start] & 128) !== 0) {
+		let n = buf[start] & 127;
+		for (let i = 1; i < len; i++) n = n * 256 + buf[start + i];
+		return n;
+	}
+	let s = "";
+	for (let i = 0; i < len; i++) {
+		const c = buf[start + i];
+		if (c === 0 || c === 32) continue;
+		s += String.fromCharCode(c);
+	}
+	if (s === "") return 0;
+	return parseInt(s, 8);
 }
 function alignToBlock(n) {
-  return Math.ceil(n / BLOCK_SIZE) * BLOCK_SIZE;
+	return Math.ceil(n / 512) * 512;
 }
 function allZeros(buf) {
-  for (let i = 0; i < buf.length; i++) {
-    if (buf[i] !== 0) return false;
-  }
-  return true;
+	for (let i = 0; i < buf.length; i++) {
+		if (buf[i] !== 0) return false;
+	}
+	return true;
 }
 function validateChecksum(header) {
-  const stored = parseOctal(header, 148, 8);
-  let unsigned = 0;
-  let signed = 0;
-  for (let i = 0; i < BLOCK_SIZE; i++) {
-    const byte = i >= 148 && i < 156 ? 32 : header[i];
-    unsigned += byte;
-    signed += byte > 127 ? byte - 256 : byte;
-  }
-  return stored === unsigned || stored === signed;
+	const stored = parseOctal(header, 148, 8);
+	let unsigned = 0;
+	let signed = 0;
+	for (let i = 0; i < 512; i++) {
+		const byte = i >= 148 && i < 156 ? 32 : header[i];
+		unsigned += byte;
+		signed += byte > 127 ? byte - 256 : byte;
+	}
+	return stored === unsigned || stored === signed;
 }
-class TarParseError extends Error {
-  constructor(msg) {
-    super(msg);
-    this.name = "TarParseError";
-  }
-}
-export {
-  BLOCK_SIZE,
-  TarParseError,
-  parseTar
+var TarParseError = class extends Error {
+	constructor(msg) {
+		super(msg);
+		this.name = "TarParseError";
+	}
 };
+
+//#endregion
+export { BLOCK_SIZE, TarParseError, parseTar };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gjsify/tar",
-  "version": "0.3.12",
+  "version": "0.3.14",
   "description": "Streaming .tar / .tar.gz reader for the gjsify install backend (Node + GJS)",
   "type": "module",
   "module": "lib/esm/index.js",
@@ -34,8 +34,8 @@
   ],
   "license": "MIT",
   "devDependencies": {
-    "@gjsify/cli": "^0.3.12",
-    "@gjsify/unit": "^0.3.12",
+    "@gjsify/cli": "^0.3.14",
+    "@gjsify/unit": "^0.3.14",
     "typescript": "^6.0.3"
   }
 }