@opentdf/sdk 0.1.0-beta.1701

package/dist/web/tdf3/src/utils/zip-reader.js

@@ -0,0 +1,247 @@
+import { InvalidFileError } from '../../../src/errors.js';
+import { readUInt32LE, readUInt16LE, copyUint8Arr, buffToString } from './index.js';
+// TODO: Better document what these constants are
+// TODO: Document each function please
+const CD_SIGNATURE = 0x02014b50;
+const CENTRAL_DIRECTORY_RECORD_FIXED_SIZE = 46;
+const LOCAL_FILE_HEADER_FIXED_SIZE = 30;
+const VERSION_NEEDED_TO_EXTRACT_ZIP64 = 45;
+const manifestMaxSize = 1024 * 1024 * 10; // 10 MB
+const cp437 = '\u0000☺☻♥♦♣♠•◘○◙♂♀♪♫☼►◄↕‼¶§▬↨↑↓→←∟↔▲▼ !"#$%&\'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_`abcdefghijklmnopqrstuvwxyz{|}~⌂ÇüéâäàåçêëèïîìÄÅÉæÆôöòûùÿÖÜ¢£¥₧ƒáíóúñѪº¿⌐¬½¼¡«»░▒▓│┤╡╢╖╕╣║╗╝╜╛┐└┴┬├─┼╞╟╚╔╩╦╠═╬╧╨╤╥╙╘╒╓╫╪┘┌█▄▌▐▀αßΓπΣσµτΦΘΩδ∞φε∩≡±≥≤⌠⌡÷≈°∙·√ⁿ²■ ';
+/**
+ *
+ * ZipReader -
+ *
+ * This class is used to extract parts of a TDF. You may pull bytes of a given range from a
+ * or request specific important chunks like the 'manifest', or 'payload'.
+ */
+export class ZipReader {
+    constructor(getChunk) {
+        this.getChunk = getChunk;
+    }
+    /**
+     * Utility function to get the centralDirectory for the zip file.
+     * It reads the end of the file to find it.
+     * @return The central directory represented as an object
+     */
+    async getCentralDirectory() {
+        const chunk = await this.getChunk(-1000);
+        // TODO: Does this need to be tuned??!?
+        // Slice off the EOCDR (End of Central Directory Record) part of the buffer so we can figure out the CD size
+        const cdBuffers = this.getCDBuffers(chunk);
+        const cdParsedBuffers = cdBuffers.map(parseCDBuffer);
+        for (const buffer of cdParsedBuffers) {
+            await this.adjustHeaders(buffer);
+        }
+        return cdParsedBuffers;
+    }
+    /**
+     * Gets the manifest
+     * @returns The manifest as a buffer represented as JSON
+     */
+    async getManifest(cdBuffers, manifestFileName) {
+        const cdObj = cdBuffers.find(({ fileName }) => fileName === manifestFileName);
+        if (!cdObj) {
+            throw new InvalidFileError('Unable to retrieve CD manifest');
+        }
+        const byteStart = cdObj.relativeOffsetOfLocalHeader + cdObj.headerLength;
+        if (cdObj.uncompressedSize > manifestMaxSize) {
+            throw new InvalidFileError(`manifest file too large: ${(cdObj.uncompressedSize >> 10).toLocaleString()} KiB`);
+        }
+        const byteEnd = byteStart + cdObj.uncompressedSize;
+        const manifest = await this.getChunk(byteStart, byteEnd);
+        return JSON.parse(new TextDecoder().decode(manifest));
+    }
+    async adjustHeaders(cdObj) {
+        if (!cdObj) {
+            throw new InvalidFileError('Unable to retrieve CD adjust');
+        }
+        // Calculate header length -- tdf3-js writes 0 in all the header fields
+        // and does not include extra field for zip64
+        const headerChunk = await this.getChunk(cdObj.relativeOffsetOfLocalHeader, cdObj.relativeOffsetOfLocalHeader + cdObj.headerLength);
+        cdObj.headerLength = recalculateHeaderLength(headerChunk);
+    }
+    async getPayloadSegment(cdBuffers, payloadName, encrpytedSegmentOffset, encryptedSegmentSize) {
+        const cdObj = cdBuffers.find(({ fileName }) => payloadName === fileName);
+        if (!cdObj) {
+            throw new InvalidFileError('Unable to retrieve CD');
+        }
+        const byteStart = cdObj.relativeOffsetOfLocalHeader + cdObj.headerLength + encrpytedSegmentOffset;
+        // TODO: what's the exact byte start?
+        const byteEnd = byteStart + encryptedSegmentSize;
+        return await this.getChunk(byteStart, byteEnd);
+    }
+    /**
+     * extracts the CD buffer entries from the end of a zip file.
+     * @param  chunkBuffer The last portion of a zip file
+     * @returns an array of typed arrays, each element corresponding to a central directory record
+     */
+    getCDBuffers(chunkBuffer) {
+        const cdBuffers = [];
+        let lastBufferOffset = chunkBuffer.length;
+        for (let i = chunkBuffer.length - 22; i >= 0; i -= 1) {
+            // If what we're locking at isn't the start of a central directory, skip it..
+            if (readUInt32LE(chunkBuffer, i) !== CD_SIGNATURE) {
+                // eslint-disable-next-line no-continue
+                continue;
+            }
+            // Slice off that CD from it's start until the end of either the buffer, or whatever the start of the previously
+            // found CD was
+            cdBuffers.push(chunkBuffer.slice(i, lastBufferOffset));
+            // Store the last offset location so we know how to slice off hte next CD.
+            lastBufferOffset = i;
+            // We can skip over 22 iterations since we know the minimum size of a CD is 22.
+            i -= 22;
+        }
+        // They should be in the correct order. Since we iterate backwards, it's built backwards.
+        return cdBuffers.reverse();
+    }
+}
+function parseCentralDirectoryWithNoExtras(cdBuffer) {
+    const cd = {};
+    // 4 - Version made by
+    cd.versionMadeBy = readUInt16LE(cdBuffer, 4);
+    // 6 - Version needed to extract (minimum)
+    cd.versionNeededToExtract = readUInt16LE(cdBuffer, 6);
+    // 8 - General purpose bit flag
+    cd.generalPurposeBitFlag = readUInt16LE(cdBuffer, 8);
+    // 10 - Compression method
+    cd.compressionMethod = readUInt16LE(cdBuffer, 10);
+    // 12 - File last modification time
+    cd.lastModFileTime = readUInt16LE(cdBuffer, 12);
+    // 14 - File last modification date
+    cd.lastModFileDate = readUInt16LE(cdBuffer, 14);
+    // 16 - CRC-32
+    cd.crc32 = readUInt32LE(cdBuffer, 16);
+    // 20 - Compressed size
+    cd.compressedSize = readUInt32LE(cdBuffer, 20);
+    // 24 - Uncompressed size
+    cd.uncompressedSize = readUInt32LE(cdBuffer, 24);
+    // 28 - File name length (n)
+    cd.fileNameLength = readUInt16LE(cdBuffer, 28);
+    // 30 - Extra field length (m)
+    cd.extraFieldLength = readUInt16LE(cdBuffer, 30);
+    // 32 - File comment length (k)
+    cd.fileCommentLength = readUInt16LE(cdBuffer, 32);
+    // 34 - Disk number where file starts
+    // 36 - Internal file attributes
+    cd.internalFileAttributes = readUInt16LE(cdBuffer, 36);
+    // 38 - External file attributes
+    cd.externalFileAttributes = readUInt32LE(cdBuffer, 38);
+    // 42 - Relative offset of local file header
+    cd.relativeOffsetOfLocalHeader = readUInt32LE(cdBuffer, 42);
+    const fileNameBuffer = cdBuffer.slice(CENTRAL_DIRECTORY_RECORD_FIXED_SIZE, CENTRAL_DIRECTORY_RECORD_FIXED_SIZE + cd.fileNameLength);
+    // eslint-disable-next-line no-bitwise
+    const isUtf8 = !!(cd.generalPurposeBitFlag & 0x800);
+    cd.fileName = bufferToString(fileNameBuffer, 0, cd.fileNameLength, isUtf8);
+    cd.headerLength = LOCAL_FILE_HEADER_FIXED_SIZE + cd.fileNameLength + cd.extraFieldLength;
+    return cd;
+}
+/**
+ * Takes a central directory buffer and turns it into a manageable object
+ * that represents the CD
+ * @param  cdBuffer The central directory buffer to parse
+ * @return The CD object
+ */
+export function parseCDBuffer(cdBuffer) {
+    if (readUInt32LE(cdBuffer, 0) !== CD_SIGNATURE) {
+        throw new InvalidFileError('Invalid central directory file header signature');
+    }
+    const cd = parseCentralDirectoryWithNoExtras(cdBuffer);
+    if (cd.versionNeededToExtract < VERSION_NEEDED_TO_EXTRACT_ZIP64 || !cd.extraFieldLength) {
+        // NOTE(PLAT-1134) Zip64 was added in pkzip 4.5
+        return cd;
+    }
+    // Zip-64 information
+    const extraFieldBuffer = cdBuffer.slice(CENTRAL_DIRECTORY_RECORD_FIXED_SIZE + cd.fileNameLength, CENTRAL_DIRECTORY_RECORD_FIXED_SIZE + cd.fileNameLength + cd.extraFieldLength);
+    const extraFields = sliceExtraFields(extraFieldBuffer, cd);
+    const zip64EiefBuffer = extraFields[1];
+    if (zip64EiefBuffer) {
+        let index = 0;
+        // 0 - Original Size          8 bytes
+        if (cd.uncompressedSize === 0xffffffff) {
+            if (index + 8 > zip64EiefBuffer.length) {
+                throw new InvalidFileError('zip64 extended information extra field does not include uncompressed size');
+            }
+            cd.uncompressedSize = readUInt64LE(zip64EiefBuffer, index);
+            index += 8;
+        }
+        // 8 - Compressed Size        8 bytes
+        if (cd.compressedSize === 0xffffffff) {
+            if (index + 8 > zip64EiefBuffer.length) {
+                throw new InvalidFileError('zip64 extended information extra field does not include compressed size');
+            }
+            cd.compressedSize = readUInt64LE(zip64EiefBuffer, index);
+            index += 8;
+        }
+        // 16 - Relative Header Offset 8 bytes
+        if (cd.relativeOffsetOfLocalHeader === 0xffffffff) {
+            if (index + 8 > zip64EiefBuffer.length) {
+                throw new InvalidFileError('zip64 extended information extra field does not include relative header offset');
+            }
+            cd.relativeOffsetOfLocalHeader = readUInt64LE(zip64EiefBuffer, index);
+        }
+        // 24 - Disk Start Number      4 bytes
+        // not needed
+    }
+    return cd;
+}
+/**
+ * Takes a buffer, and turns it into a string
+ * @param  buffer The buffer to convert
+ * @param  start  The start location of the part of the buffer to convert
+ * @param  end    The end location of the part of the buffer to convert
+ * @param  isUtf8 Is it utf8? Otherwise, assumed to be CP-437
+ * @return The converted string
+ */
+function bufferToString(buffer, start, end, isUtf8) {
+    if (isUtf8) {
+        return buffToString(buffer, 'utf-8', start, end);
+    }
+    let result = '';
+    for (let i = start; i < end; i++) {
+        if (cp437[buffer[i]]) {
+            result += cp437[buffer[i]];
+        }
+    }
+    return result;
+}
+function recalculateHeaderLength(tempHeaderBuffer) {
+    const fileNameLength = readUInt16LE(tempHeaderBuffer, 26);
+    const extraFieldLength = readUInt16LE(tempHeaderBuffer, 28);
+    return LOCAL_FILE_HEADER_FIXED_SIZE + fileNameLength + extraFieldLength;
+}
+export function readUInt64LE(buffer, offset) {
+    const lower32 = readUInt32LE(buffer, offset);
+    const upper32 = readUInt32LE(buffer, offset + 4);
+    const combined = upper32 * 0x100000000 + lower32;
+    if (!Number.isSafeInteger(combined)) {
+        throw Error(`Value exceeds MAX_SAFE_INTEGER: ${combined}`);
+    }
+    return combined;
+}
+/**
+ * Breaks extra field buffer into slices by field identifier.
+ */
+function sliceExtraFields(extraFieldBuffer, cd) {
+    const extraFields = {};
+    let i = 0;
+    while (i < extraFieldBuffer.length - 3) {
+        const headerId = readUInt16LE(extraFieldBuffer, i + 0);
+        const dataSize = readUInt16LE(extraFieldBuffer, i + 2);
+        const dataStart = i + 4;
+        const dataEnd = dataStart + dataSize;
+        if (dataEnd > extraFieldBuffer.length) {
+            throw new InvalidFileError('extra field length exceeds extra field buffer size');
+        }
+        const dataBuffer = new Uint8Array(dataSize);
+        copyUint8Arr(extraFieldBuffer, dataBuffer, 0, dataStart, dataEnd);
+        if (extraFields[headerId]) {
+            throw new InvalidFileError(`Conflicting extra field #${headerId} for entry [${cd.fileName}]`);
+        }
+        extraFields[headerId] = dataBuffer;
+        i = dataEnd;
+    }
+    return extraFields;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"zip-reader.js","sourceRoot":"","sources":["../../../../../tdf3/src/utils/zip-reader.ts"],"names":[],"mappings":"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"}

