@loaders.gl/zip 4.0.0-alpha.8 → 4.0.0-beta.1

package/src/parse-zip/cd-file-header.ts

@@ -0,0 +1,114 @@
+import {FileProvider} from '@loaders.gl/loader-utils';
+import {parseEoCDRecord} from './end-of-central-directory';
+import {ZipSignature} from './search-from-the-end';
+
+/**
+ * zip central directory file header info
+ * according to https://en.wikipedia.org/wiki/ZIP_(file_format)
+ */
+export type ZipCDFileHeader = {
+  /** Compressed size */
+  compressedSize: bigint;
+  /** Uncompressed size */
+  uncompressedSize: bigint;
+  /** Extra field size */
+  extraFieldLength: number;
+  /** File name length */
+  fileNameLength: number;
+  /** File name */
+  fileName: string;
+  /** Extra field offset */
+  extraOffset: bigint;
+  /** Relative offset of local file header */
+  localHeaderOffset: bigint;
+};
+
+// offsets accroding to https://en.wikipedia.org/wiki/ZIP_(file_format)
+const CD_COMPRESSED_SIZE_OFFSET = 20n;
+const CD_UNCOMPRESSED_SIZE_OFFSET = 24n;
+const CD_FILE_NAME_LENGTH_OFFSET = 28n;
+const CD_EXTRA_FIELD_LENGTH_OFFSET = 30n;
+const CD_LOCAL_HEADER_OFFSET_OFFSET = 42n;
+const CD_FILE_NAME_OFFSET = 46n;
+
+export const signature: ZipSignature = [0x50, 0x4b, 0x01, 0x02];
+
+/**
+ * Parses central directory file header of zip file
+ * @param headerOffset - offset in the archive where header starts
+ * @param buffer - buffer containing whole array
+ * @returns Info from the header
+ */
+export const parseZipCDFileHeader = async (
+  headerOffset: bigint,
+  buffer: FileProvider
+): Promise<ZipCDFileHeader | null> => {
+  if (
+    Buffer.from(await buffer.slice(headerOffset, headerOffset + 4n)).compare(
+      Buffer.from(signature)
+    ) !== 0
+  ) {
+    return null;
+  }
+
+  let compressedSize = BigInt(await buffer.getUint32(headerOffset + CD_COMPRESSED_SIZE_OFFSET));
+
+  let uncompressedSize = BigInt(await buffer.getUint32(headerOffset + CD_UNCOMPRESSED_SIZE_OFFSET));
+
+  const extraFieldLength = await buffer.getUint16(headerOffset + CD_EXTRA_FIELD_LENGTH_OFFSET);
+
+  const fileNameLength = await buffer.getUint16(headerOffset + CD_FILE_NAME_LENGTH_OFFSET);
+
+  const fileName = new TextDecoder().decode(
+    await buffer.slice(
+      headerOffset + CD_FILE_NAME_OFFSET,
+      headerOffset + CD_FILE_NAME_OFFSET + BigInt(fileNameLength)
+    )
+  );
+
+  const extraOffset = headerOffset + CD_FILE_NAME_OFFSET + BigInt(fileNameLength);
+
+  const oldFormatOffset = await buffer.getUint32(headerOffset + CD_LOCAL_HEADER_OFFSET_OFFSET);
+
+  let fileDataOffset = BigInt(oldFormatOffset);
+  let offsetInZip64Data = 4n;
+  // looking for info that might be also be in zip64 extra field
+  if (uncompressedSize === BigInt(0xffffffff)) {
+    uncompressedSize = await buffer.getBigUint64(extraOffset + offsetInZip64Data);
+    offsetInZip64Data += 8n;
+  }
+  if (compressedSize === BigInt(0xffffffff)) {
+    compressedSize = await buffer.getBigUint64(extraOffset + offsetInZip64Data);
+    offsetInZip64Data += 8n;
+  }
+  if (fileDataOffset === BigInt(0xffffffff)) {
+    fileDataOffset = await buffer.getBigUint64(extraOffset + offsetInZip64Data); // setting it to the one from zip64
+  }
+  const localHeaderOffset = fileDataOffset;
+
+  return {
+    compressedSize,
+    uncompressedSize,
+    extraFieldLength,
+    fileNameLength,
+    fileName,
+    extraOffset,
+    localHeaderOffset
+  };
+};
+
+/**
+ * Create iterator over files of zip archive
+ * @param fileProvider - file provider that provider random access to the file
+ */
+export async function* zipCDFileHeaderGenerator(fileProvider: FileProvider) {
+  const {cdStartOffset} = await parseEoCDRecord(fileProvider);
+  let cdHeader = await parseZipCDFileHeader(cdStartOffset, fileProvider);
+  while (cdHeader) {
+    yield cdHeader;
+    cdHeader = await parseZipCDFileHeader(
+      cdHeader.extraOffset + BigInt(cdHeader.extraFieldLength),
+      fileProvider
+    );
+  }
+}

