tar-vern 0.3.0 → 1.0.0

package/README_pack.md

@@ -2,7 +2,7 @@
 
 Tape archiver (tar) library for Typescript implementation.
 
-[![Project Status: WIP – Initial development is in progress, but there has not yet been a stable, usable release suitable for the public.](https://www.repostatus.org/badges/latest/wip.svg)](https://www.repostatus.org/#wip)
+[![Project Status: Active – The project has reached a stable, usable state and is being actively developed.](https://www.repostatus.org/badges/latest/active.svg)](https://www.repostatus.org/#active)
 [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
 
 ----
@@ -27,15 +27,15 @@ npm install tar-vern
 
 ----
 
-## Usage for tar packing
-
-### Minimum example
+## Minimal sample code
 
 tar-vern supplies file and directory information to pack through "TypeScript async generator."
 This allows you to specify pack data with very concise code.
 
 ```typescript
-import { createTarPacker, storeReaderToFile } from 'tar-vern';
+import {
+  createTarPacker, storeReaderToFile,
+  createFileItem, createDirectoryItem } from 'tar-vern';
 
 // Create an async generator for tar entries
 const itemGenerator = async function*() {
@@ -51,11 +51,33 @@ const itemGenerator = async function*() {
   // (Make your own entries with yield expression...)
 };
 
-// Create GZip compressed tar stream
+// Create GZipped tar stream and write to file
 const packer = createTarPacker(itemGenerator(), 'gzip');
 await storeReaderToFile(packer, 'archive.tar.gz');   // Use helper to awaitable
 ```
 
+tar-vern provides tar extraction through async generator too, allowing you to process entries as they are extracted from the tar archive.
+
+```typescript
+import { createReadStream } from 'fs';
+import { createTarExtractor } from 'tar-vern';
+
+// Read GZipped tar file and extract entries
+const readableStream = createReadStream('archive.tar.gz');
+
+for await (const extractedItem of createTarExtractor(readableStream), 'gzip') {
+  if (extractedItem.kind === 'file') {
+    console.log(`File: ${extractedItem.path}`);
+    
+    // Get content as string or buffer
+    const content = await extractedItem.getContent('string');
+    console.log(`Content: ${content}`);
+  } else {
+    console.log(`Directory: ${extractedItem.path}`);
+  }
+}
+```
+
 ----
 
 For more information, [see repository documents](http://github.com/kekyo/tar-vern/).

package/dist/extractor.d.ts

@@ -0,0 +1,21 @@
+/*!
+ * name: tar-vern
+ * version: 1.0.0
+ * description: Tape archiver library for Typescript
+ * author: Kouji Matsui (@kekyo@mi.kekyo.net)
+ * license: MIT
+ * repository.url: https://github.com/kekyo/tar-vern.git
+ * git.commit.hash: def794cc361e3023c973a6dc7719d38fc08ac363
+ */
+
+import { Readable } from 'stream';
+import { CompressionTypes, ExtractedEntryItem } from './types';
+/**
+ * Create a tar extractor
+ * @param readable - The readable stream containing tar data
+ * @param compressionType - The compression type (default: 'none')
+ * @param signal - The abort signal
+ * @returns Async generator of entry items
+ */
+export declare const createTarExtractor: (readable: Readable, compressionType?: CompressionTypes, signal?: AbortSignal) => AsyncGenerator<ExtractedEntryItem, void, unknown>;
+//# sourceMappingURL=extractor.d.ts.map

package/dist/extractor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"extractor.d.ts","sourceRoot":"","sources":["../src/extractor.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,QAAQ,EAAE,MAAM,QAAQ,CAAC;AAElC,OAAO,EAAE,gBAAgB,EAA0B,kBAAkB,EAAqB,MAAM,SAAS,CAAC;AAmS1G;;;;;;GAMG;AACH,eAAO,MAAM,kBAAkB,GAC7B,UAAU,QAAQ,EAClB,kBAAkB,gBAAgB,EAClC,SAAS,WAAW,KAAG,cAAc,CAAC,kBAAkB,EAAE,IAAI,EAAE,OAAO,CAyIxE,CAAC"}

package/dist/index.cjs

@@ -1,10 +1,11 @@
 /*!
  * name: tar-vern
- * version: 0.3.0
+ * version: 1.0.0
  * description: Tape archiver library for Typescript
  * author: Kouji Matsui (@kekyo@mi.kekyo.net)
  * license: MIT
  * repository.url: https://github.com/kekyo/tar-vern.git
+ * git.commit.hash: def794cc361e3023c973a6dc7719d38fc08ac363
  */
 "use strict";
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
@@ -12,15 +13,20 @@ const stream = require("stream");
 const zlib = require("zlib");
 const fs = require("fs");
 const promises = require("fs/promises");
+const promises$1 = require("stream/promises");
+const path = require("path");
+const MAX_NAME = 100;
+const MAX_PREFIX = 155;
 const getUName = (candidateName, candidateId, reflectStat) => {
   return candidateName ?? (reflectStat === "all" ? candidateId.toString() : "root");
 };
 const getBuffer = (data) => {
   return Buffer.isBuffer(data) ? data : Buffer.from(data, "utf8");
 };
-const createDirectoryItem = async (path, reflectStat, options) => {
+const createDirectoryItem = async (path2, reflectStat, options, signal) => {
   const rs = reflectStat ?? "none";
   if (rs !== "none" && options?.directoryPath) {
+    signal?.throwIfAborted();
     const stats = await promises.stat(options.directoryPath);
     const mode = options?.mode ?? stats.mode;
     const uid = options?.uid ?? stats.uid;
@@ -30,7 +36,7 @@ const createDirectoryItem = async (path, reflectStat, options) => {
     const gname = getUName(options?.gname, stats.gid, rs);
     return {
       kind: "directory",
-      path,
+      path: path2,
       mode,
       uname,
       gname,
@@ -47,7 +53,7 @@ const createDirectoryItem = async (path, reflectStat, options) => {
     const gname = getUName(options?.gname, void 0, rs);
     return {
       kind: "directory",
-      path,
+      path: path2,
       mode,
       uname,
       gname,
@@ -57,7 +63,8 @@ const createDirectoryItem = async (path, reflectStat, options) => {
     };
   }
 };
-const createFileItem = async (path, content, options) => {
+const createFileItem = async (path2, content, options, signal) => {
+  signal?.throwIfAborted();
   const mode = options?.mode ?? 420;
   const uid = options?.uid ?? 0;
   const gid = options?.gid ?? 0;
@@ -66,7 +73,7 @@ const createFileItem = async (path, content, options) => {
   const gname = options?.gname ?? "root";
   return {
     kind: "file",
-    path,
+    path: path2,
     mode,
     uname,
     gname,
@@ -76,7 +83,7 @@ const createFileItem = async (path, content, options) => {
     content
   };
 };
-const createReadableFileItem = async (path, readable, options) => {
+const createReadableFileItem = async (path2, readable, options, signal) => {
   const mode = options?.mode ?? 420;
   const uid = options?.uid ?? 0;
   const gid = options?.gid ?? 0;
@@ -88,13 +95,14 @@ const createReadableFileItem = async (path, readable, options) => {
     const chunks = [];
     length = 0;
     for await (const chunk of readable) {
+      signal?.throwIfAborted();
       const buffer = getBuffer(chunk);
       chunks.push(buffer);
       length += buffer.length;
     }
     return {
       kind: "file",
-      path,
+      path: path2,
       mode,
       uname,
       gname,
@@ -104,13 +112,13 @@ const createReadableFileItem = async (path, readable, options) => {
       content: {
         kind: "readable",
         length,
-        readable: stream.Readable.from(chunks)
+        readable: stream.Readable.from(chunks, { signal })
       }
     };
   } else {
     return {
       kind: "file",
-      path,
+      path: path2,
       mode,
       uname,
       gname,
@@ -125,7 +133,7 @@ const createReadableFileItem = async (path, readable, options) => {
     };
   }
 };
-const createGeneratorFileItem = async (path, generator, options) => {
+const createGeneratorFileItem = async (path2, generator, options, signal) => {
   const mode = options?.mode ?? 420;
   const uid = options?.uid ?? 0;
   const gid = options?.gid ?? 0;
@@ -137,13 +145,14 @@ const createGeneratorFileItem = async (path, generator, options) => {
     const chunks = [];
     length = 0;
     for await (const chunk of generator) {
+      signal?.throwIfAborted();
       const buffer = getBuffer(chunk);
       chunks.push(buffer);
       length += buffer.length;
     }
     return {
       kind: "file",
-      path,
+      path: path2,
       mode,
       uname,
       gname,
@@ -153,13 +162,13 @@ const createGeneratorFileItem = async (path, generator, options) => {
       content: {
         kind: "readable",
         length,
-        readable: stream.Readable.from(chunks)
+        readable: stream.Readable.from(chunks, { signal })
       }
     };
   } else {
     return {
       kind: "file",
-      path,
+      path: path2,
       mode,
       uname,
       gname,
@@ -174,17 +183,18 @@ const createGeneratorFileItem = async (path, generator, options) => {
     };
   }
 };
-const createReadFileItem = async (path, filePath, reflectStat, options) => {
+const createReadFileItem = async (path2, filePath, reflectStat, options, signal) => {
   const rs = reflectStat ?? "exceptName";
+  signal?.throwIfAborted();
   const stats = await promises.stat(filePath);
-  const reader = fs.createReadStream(filePath);
+  const reader = fs.createReadStream(filePath, { signal });
   const mode = options?.mode ?? (rs !== "none" ? stats.mode : void 0);
   const uid = options?.uid ?? (rs !== "none" ? stats.uid : void 0);
   const gid = options?.gid ?? (rs !== "none" ? stats.gid : void 0);
   const date = options?.date ?? (rs !== "none" ? stats.mtime : void 0);
   const uname = getUName(options?.uname, stats.uid, rs);
   const gname = getUName(options?.gname, stats.gid, rs);
-  return await createReadableFileItem(path, reader, {
+  return await createReadableFileItem(path2, reader, {
     length: stats.size,
     mode,
     uname,
@@ -192,16 +202,55 @@ const createReadFileItem = async (path, filePath, reflectStat, options) => {
     uid,
     gid,
     date
-  });
+  }, signal);
+};
+const storeReaderToFile = async (reader, path2, signal) => {
+  const writer = fs.createWriteStream(path2, { signal });
+  await promises$1.pipeline(reader, writer, { signal });
+};
+const createEntryItemGenerator = async function* (baseDir, relativePaths, reflectStat, signal) {
+  const rs = reflectStat ?? "exceptName";
+  for (const relativePath of relativePaths) {
+    signal?.throwIfAborted();
+    const fsPath = path.join(baseDir, relativePath);
+    try {
+      signal?.throwIfAborted();
+      const stats = await promises.stat(fsPath);
+      if (stats.isDirectory()) {
+        yield await createDirectoryItem(relativePath, rs, {
+          directoryPath: fsPath
+        }, signal);
+      } else if (stats.isFile()) {
+        yield await createReadFileItem(relativePath, fsPath, rs, void 0, signal);
+      }
+    } catch (error) {
+      console.warn(`Warning: Could not access ${fsPath}:`, error);
+      continue;
+    }
+  }
 };
-const storeReaderToFile = (reader, path) => {
-  const writer = fs.createWriteStream(path);
-  reader.pipe(writer);
-  return new Promise((res, rej) => {
-    writer.on("finish", res);
-    writer.on("error", rej);
-    reader.on("error", rej);
-  });
+const extractTo = async (iterator, basePath, signal) => {
+  for await (const entry of iterator) {
+    signal?.throwIfAborted();
+    const targetPath = path.join(basePath, entry.path);
+    if (entry.kind === "directory") {
+      try {
+        signal?.throwIfAborted();
+        await promises.mkdir(targetPath, { recursive: true, mode: entry.mode });
+      } catch (error) {
+        if (error.code !== "EEXIST") {
+          throw error;
+        }
+      }
+    } else if (entry.kind === "file") {
+      const parentDir = path.dirname(targetPath);
+      signal?.throwIfAborted();
+      await promises.mkdir(parentDir, { recursive: true });
+      const fileEntry = entry;
+      const content = await fileEntry.getContent("buffer");
+      await promises.writeFile(targetPath, content, { mode: entry.mode, signal });
+    }
+  }
 };
 const utf8ByteLength = (str) => {
   return Buffer.byteLength(str, "utf8");
@@ -219,13 +268,11 @@ const truncateUtf8Safe = (str, maxBytes) => {
   }
   return str.slice(0, i);
 };
-const MAX_NAME = 100;
-const MAX_PREFIX = 155;
-const splitPath = (path) => {
-  if (utf8ByteLength(path) <= MAX_NAME) {
-    return { prefix: "", name: path };
+const splitPath = (path2) => {
+  if (utf8ByteLength(path2) <= MAX_NAME) {
+    return { prefix: "", name: path2 };
   }
-  const parts = path.split("/");
+  const parts = path2.split("/");
   let name = parts.pop() ?? "";
   let prefix = parts.join("/");
   if (utf8ByteLength(name) > MAX_NAME) {
@@ -249,9 +296,9 @@ const getPaddedBytes = (buffer) => {
   }
 };
 const terminatorBytes = Buffer.alloc(1024, 0);
-const createTarHeader = (type, path, size, mode, uname, gname, uid, gid, date) => {
+const createTarHeader = (type, path2, size, mode, uname, gname, uid, gid, date) => {
   const buffer = Buffer.alloc(512, 0);
-  const { name, prefix } = splitPath(path);
+  const { name, prefix } = splitPath(path2);
   buffer.write(name, 0, 100, "utf8");
   getOctalBytes(mode & 4095, 8).copy(buffer, 100);
   getOctalBytes(uid, 8).copy(buffer, 108);
@@ -301,10 +348,11 @@ const createTarPacker = (entryItemGenerator, compressionType, signal) => {
             const totalPaddedContentBytes = getPaddedBytes(contentBytes);
             yield totalPaddedContentBytes;
           } else {
+            const content = entryItemContent;
             const tarHeaderBytes = createTarHeader(
               "file",
               entryItem.path,
-              entryItemContent.length,
+              content.length,
               entryItem.mode,
               entryItem.uname,
               entryItem.gname,
@@ -314,10 +362,10 @@ const createTarPacker = (entryItemGenerator, compressionType, signal) => {
             );
             yield tarHeaderBytes;
             let position = 0;
-            switch (entryItemContent.kind) {
+            switch (content.kind) {
               // Content is a generator
               case "generator": {
-                for await (const contentBytes of entryItemContent.generator) {
+                for await (const contentBytes of content.generator) {
                   signal?.throwIfAborted();
                   yield contentBytes;
                   position += contentBytes.length;
@@ -326,9 +374,9 @@ const createTarPacker = (entryItemGenerator, compressionType, signal) => {
               }
               // Content is a readable stream
               case "readable": {
-                for await (const content of entryItemContent.readable) {
+                for await (const chunk of content.readable) {
                   signal?.throwIfAborted();
-                  const contentBytes = getBuffer(content);
+                  const contentBytes = getBuffer(chunk);
                   yield contentBytes;
                   position += contentBytes.length;
                 }
@@ -366,23 +414,280 @@ const createTarPacker = (entryItemGenerator, compressionType, signal) => {
   switch (ct) {
     // No compression
     case "none": {
-      return stream.Readable.from(entryItemIterator());
+      return stream.Readable.from(entryItemIterator(), { signal });
     }
     // Gzip compression
     case "gzip": {
       const gzipStream = zlib.createGzip({ level: 9 });
-      const entryItemStream = stream.Readable.from(entryItemIterator());
+      const entryItemStream = stream.Readable.from(entryItemIterator(), { signal });
       entryItemStream.pipe(gzipStream);
       return gzipStream;
     }
   }
 };
+const parseOctalBytes = (buffer, offset, length) => {
+  const str = buffer.subarray(offset, offset + length).toString("ascii").replace(/\0/g, "").trim();
+  return str ? parseInt(str, 8) : 0;
+};
+const parseString = (buffer, offset, length) => {
+  return buffer.subarray(offset, offset + length).toString("utf8").replace(/\0/g, "").trim();
+};
+const readExactBytes = async (iterator, size, signal) => {
+  const chunks = [];
+  let totalRead = 0;
+  while (totalRead < size) {
+    signal?.throwIfAborted();
+    const { value, done } = await iterator.next();
+    if (done) {
+      if (totalRead === 0) {
+        return void 0;
+      } else {
+        throw new Error(`Unexpected end of stream: expected ${size} bytes, got ${totalRead} bytes`);
+      }
+    }
+    const chunk = getBuffer(value);
+    const needed = size - totalRead;
+    if (chunk.length <= needed) {
+      chunks.push(chunk);
+      totalRead += chunk.length;
+    } else {
+      chunks.push(chunk.subarray(0, needed));
+      await iterator.return?.(chunk.subarray(needed));
+      totalRead = size;
+    }
+  }
+  return Buffer.concat(chunks, size);
+};
+const skipExactBytes = async (iterator, size, signal) => {
+  let totalSkipped = 0;
+  while (totalSkipped < size) {
+    signal?.throwIfAborted();
+    const { value, done } = await iterator.next();
+    if (done) {
+      throw new Error(`Unexpected end of stream: expected to skip ${size} bytes, skipped ${totalSkipped} bytes`);
+    }
+    const chunk = getBuffer(value);
+    const needed = size - totalSkipped;
+    if (chunk.length <= needed) {
+      totalSkipped += chunk.length;
+    } else {
+      await iterator.return?.(chunk.subarray(needed));
+      totalSkipped = size;
+    }
+  }
+};
+const skipPaddingBytesTo512Boundary = async (iterator, contentSize, signal) => {
+  const padding = (512 - contentSize % 512) % 512;
+  if (padding > 0) {
+    await skipExactBytes(iterator, padding, signal);
+  }
+};
+const parseTarHeader = (buffer) => {
+  if (buffer.every((b) => b === 0)) {
+    return void 0;
+  }
+  const name = parseString(buffer, 0, 100);
+  const mode = parseOctalBytes(buffer, 100, 8);
+  const uid = parseOctalBytes(buffer, 108, 8);
+  const gid = parseOctalBytes(buffer, 116, 8);
+  const size = parseOctalBytes(buffer, 124, 12);
+  const mtime = new Date(parseOctalBytes(buffer, 136, 12) * 1e3);
+  const checksum = parseOctalBytes(buffer, 148, 8);
+  const typeflag = parseString(buffer, 156, 1);
+  const magic = parseString(buffer, 257, 6);
+  const uname = parseString(buffer, 265, 32);
+  const gname = parseString(buffer, 297, 32);
+  const prefix = parseString(buffer, 345, 155);
+  if (magic !== "ustar") {
+    throw new Error(`Invalid tar format: magic="${magic}"`);
+  }
+  let calculatedSum = 0;
+  for (let i = 0; i < 512; i++) {
+    if (i >= 148 && i < 156) {
+      calculatedSum += 32;
+    } else {
+      calculatedSum += buffer[i];
+    }
+  }
+  if (calculatedSum !== checksum) {
+    throw new Error(`Invalid checksum: expected ${checksum}, got ${calculatedSum}`);
+  }
+  let path2 = prefix ? `${prefix}/${name}` : name;
+  if (path2.endsWith("/")) {
+    path2 = path2.slice(0, -1);
+  }
+  const kind = typeflag === "5" ? "directory" : "file";
+  return {
+    kind,
+    path: path2,
+    size,
+    mode,
+    uid,
+    gid,
+    mtime,
+    uname: uname || uid.toString(),
+    gname: gname || gid.toString(),
+    checksum,
+    consumed: false
+  };
+};
+const createBufferedAsyncIterator = (iterable, signal) => {
+  const buffer = [];
+  const iterator = iterable[Symbol.asyncIterator]();
+  return {
+    next: async () => {
+      signal?.throwIfAborted();
+      if (buffer.length > 0) {
+        return { value: buffer.shift(), done: false };
+      }
+      return iterator.next();
+    },
+    return: async (value) => {
+      if (value !== void 0) {
+        buffer.unshift(value);
+      }
+      return { value: void 0, done: false };
+    }
+  };
+};
+const createReadableFromIterator = (iterator, size, signal, consumedRef) => {
+  const generator = async function* () {
+    let remainingBytes = size;
+    while (remainingBytes > 0) {
+      signal?.throwIfAborted();
+      const { value, done } = await iterator.next();
+      if (done) {
+        throw new Error(`Unexpected end of stream: expected ${size} bytes, remaining ${remainingBytes} bytes`);
+      }
+      const chunk = getBuffer(value);
+      if (chunk.length <= remainingBytes) {
+        remainingBytes -= chunk.length;
+        yield chunk;
+      } else {
+        const needed = chunk.subarray(0, remainingBytes);
+        const excess = chunk.subarray(remainingBytes);
+        remainingBytes = 0;
+        await iterator.return?.(excess);
+        yield needed;
+        break;
+      }
+    }
+    await skipPaddingBytesTo512Boundary(iterator, size, signal);
+    consumedRef.consumed = true;
+  };
+  return stream.Readable.from(generator(), { signal });
+};
+const createTarExtractor = async function* (readable, compressionType, signal) {
+  const ct = compressionType ?? "none";
+  let inputStream;
+  switch (ct) {
+    case "gzip":
+      const gunzip = zlib.createGunzip();
+      readable.pipe(gunzip);
+      inputStream = gunzip;
+      break;
+    case "none":
+    default:
+      inputStream = readable;
+      break;
+  }
+  const iterator = createBufferedAsyncIterator(inputStream, signal);
+  let header;
+  while (true) {
+    signal?.throwIfAborted();
+    if (header?.kind === "file" && !header.consumed) {
+      await skipExactBytes(iterator, header.size, signal);
+      await skipPaddingBytesTo512Boundary(iterator, header.size, signal);
+      header.consumed = true;
+    }
+    let headerBuffer;
+    try {
+      headerBuffer = await readExactBytes(iterator, 512, signal);
+    } catch (error) {
+      if (error instanceof Error && error.message.includes("Unexpected end of stream")) {
+        throw new Error("Invalid tar format: incomplete header");
+      }
+      throw error;
+    }
+    if (headerBuffer === void 0) {
+      break;
+    }
+    header = parseTarHeader(headerBuffer);
+    if (!header) {
+      const secondBlock = await readExactBytes(iterator, 512, signal);
+      if (secondBlock === void 0 || secondBlock.every((b) => b === 0)) {
+        break;
+      }
+      throw new Error("Invalid tar format: expected terminator block");
+    }
+    if (header.kind === "directory") {
+      yield {
+        kind: "directory",
+        path: header.path,
+        mode: header.mode,
+        uid: header.uid,
+        gid: header.gid,
+        uname: header.uname,
+        gname: header.gname,
+        date: header.mtime
+      };
+    } else {
+      const currentHeader = header;
+      yield {
+        kind: "file",
+        path: currentHeader.path,
+        mode: currentHeader.mode,
+        uid: currentHeader.uid,
+        gid: currentHeader.gid,
+        uname: currentHeader.uname,
+        gname: currentHeader.gname,
+        date: currentHeader.mtime,
+        getContent: async (type) => {
+          if (currentHeader.consumed) {
+            throw new Error("Content has already been consumed. Multiple calls to getContent are not supported.");
+          }
+          switch (type) {
+            // For string
+            case "string": {
+              const dataBuffer = await readExactBytes(iterator, currentHeader.size, signal);
+              if (dataBuffer === void 0) {
+                throw new Error(`Unexpected end of stream while reading file data for ${currentHeader.path}`);
+              }
+              await skipPaddingBytesTo512Boundary(iterator, currentHeader.size, signal);
+              currentHeader.consumed = true;
+              return dataBuffer.toString("utf8");
+            }
+            // For buffer
+            case "buffer": {
+              const dataBuffer = await readExactBytes(iterator, currentHeader.size, signal);
+              if (dataBuffer === void 0) {
+                throw new Error(`Unexpected end of stream while reading file data for ${currentHeader.path}`);
+              }
+              await skipPaddingBytesTo512Boundary(iterator, currentHeader.size, signal);
+              currentHeader.consumed = true;
+              return dataBuffer;
+            }
+            // For Readble stream
+            case "readable": {
+              const readable2 = createReadableFromIterator(iterator, currentHeader.size, signal, currentHeader);
+              return readable2;
+            }
+            default:
+              throw new Error(`Unsupported content type: ${type}`);
+          }
+        }
+      };
+    }
+  }
+};
 exports.createDirectoryItem = createDirectoryItem;
+exports.createEntryItemGenerator = createEntryItemGenerator;
 exports.createFileItem = createFileItem;
 exports.createGeneratorFileItem = createGeneratorFileItem;
 exports.createReadFileItem = createReadFileItem;
 exports.createReadableFileItem = createReadableFileItem;
+exports.createTarExtractor = createTarExtractor;
 exports.createTarPacker = createTarPacker;
-exports.getBuffer = getBuffer;
+exports.extractTo = extractTo;
 exports.storeReaderToFile = storeReaderToFile;
 //# sourceMappingURL=index.cjs.map