package/dist/web/tdf3/src/utils/zip-writer.js

@@ -0,0 +1,302 @@
+import { writeUInt32LE, writeUInt16LE, concatUint8 } from './index.js';
+const CD_SIGNATURE = 0x02014b50;
+const LOCAL_FILE_HEADER_FIXED_SIZE = 30;
+const VERSION_NEEDED_TO_EXTRACT_UTF8 = 20;
+const VERSION_NEEDED_TO_EXTRACT_ZIP64 = 45;
+const FILE_NAME_IS_UTF8 = 1 << 11;
+const UNKNOWN_CRC32_AND_FILE_SIZES = 1 << 3;
+/*
+
+{ versionMadeBy: 831,
+    versionNeededToExtract: 20,
+    generalPurposeBitFlag: 2048,
+    compressionMethod: 0,
+    lastModFileTime: 29443,
+    lastModFileDate: 19762,
+    crc32: 3735382831,
+    compressedSize: 2583,
+    uncompressedSize: 2583,
+    fileNameLength: 15,
+    extraFieldLength: 0,
+    fileCommentLength: 0,
+    internalFileAttributes: 0,
+    externalFileAttributes: 2176057344,
+    relativeOffsetOfLocalHeader: 0,
+    fileName: '0.manifest.json',
+    headerLength: 45 }
+
+
+*/
+const CENTRAL_DIRECTORY_RECORD_FIXED_SIZE = 46;
+const ZIP64_EXTENDED_INFORMATION_EXTRA_FIELD_SIZE = 28;
+// 3 = unix. 63 = spec version 6.3
+const VERSION_MADE_BY = (3 << 8) | 63;
+const NO_COMPRESSION = 0;
+const DATA_DESCRIPTOR_SIZE = 16;
+const ZIP64_DATA_DESCRIPTOR_SIZE = 24;
+const END_OF_CENTRAL_DIRECTORY_RECORD_SIZE = 22;
+const ZIP64_END_OF_CENTRAL_DIRECTORY_RECORD_SIZE = 56;
+const ZIP64_END_OF_CENTRAL_DIRECTORY_LOCATOR_SIZE = 20;
+// write a 64bit integer by writing 2 32bit integers
+export function writeUInt64LE(buffer, n, offset) {
+    if (!Number.isSafeInteger(n)) {
+        throw new Error(`internal: unsafe number [${n}]`);
+    }
+    const high = Math.floor(n / 0x100000000);
+    const low = n % 0x100000000;
+    writeUInt32LE(buffer, low, offset);
+    writeUInt32LE(buffer, high, offset + 4);
+}
+// MS-DOS 64 bit date/time fields, as described:
+// https://docs.microsoft.com/en-us/windows/win32/api/winbase/nf-winbase-dosdatetimetofiletime
+export function dateToDosDateTime(jsDate) {
+    let date = 0;
+    date |= jsDate.getDate() & 0x1f; // 1-31
+    date |= ((jsDate.getMonth() + 1) & 0xf) << 5; // 0-11, 1-12
+    date |= ((jsDate.getFullYear() - 1980) & 0x7f) << 9; // 0-128, 1980-2108
+    let time = 0;
+    time |= Math.floor(jsDate.getSeconds() / 2); // 0-59, 0-29 (lose odd numbers)
+    time |= (jsDate.getMinutes() & 0x3f) << 5; // 0-59
+    time |= (jsDate.getHours() & 0x1f) << 11; // 0-23
+    return { date, time };
+}
+/**
+ * Utilities for writing zip file structures.
+ */
+export class ZipWriter {
+    constructor() {
+        // Enable zip64
+        this.zip64 = true;
+    }
+    getLocalFileHeader(utf8FileName, crc32, compressedSize, uncompressedSize, now = new Date()) {
+        const fixedSizeStuff = new Uint8Array(LOCAL_FILE_HEADER_FIXED_SIZE);
+        let generalPurposeBitFlag = FILE_NAME_IS_UTF8;
+        // we can't know the size in advance
+        // TODO: this means we need to add a data descriptor!
+        generalPurposeBitFlag |= UNKNOWN_CRC32_AND_FILE_SIZES;
+        const dateModified = dateToDosDateTime(now);
+        const filenameBuffer = new TextEncoder().encode(utf8FileName);
+        // local file header signature     4 bytes  (0x04034b50)
+        writeUInt32LE(fixedSizeStuff, 0x04034b50, 0);
+        // version needed to extract       2 bytes
+        writeUInt16LE(fixedSizeStuff, VERSION_NEEDED_TO_EXTRACT_UTF8, 4);
+        // general purpose bit flag        2 bytes
+        writeUInt16LE(fixedSizeStuff, generalPurposeBitFlag, 6);
+        // compression method              2 bytes
+        writeUInt16LE(fixedSizeStuff, NO_COMPRESSION, 8);
+        // last mod file time              2 bytes
+        writeUInt16LE(fixedSizeStuff, dateModified.time, 10);
+        // last mod file date              2 bytes
+        writeUInt16LE(fixedSizeStuff, dateModified.date, 12);
+        // crc-32                          4 bytes
+        writeUInt32LE(fixedSizeStuff, crc32, 14);
+        // compressed size                 4 bytes
+        writeUInt32LE(fixedSizeStuff, this.zip64 ? 0xffffffff : compressedSize, 18);
+        // uncompressed size               4 bytes
+        writeUInt32LE(fixedSizeStuff, this.zip64 ? 0xffffffff : uncompressedSize, 22);
+        // file name length                2 bytes
+        writeUInt16LE(fixedSizeStuff, filenameBuffer.length, 26);
+        let zeiefBuffer = new Uint8Array(0);
+        if (this.zip64) {
+            // ZIP64 extended information extra field
+            zeiefBuffer = new Uint8Array(ZIP64_EXTENDED_INFORMATION_EXTRA_FIELD_SIZE);
+            // 0x0001                  2 bytes    Tag for this "extra" block type
+            writeUInt16LE(zeiefBuffer, 0x0001, 0);
+            // size                    2 bytes    Size of this "extra" block
+            writeUInt16LE(zeiefBuffer, ZIP64_EXTENDED_INFORMATION_EXTRA_FIELD_SIZE - 4, 2);
+            writeUInt64LE(zeiefBuffer, compressedSize, 4);
+            writeUInt64LE(zeiefBuffer, uncompressedSize, 12);
+            writeUInt64LE(zeiefBuffer, 0, 20);
+        }
+        // extra field length              2 bytes
+        writeUInt16LE(fixedSizeStuff, zeiefBuffer.length, 28);
+        return concatUint8([
+            fixedSizeStuff,
+            // file name (variable size)
+            filenameBuffer,
+            // extra field (variable size)
+            zeiefBuffer,
+        ]);
+    }
+    writeDataDescriptor(crc32, uncompressedSize) {
+        // NOTE(PLAT-1134): optional signature (required according to Archive Utility)
+        // 4.3.9.3 Although not originally assigned a signature, the value
+        // 0x08074b50 has commonly been adopted as a signature value
+        // for the data descriptor record.  Implementers should be
+        // aware that ZIP files may be encountered with or without this
+        // signature marking data descriptors and SHOULD account for
+        // either case when reading ZIP files to ensure compatibility.
+        const ddSig = 0x08074b50;
+        let buffer;
+        if (this.zip64) {
+            // 4.3.9.2 When compressing files, compressed and uncompressed sizes
+            // SHOULD be stored in ZIP64 format (as 8 byte values) when a
+            // file's size exceeds 0xFFFFFFFF.   However ZIP64 format MAY be
+            // used regardless of the size of a file.  When extracting, if
+            // the zip64 extended information extra field is present for
+            // the file the compressed and uncompressed sizes will be 8
+            // byte values.
+            buffer = new Uint8Array(ZIP64_DATA_DESCRIPTOR_SIZE);
+            writeUInt32LE(buffer, crc32, 4);
+            writeUInt32LE(buffer, ddSig, 0);
+            // We just use STORE, so compressed and uncompressed are the same.
+            writeUInt64LE(buffer, uncompressedSize, 8);
+            writeUInt64LE(buffer, uncompressedSize, 16);
+        }
+        else {
+            buffer = new Uint8Array(DATA_DESCRIPTOR_SIZE);
+            writeUInt32LE(buffer, ddSig, 0);
+            writeUInt32LE(buffer, crc32, 4);
+            writeUInt32LE(buffer, uncompressedSize, 8);
+            writeUInt32LE(buffer, uncompressedSize, 12);
+        }
+        return buffer;
+    }
+    writeCentralDirectoryRecord(uncompressedSize, utf8FileName, relativeOffsetOfLocalHeader, crc32, externalFileAttributes, now = new Date()) {
+        const fixedSizeStuff = new Uint8Array(CENTRAL_DIRECTORY_RECORD_FIXED_SIZE);
+        let generalPurposeBitFlag = FILE_NAME_IS_UTF8;
+        // we can't know the size in advance
+        // TODO: this means we need to add a data descriptor!
+        generalPurposeBitFlag |= UNKNOWN_CRC32_AND_FILE_SIZES;
+        let normalCompressedSize = uncompressedSize;
+        let normalUncompressedSize = uncompressedSize;
+        let normalRelativeOffsetOfLocalHeader = relativeOffsetOfLocalHeader;
+        let versionNeededToExtract = VERSION_NEEDED_TO_EXTRACT_UTF8;
+        let zeiefBuffer = new Uint8Array(0);
+        if (this.zip64) {
+            versionNeededToExtract = VERSION_NEEDED_TO_EXTRACT_ZIP64;
+            normalCompressedSize = 0xffffffff;
+            normalUncompressedSize = 0xffffffff;
+            normalRelativeOffsetOfLocalHeader = 0xffffffff;
+            // ZIP64 extended information extra field
+            zeiefBuffer = new Uint8Array(ZIP64_EXTENDED_INFORMATION_EXTRA_FIELD_SIZE);
+            // 0x0001                  2 bytes    Tag for this "extra" block type
+            writeUInt16LE(zeiefBuffer, 0x0001, 0);
+            // size                    2 bytes    Size of this "extra" block
+            writeUInt16LE(zeiefBuffer, ZIP64_EXTENDED_INFORMATION_EXTRA_FIELD_SIZE - 4, 2);
+            // uncompressed size       8 bytes    Original uncompressed file size
+            writeUInt64LE(zeiefBuffer, uncompressedSize, 4);
+            // compressed Size          8 bytes    Size of compressed data
+            writeUInt64LE(zeiefBuffer, uncompressedSize, 12);
+            // relative header offset  8 bytes    Offset of local header record
+            writeUInt64LE(zeiefBuffer, relativeOffsetOfLocalHeader, 20);
+            // Disk Start Number       4 bytes    Number of the disk on which this file starts
+            // (omit)
+            // console.log(`zeif Buffer ${utf8FileName}: ${zeiefBuffer.toString('hex')}`);
+        }
+        const dateModified = dateToDosDateTime(now);
+        const filenameBuffer = new TextEncoder().encode(utf8FileName);
+        // central file header signature   4 bytes  (0x02014b50)
+        writeUInt32LE(fixedSizeStuff, CD_SIGNATURE, 0);
+        // version made by                 2 bytes
+        writeUInt16LE(fixedSizeStuff, VERSION_MADE_BY, 4);
+        // version needed to extract       2 bytes
+        writeUInt16LE(fixedSizeStuff, versionNeededToExtract, 6);
+        // general purpose bit flag        2 bytes
+        writeUInt16LE(fixedSizeStuff, generalPurposeBitFlag, 8);
+        // compression method              2 bytes
+        writeUInt16LE(fixedSizeStuff, NO_COMPRESSION, 10);
+        // last mod file time              2 bytes
+        writeUInt16LE(fixedSizeStuff, dateModified.time, 12);
+        // last mod file date              2 bytes
+        writeUInt16LE(fixedSizeStuff, dateModified.date, 14);
+        // crc-32                          4 bytes
+        writeUInt32LE(fixedSizeStuff, crc32, 16);
+        // compressed size                 4 bytes
+        writeUInt32LE(fixedSizeStuff, normalCompressedSize, 20);
+        // uncompressed size               4 bytes
+        writeUInt32LE(fixedSizeStuff, normalUncompressedSize, 24);
+        // file name length                2 bytes
+        writeUInt16LE(fixedSizeStuff, filenameBuffer.length, 28);
+        // extra field length              2 bytes
+        writeUInt16LE(fixedSizeStuff, zeiefBuffer.length, 30);
+        // file comment length             2 bytes
+        writeUInt16LE(fixedSizeStuff, 0, 32);
+        // disk number start               2 bytes
+        writeUInt16LE(fixedSizeStuff, 0, 34);
+        // internal file attributes        2 bytes
+        writeUInt16LE(fixedSizeStuff, 0, 36);
+        // external file attributes        4 bytes
+        writeUInt32LE(fixedSizeStuff, externalFileAttributes, 38);
+        // relative offset of local header 4 bytes
+        writeUInt32LE(fixedSizeStuff, normalRelativeOffsetOfLocalHeader, 42);
+        return concatUint8([
+            fixedSizeStuff,
+            // file name (variable size)
+            filenameBuffer,
+            // extra field (variable size)
+            zeiefBuffer,
+            // file comment (variable size)
+            // empty comment
+        ]);
+    }
+    writeEndOfCentralDirectoryRecord(entriesLength, sizeOfCentralDirectory, offsetOfStartOfCentralDirectory) {
+        let normalEntriesLength = entriesLength;
+        let normalSizeOfCentralDirectory = sizeOfCentralDirectory;
+        let normalOffsetOfStartOfCentralDirectory = offsetOfStartOfCentralDirectory;
+        if (this.zip64) {
+            normalEntriesLength = 0xffff;
+            normalSizeOfCentralDirectory = 0xffffffff;
+            normalOffsetOfStartOfCentralDirectory = 0xffffffff;
+        }
+        const eocdrBuffer = new Uint8Array(END_OF_CENTRAL_DIRECTORY_RECORD_SIZE);
+        // end of central dir signature                       4 bytes  (0x06054b50)
+        writeUInt32LE(eocdrBuffer, 0x06054b50, 0);
+        // number of this disk                                2 bytes
+        writeUInt16LE(eocdrBuffer, 0, 4);
+        // number of the disk with the start of the central directory  2 bytes
+        writeUInt16LE(eocdrBuffer, 0, 6);
+        // total number of entries in the central directory on this disk  2 bytes
+        writeUInt16LE(eocdrBuffer, normalEntriesLength, 8);
+        // total number of entries in the central directory   2 bytes
+        writeUInt16LE(eocdrBuffer, normalEntriesLength, 10);
+        // size of the central directory                      4 bytes
+        writeUInt32LE(eocdrBuffer, normalSizeOfCentralDirectory, 12);
+        // offset of start of central directory with respect to the starting disk number  4 bytes
+        writeUInt32LE(eocdrBuffer, normalOffsetOfStartOfCentralDirectory, 16);
+        // .ZIP file comment length                           2 bytes
+        writeUInt16LE(eocdrBuffer, 0, 20);
+        // .ZIP file comment                                  (variable size)
+        // no comment
+        if (!this.zip64) {
+            return eocdrBuffer;
+        }
+        // ZIP64 format
+        // ZIP64 End of Central Directory Record
+        const zip64EocdrBuffer = new Uint8Array(ZIP64_END_OF_CENTRAL_DIRECTORY_RECORD_SIZE);
+        // zip64 end of central dir signature                                             4 bytes  (0x06064b50)
+        writeUInt32LE(zip64EocdrBuffer, 0x06064b50, 0);
+        // size of zip64 end of central directory record                                  8 bytes
+        writeUInt64LE(zip64EocdrBuffer, ZIP64_END_OF_CENTRAL_DIRECTORY_RECORD_SIZE - 12, 4);
+        // version made by                                                                2 bytes
+        writeUInt16LE(zip64EocdrBuffer, VERSION_MADE_BY, 12);
+        // version needed to extract                                                      2 bytes
+        writeUInt16LE(zip64EocdrBuffer, VERSION_NEEDED_TO_EXTRACT_ZIP64, 14);
+        // number of this disk                                                            4 bytes
+        writeUInt32LE(zip64EocdrBuffer, 0, 16);
+        // number of the disk with the start of the central directory                     4 bytes
+        writeUInt32LE(zip64EocdrBuffer, 0, 20);
+        // total number of entries in the central directory on this disk                  8 bytes
+        writeUInt64LE(zip64EocdrBuffer, entriesLength, 24);
+        // total number of entries in the central directory                               8 bytes
+        writeUInt64LE(zip64EocdrBuffer, entriesLength, 32);
+        // size of the central directory                                                  8 bytes
+        writeUInt64LE(zip64EocdrBuffer, sizeOfCentralDirectory, 40);
+        // offset of start of central directory with respect to the starting disk number  8 bytes
+        writeUInt64LE(zip64EocdrBuffer, offsetOfStartOfCentralDirectory, 48);
+        // zip64 extensible data sector                                                   (variable size)
+        // nothing in the zip64 extensible data sector
+        // ZIP64 End of Central Directory Locator
+        const zip64EocdlBuffer = new Uint8Array(ZIP64_END_OF_CENTRAL_DIRECTORY_LOCATOR_SIZE);
+        // zip64 end of central dir locator signature                               4 bytes  (0x07064b50)
+        writeUInt32LE(zip64EocdlBuffer, 0x07064b50, 0);
+        // number of the disk with the start of the zip64 end of central directory  4 bytes
+        writeUInt32LE(zip64EocdlBuffer, 0, 4);
+        // relative offset of the zip64 end of central directory record             8 bytes
+        writeUInt64LE(zip64EocdlBuffer, offsetOfStartOfCentralDirectory + sizeOfCentralDirectory, 8);
+        // total number of disks                                                    4 bytes
+        writeUInt32LE(zip64EocdlBuffer, 1, 16);
+        return concatUint8([zip64EocdrBuffer, zip64EocdlBuffer, eocdrBuffer]);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"zip-writer.js","sourceRoot":"","sources":["../../../../../tdf3/src/utils/zip-writer.ts"],"names":[],"mappings":"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"}

package/dist/web/tdf3/src/version.js

@@ -0,0 +1,3 @@
+export const version = '0.1.0';
+export const clientType = 'tdf3-js-client';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidmVyc2lvbi5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3RkZjMvc3JjL3ZlcnNpb24udHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsTUFBTSxDQUFDLE1BQU0sT0FBTyxHQUFHLE9BQU8sQ0FBQztBQUMvQixNQUFNLENBQUMsTUFBTSxVQUFVLEdBQUcsZ0JBQWdCLENBQUMifQ==