package/src/parse-zip/end-of-central-directory.ts

@@ -0,0 +1,71 @@
+import {FileProvider} from '@loaders.gl/loader-utils';
+import {ZipSignature, searchFromTheEnd} from './search-from-the-end';
+
+/**
+ * End of central directory info
+ * according to https://en.wikipedia.org/wiki/ZIP_(file_format)
+ */
+export type ZipEoCDRecord = {
+  /** Relative offset of local file header */
+  cdStartOffset: bigint;
+  /** Relative offset of local file header */
+  cdRecordsNumber: bigint;
+};
+
+const eoCDSignature: ZipSignature = [0x50, 0x4b, 0x05, 0x06];
+const zip64EoCDLocatorSignature = [0x50, 0x4b, 0x06, 0x07];
+const zip64EoCDSignature = [0x50, 0x4b, 0x06, 0x06];
+
+// offsets accroding to https://en.wikipedia.org/wiki/ZIP_(file_format)
+const CD_RECORDS_NUMBER_OFFSET = 8n;
+const CD_START_OFFSET_OFFSET = 16n;
+const ZIP64_EOCD_START_OFFSET_OFFSET = 8n;
+const ZIP64_CD_RECORDS_NUMBER_OFFSET = 24n;
+const ZIP64_CD_START_OFFSET_OFFSET = 48n;
+
+/**
+ * Parses end of central directory record of zip file
+ * @param fileProvider - FileProvider instance
+ * @returns Info from the header
+ */
+export const parseEoCDRecord = async (fileProvider: FileProvider): Promise<ZipEoCDRecord> => {
+  const zipEoCDOffset = await searchFromTheEnd(fileProvider, eoCDSignature);
+
+  let cdRecordsNumber = BigInt(
+    await fileProvider.getUint16(zipEoCDOffset + CD_RECORDS_NUMBER_OFFSET)
+  );
+  let cdStartOffset = BigInt(await fileProvider.getUint32(zipEoCDOffset + CD_START_OFFSET_OFFSET));
+
+  if (cdStartOffset === BigInt(0xffffffff) || cdRecordsNumber === BigInt(0xffffffff)) {
+    const zip64EoCDLocatorOffset = zipEoCDOffset - 20n;
+
+    if (
+      Buffer.from(
+        await fileProvider.slice(zip64EoCDLocatorOffset, zip64EoCDLocatorOffset + 4n)
+      ).compare(Buffer.from(zip64EoCDLocatorSignature)) !== 0
+    ) {
+      throw new Error('zip64 EoCD locator not found');
+    }
+    const zip64EoCDOffset = await fileProvider.getBigUint64(
+      zip64EoCDLocatorOffset + ZIP64_EOCD_START_OFFSET_OFFSET
+    );
+
+    if (
+      Buffer.from(await fileProvider.slice(zip64EoCDOffset, zip64EoCDOffset + 4n)).compare(
+        Buffer.from(zip64EoCDSignature)
+      ) !== 0
+    ) {
+      throw new Error('zip64 EoCD not found');
+    }
+
+    cdRecordsNumber = await fileProvider.getBigUint64(
+      zip64EoCDOffset + ZIP64_CD_RECORDS_NUMBER_OFFSET
+    );
+    cdStartOffset = await fileProvider.getBigUint64(zip64EoCDOffset + ZIP64_CD_START_OFFSET_OFFSET);
+  }
+
+  return {
+    cdRecordsNumber,
+    cdStartOffset
+  };
+};

package/src/parse-zip/local-file-header.ts

@@ -0,0 +1,95 @@
+import {FileProvider} from '@loaders.gl/loader-utils';
+
+/**
+ * zip local file header info
+ * according to https://en.wikipedia.org/wiki/ZIP_(file_format)
+ */
+export type ZipLocalFileHeader = {
+  /** File name length */
+  fileNameLength: number;
+  /** File name */
+  fileName: string;
+  /** Extra field length */
+  extraFieldLength: number;
+  /** Offset of the file data */
+  fileDataOffset: bigint;
+  /** Compressed size */
+  compressedSize: bigint;
+  /** Compression method */
+  compressionMethod: number;
+};
+
+// offsets accroding to https://en.wikipedia.org/wiki/ZIP_(file_format)
+const COMPRESSION_METHOD_OFFSET = 8n;
+const COMPRESSED_SIZE_OFFSET = 18n;
+const UNCOMPRESSED_SIZE_OFFSET = 22n;
+const FILE_NAME_LENGTH_OFFSET = 26n;
+const EXTRA_FIELD_LENGTH_OFFSET = 28n;
+const FILE_NAME_OFFSET = 30n;
+
+export const signature = [0x50, 0x4b, 0x03, 0x04];
+
+/**
+ * Parses local file header of zip file
+ * @param headerOffset - offset in the archive where header starts
+ * @param buffer - buffer containing whole array
+ * @returns Info from the header
+ */
+export const parseZipLocalFileHeader = async (
+  headerOffset: bigint,
+  buffer: FileProvider
+): Promise<ZipLocalFileHeader | null> => {
+  if (
+    Buffer.from(await buffer.slice(headerOffset, headerOffset + 4n)).compare(
+      Buffer.from(signature)
+    ) !== 0
+  ) {
+    return null;
+  }
+
+  const fileNameLength = await buffer.getUint16(headerOffset + FILE_NAME_LENGTH_OFFSET);
+
+  const fileName = new TextDecoder()
+    .decode(
+      await buffer.slice(
+        headerOffset + FILE_NAME_OFFSET,
+        headerOffset + FILE_NAME_OFFSET + BigInt(fileNameLength)
+      )
+    )
+    .split('\\')
+    .join('/');
+  const extraFieldLength = await buffer.getUint16(headerOffset + EXTRA_FIELD_LENGTH_OFFSET);
+
+  let fileDataOffset = headerOffset + FILE_NAME_OFFSET + BigInt(fileNameLength + extraFieldLength);
+
+  const compressionMethod = await buffer.getUint16(headerOffset + COMPRESSION_METHOD_OFFSET);
+
+  let compressedSize = BigInt(await buffer.getUint32(headerOffset + COMPRESSED_SIZE_OFFSET)); // add zip 64 logic
+
+  let uncompressedSize = BigInt(await buffer.getUint32(headerOffset + UNCOMPRESSED_SIZE_OFFSET)); // add zip 64 logic
+
+  const extraOffset = headerOffset + FILE_NAME_OFFSET + BigInt(fileNameLength);
+
+  let offsetInZip64Data = 4n;
+  // looking for info that might be also be in zip64 extra field
+  if (uncompressedSize === BigInt(0xffffffff)) {
+    uncompressedSize = await buffer.getBigUint64(extraOffset + offsetInZip64Data);
+    offsetInZip64Data += 8n;
+  }
+  if (compressedSize === BigInt(0xffffffff)) {
+    compressedSize = await buffer.getBigUint64(extraOffset + offsetInZip64Data);
+    offsetInZip64Data += 8n;
+  }
+  if (fileDataOffset === BigInt(0xffffffff)) {
+    fileDataOffset = await buffer.getBigUint64(extraOffset + offsetInZip64Data); // setting it to the one from zip64
+  }
+
+  return {
+    fileNameLength,
+    fileName,
+    extraFieldLength,
+    fileDataOffset,
+    compressedSize,
+    compressionMethod
+  };
+};

package/src/parse-zip/search-from-the-end.ts

@@ -0,0 +1,38 @@
+import {FileProvider} from '@loaders.gl/loader-utils';
+
+/** Description of zip signature type */
+export type ZipSignature = [number, number, number, number];
+
+/**
+ * looking for the last occurrence of the provided
+ * @param file
+ * @param target
+ * @returns
+ */
+export const searchFromTheEnd = async (
+  file: FileProvider,
+  target: ZipSignature
+): Promise<bigint> => {
+  const searchWindow = [
+    await file.getUint8(file.length - 1n),
+    await file.getUint8(file.length - 2n),
+    await file.getUint8(file.length - 3n),
+    undefined
+  ];
+
+  let targetOffset = 0n;
+
+  // looking for the last record in the central directory
+  for (let i = file.length - 4n; i > -1; i--) {
+    searchWindow[3] = searchWindow[2];
+    searchWindow[2] = searchWindow[1];
+    searchWindow[1] = searchWindow[0];
+    searchWindow[0] = await file.getUint8(i);
+    if (searchWindow.every((val, index) => val === target[index])) {
+      targetOffset = i;
+      break;
+    }
+  }
+
+  return targetOffset;
+};

package/src/tar-builder.ts

@@ -11,14 +11,14 @@ type TarBuilderOptions = {
 /**
  * Build a tar file by adding files
  */
-export default class TARBuilder {
+export class TarBuilder {
   static get properties() {
     return {
       id: 'tar',
       name: 'TAR',
       extensions: ['tar'],
       mimeTypes: ['application/x-tar'],
-      builder: TARBuilder,
+      builder: TarBuilder,
       options: TAR_BUILDER_OPTIONS
     };
   }

package/src/zip-loader.ts

@@ -1,4 +1,5 @@
-// Zip loader
+// loaders.gl, MIT license
+
 import type {LoaderWithParser, LoaderOptions} from '@loaders.gl/loader-utils';
 import JSZip from 'jszip';
 
@@ -64,5 +65,3 @@ async function loadZipEntry(jsZip: any, subFilename: string, options: any = {})
     return error;
   }
 }
-
-export const _typecheckZipLoader: LoaderWithParser = ZipLoader;

package/src/zip-writer.ts

@@ -1,10 +1,20 @@
-import type {Writer} from '@loaders.gl/loader-utils';
-import JSZip from 'jszip';
+// loaders.gl, MIT license
+
+import type {Writer, WriterOptions} from '@loaders.gl/loader-utils';
+import JSZip, {JSZipGeneratorOptions} from 'jszip';
+
+export type ZipWriterOptions = WriterOptions & {
+  zip?: {
+    onUpdate?: (metadata: {percent: number}) => void;
+  };
+  /** Passthrough options to jszip */
+  jszip?: JSZipGeneratorOptions;
+};
 
 /**
  * Zip exporter
  */
-export const ZipWriter: Writer = {
+export const ZipWriter: Writer<FileReaderEventMap, never, ZipWriterOptions> = {
   name: 'Zip Archive',
   extensions: ['zip'],
   category: 'archive',
@@ -13,7 +23,10 @@ export const ZipWriter: Writer = {
   encode: encodeZipAsync
 };
 
-async function encodeZipAsync(fileMap: any, options: any = {}) {
+async function encodeZipAsync(
+  fileMap: Record<string, ArrayBuffer>,
+  options: ZipWriterOptions = {}
+) {
   const jsZip = new JSZip();
   // add files to the zip
   for (const subFileName in fileMap) {
@@ -21,17 +34,17 @@ async function encodeZipAsync(fileMap: any, options: any = {}) {
 
     // jszip supports both arraybuffer and string data (the main loaders.gl types)
     // https://stuk.github.io/jszip/documentation/api_zipobject/async.html
-    jsZip.file(subFileName, subFileData, options);
+    jsZip.file(subFileName, subFileData, options?.jszip || {});
   }
 
   // always generate the full zip as an arraybuffer
-  options = Object.assign({}, options, {
-    type: 'arraybuffer'
-  });
+  const jszipOptions: JSZipGeneratorOptions = {...options?.jszip, type: 'arraybuffer'};
   const {onUpdate = () => {}} = options;
 
-  return jsZip.generateAsync(options, onUpdate).catch((error) => {
+  try {
+    return await jsZip.generateAsync(jszipOptions, onUpdate);
+  } catch (error) {
     options.log.error(`Unable to write zip archive: ${error}`);
     throw error;
-  });
+  }
 }

package/dist/bundle.js

@@ -1,5 +0,0 @@
-"use strict";
-// @ts-nocheck
-const moduleExports = require('./index');
-globalThis.loaders = globalThis.loaders || {};
-module.exports = Object.assign(globalThis.loaders, moduleExports);

package/dist/index.js

@@ -1,12 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.TarBuilder = exports.ZipWriter = exports.ZipLoader = void 0;
-var zip_loader_1 = require("./zip-loader");
-Object.defineProperty(exports, "ZipLoader", { enumerable: true, get: function () { return zip_loader_1.ZipLoader; } });
-var zip_writer_1 = require("./zip-writer");
-Object.defineProperty(exports, "ZipWriter", { enumerable: true, get: function () { return zip_writer_1.ZipWriter; } });
-var tar_builder_1 = require("./tar-builder");
-Object.defineProperty(exports, "TarBuilder", { enumerable: true, get: function () { return __importDefault(tar_builder_1).default; } });

package/dist/lib/tar/header.js

@@ -1,99 +0,0 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.format = void 0;
-// This file is derived from the tar-js code base under MIT license
-// See https://github.com/beatgammit/tar-js/blob/master/LICENSE
-/*
- * tar-js
- * MIT (c) 2011 T. Jameson Little
- */
-/* eslint-disable */
-const utils = __importStar(require("./utils"));
-/*
-struct posix_header {             // byte offset
-    char name[100];               //   0
-    char mode[8];                 // 100
-    char uid[8];                  // 108
-    char gid[8];                  // 116
-    char size[12];                // 124
-    char mtime[12];               // 136
-    char chksum[8];               // 148
-    char typeflag;                // 156
-    char linkname[100];           // 157
-    char magic[6];                // 257
-    char version[2];              // 263
-    char uname[32];               // 265
-    char gname[32];               // 297
-    char devmajor[8];             // 329
-    char devminor[8];             // 337
-    char prefix[155];             // 345
-                                  // 500
-};
-*/
-const structure = {
-    fileName: 100,
-    fileMode: 8,
-    uid: 8,
-    gid: 8,
-    fileSize: 12,
-    mtime: 12,
-    checksum: 8,
-    type: 1,
-    linkName: 100,
-    ustar: 8,
-    owner: 32,
-    group: 32,
-    majorNumber: 8,
-    minorNumber: 8,
-    filenamePrefix: 155,
-    padding: 12
-};
-/**
- * Getting the header
- * @param data
- * @param [cb]
- * @returns {Uint8Array} | Array
- */
-function format(data, cb) {
-    const buffer = utils.clean(512);
-    let offset = 0;
-    Object.entries(structure).forEach(([field, length]) => {
-        const str = data[field] || '';
-        let i;
-        let fieldLength;
-        for (i = 0, fieldLength = str.length; i < fieldLength; i += 1) {
-            buffer[offset] = str.charCodeAt(i);
-            offset += 1;
-        }
-        // space it out with nulls
-        offset += length - i;
-    });
-    if (typeof cb === 'function') {
-        return cb(buffer, offset);
-    }
-    return buffer;
-}
-exports.format = format;

package/dist/lib/tar/tar.js

@@ -1,131 +0,0 @@
-"use strict";
-// This file is derived from the tar-js code base under MIT license
-// See https://github.com/beatgammit/tar-js/blob/master/LICENSE
-/*
- * tar-js
- * MIT (c) 2011 T. Jameson Little
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-const utils_1 = require("./utils");
-const header_1 = require("./header");
-let blockSize;
-let headerLength;
-let inputLength;
-const recordSize = 512;
-class Tar {
-    /**
-     * @param [recordsPerBlock]
-     */
-    constructor(recordsPerBlock) {
-        this.blocks = [];
-        this.written = 0;
-        blockSize = (recordsPerBlock || 20) * recordSize;
-        this.out = (0, utils_1.clean)(blockSize);
-        this.blocks = [];
-        this.length = 0;
-        this.save = this.save.bind(this);
-        this.clear = this.clear.bind(this);
-        this.append = this.append.bind(this);
-    }
-    /**
-     * Append a file to the tar archive
-     * @param filepath
-     * @param input
-     * @param [opts]
-     */
-    // eslint-disable-next-line complexity
-    append(filepath, input, opts) {
-        let checksum;
-        if (typeof input === 'string') {
-            input = (0, utils_1.stringToUint8)(input);
-        }
-        else if (input.constructor && input.constructor !== Uint8Array.prototype.constructor) {
-            // @ts-ignore
-            const errorInputMatch = /function\s*([$A-Za-z_][0-9A-Za-z_]*)\s*\(/.exec(input.constructor.toString());
-            const errorInput = errorInputMatch && errorInputMatch[1];
-            const errorMessage = `Invalid input type. You gave me: ${errorInput}`;
-            throw errorMessage;
-        }
-        opts = opts || {};
-        const mode = opts.mode || parseInt('777', 8) & 0xfff;
-        const mtime = opts.mtime || Math.floor(Number(new Date()) / 1000);
-        const uid = opts.uid || 0;
-        const gid = opts.gid || 0;
-        const data = {
-            fileName: filepath,
-            fileMode: (0, utils_1.pad)(mode, 7),
-            uid: (0, utils_1.pad)(uid, 7),
-            gid: (0, utils_1.pad)(gid, 7),
-            fileSize: (0, utils_1.pad)(input.length, 11),
-            mtime: (0, utils_1.pad)(mtime, 11),
-            checksum: '        ',
-            // 0 = just a file
-            type: '0',
-            ustar: 'ustar  ',
-            owner: opts.owner || '',
-            group: opts.group || ''
-        };
-        // calculate the checksum
-        checksum = 0;
-        Object.keys(data).forEach((key) => {
-            let i;
-            const value = data[key];
-            let length;
-            for (i = 0, length = value.length; i < length; i += 1) {
-                checksum += value.charCodeAt(i);
-            }
-        });
-        data.checksum = `${(0, utils_1.pad)(checksum, 6)}\u0000 `;
-        const headerArr = (0, header_1.format)(data);
-        headerLength = Math.ceil(headerArr.length / recordSize) * recordSize;
-        inputLength = Math.ceil(input.length / recordSize) * recordSize;
-        this.blocks.push({
-            header: headerArr,
-            input,
-            headerLength,
-            inputLength
-        });
-    }
-    /**
-     * Compiling data to a Blob object
-     * @returns {Blob}
-     */
-    save() {
-        const buffers = [];
-        const chunks = new Array();
-        let length = 0;
-        const max = Math.pow(2, 20);
-        let chunk = new Array();
-        this.blocks.forEach((b = []) => {
-            if (length + b.headerLength + b.inputLength > max) {
-                chunks.push({ blocks: chunk, length });
-                chunk = [];
-                length = 0;
-            }
-            chunk.push(b);
-            length += b.headerLength + b.inputLength;
-        });
-        chunks.push({ blocks: chunk, length });
-        chunks.forEach((c = []) => {
-            const buffer = new Uint8Array(c.length);
-            let written = 0;
-            c.blocks.forEach((b = []) => {
-                buffer.set(b.header, written);
-                written += b.headerLength;
-                buffer.set(b.input, written);
-                written += b.inputLength;
-            });
-            buffers.push(buffer);
-        });
-        buffers.push(new Uint8Array(2 * recordSize));
-        return new Blob(buffers, { type: 'octet/stream' });
-    }
-    /**
-     * Clear the data by its blocksize
-     */
-    clear() {
-        this.written = 0;
-        this.out = (0, utils_1.clean)(blockSize);
-    }
-}
-exports.default = Tar;

package/dist/lib/tar/types.js

@@ -1,2 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });