open-agreements 0.7.6 → 0.8.0

package/node_modules/jszip/index.d.ts

@@ -0,0 +1,330 @@
+// Type definitions for JSZip 3.1
+// Project: http://stuk.github.com/jszip/, https://github.com/stuk/jszip
+// Definitions by: mzeiher <https://github.com/mzeiher>, forabi <https://github.com/forabi>
+// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.3
+
+/// <reference types="node" />
+
+interface JSZipSupport {
+    arraybuffer: boolean;
+    uint8array: boolean;
+    blob: boolean;
+    nodebuffer: boolean;
+}
+
+type Compression = 'STORE' | 'DEFLATE';
+
+/**
+ * Depends on the compression type. With `STORE` (no compression), these options are ignored. With
+ * `DEFLATE`, you can give the compression level between 1 (best speed) and 9 (best compression).
+ */
+interface CompressionOptions {
+    level: number;
+}
+
+interface InputByType {
+    base64: string;
+    string: string;
+    text: string;
+    binarystring: string;
+    array: number[];
+    uint8array: Uint8Array;
+    arraybuffer: ArrayBuffer;
+    blob: Blob;
+    stream: NodeJS.ReadableStream;
+}
+
+interface OutputByType {
+    base64: string;
+    string: string;
+    text: string;
+    binarystring: string;
+    array: number[];
+    uint8array: Uint8Array;
+    arraybuffer: ArrayBuffer;
+    blob: Blob;
+    nodebuffer: Buffer;
+}
+
+// This private `_data` property on a JSZipObject uses this interface.
+// If/when it is made public this should be uncommented.
+// interface CompressedObject {
+//     compressedSize: number;
+//     uncompressedSize: number;
+//     crc32: number;
+//     compression: object;
+//     compressedContent: string|ArrayBuffer|Uint8Array|Buffer;
+// }
+
+type InputFileFormat = InputByType[keyof InputByType] | Promise<InputByType[keyof InputByType]>;
+
+declare namespace JSZip {
+    type InputType = keyof InputByType;
+
+    type OutputType = keyof OutputByType;
+
+    interface JSZipMetadata {
+        percent: number;
+        currentFile: string | null;
+    }
+
+    type OnUpdateCallback = (metadata: JSZipMetadata) => void;
+
+    interface JSZipObject {
+        name: string;
+        /**
+         * Present for files loadded with `loadAsync`. May contain ".." path components that could
+         * result in a zip-slip attack. See https://snyk.io/research/zip-slip-vulnerability
+         */
+        unsafeOriginalName?: string;
+        dir: boolean;
+        date: Date;
+        comment: string;
+        /** The UNIX permissions of the file, if any. */
+        unixPermissions: number | string | null;
+        /** The UNIX permissions of the file, if any. */
+        dosPermissions: number | null;
+        options: JSZipObjectOptions;
+
+        /**
+         * Prepare the content in the asked type.
+         * @param type the type of the result.
+         * @param onUpdate a function to call on each internal update.
+         * @return Promise the promise of the result.
+         */
+        async<T extends OutputType>(type: T, onUpdate?: OnUpdateCallback): Promise<OutputByType[T]>;
+        nodeStream(type?: 'nodebuffer', onUpdate?: OnUpdateCallback): NodeJS.ReadableStream;
+    }
+
+    interface JSZipFileOptions {
+        /** Set to `true` if the data is `base64` encoded. For example image data from a `<canvas>` element. Plain text and HTML do not need this option. */
+        base64?: boolean;
+        /**
+         * Set to `true` if the data should be treated as raw content, `false` if this is a text. If `base64` is used,
+         * this defaults to `true`, if the data is not a `string`, this will be set to `true`.
+         */
+        binary?: boolean;
+        /**
+         * The last modification date, defaults to the current date.
+         */
+        date?: Date;
+        /**
+         * Sets per file compression. The `compressionOptions` parameter depends on the compression type.
+         */
+        compression?: Compression;
+        /**
+         * Sets per file compression level for `DEFLATE` compression.
+         */
+        compressionOptions?: null | CompressionOptions;
+        comment?: string;
+        /** Set to `true` if (and only if) the input is a "binary string" and has already been prepared with a `0xFF` mask. */
+        optimizedBinaryString?: boolean;
+        /** Set to `true` if folders in the file path should be automatically created, otherwise there will only be virtual folders that represent the path to the file. */
+        createFolders?: boolean;
+        /** Set to `true` if this is a directory and content should be ignored. */
+        dir?: boolean;
+
+        /** 6 bits number. The DOS permissions of the file, if any. */
+        dosPermissions?: number | null;
+        /**
+         * 16 bits number. The UNIX permissions of the file, if any.
+         * Also accepts a `string` representing the octal value: `"644"`, `"755"`, etc.
+         */
+        unixPermissions?: number | string | null;
+    }
+
+    interface JSZipObjectOptions {
+        compression: Compression;
+    }
+
+    interface JSZipGeneratorOptions<T extends OutputType = OutputType> {
+        /**
+         * Sets compression option for all entries that have not specified their own `compression` option
+         */
+        compression?: Compression;
+        /**
+         * Sets compression level for `DEFLATE` compression.
+         */
+        compressionOptions?: null | CompressionOptions;
+        type?: T;
+        comment?: string;
+        /**
+         * mime-type for the generated file.
+         * Useful when you need to generate a file with a different extension, ie: “.ods”.
+         * @default 'application/zip'
+         */
+        mimeType?: string;
+        encodeFileName?(filename: string): string;
+        /** Stream the files and create file descriptors */
+        streamFiles?: boolean;
+        /** DOS (default) or UNIX */
+        platform?: 'DOS' | 'UNIX';
+    }
+
+    interface JSZipLoadOptions {
+        base64?: boolean;
+        checkCRC32?: boolean;
+        optimizedBinaryString?: boolean;
+        createFolders?: boolean;
+        decodeFileName?: (bytes: string[] | Uint8Array | Buffer) => string;
+    }
+
+    type DataEventCallback<T> = (dataChunk: T, metadata: JSZipMetadata) => void
+    type EndEventCallback = () => void
+    type ErrorEventCallback = (error: Error) => void
+
+    interface JSZipStreamHelper<T> {
+        /**
+         * Register a listener on an event
+         */
+        on(event: 'data', callback: DataEventCallback<T>): this;
+        on(event: 'end', callback: EndEventCallback): this;
+        on(event: 'error', callback: ErrorEventCallback): this;
+
+        /**
+         * Read the whole stream and call a callback with the complete content
+         *
+         * @param updateCallback The function called every time the stream updates
+         * @return A Promise of the full content
+         */
+        accumulate(updateCallback?: (metadata: JSZipMetadata) => void): Promise<T>;
+
+        /**
+         * Resume the stream if the stream is paused. Once resumed, the stream starts sending data events again
+         *
+         * @return The current StreamHelper object, for chaining
+         */
+        resume(): this;
+
+        /**
+         * Pause the stream if the stream is running. Once paused, the stream stops sending data events
+         *
+         * @return The current StreamHelper object, for chaining
+         */
+        pause(): this;
+    }
+}
+
+interface JSZip {
+    files: {[key: string]: JSZip.JSZipObject};
+
+    /**
+     * Get a file from the archive
+     *
+     * @param Path relative path to file
+     * @return File matching path, null if no file found
+     */
+    file(path: string): JSZip.JSZipObject | null;
+
+    /**
+     * Get files matching a RegExp from archive
+     *
+     * @param path RegExp to match
+     * @return Return all matching files or an empty array
+     */
+    file(path: RegExp): JSZip.JSZipObject[];
+
+    /**
+     * Add a file to the archive
+     *
+     * @param path Relative path to file
+     * @param data Content of the file
+     * @param options Optional information about the file
+     * @return JSZip object
+     */
+    file<T extends JSZip.InputType>(path: string, data: InputByType[T] | Promise<InputByType[T]>, options?: JSZip.JSZipFileOptions): this;
+    file<T extends JSZip.InputType>(path: string, data: null, options?: JSZip.JSZipFileOptions & { dir: true }): this;
+
+    /**
+     * Returns an new JSZip instance with the given folder as root
+     *
+     * @param name Name of the folder
+     * @return New JSZip object with the given folder as root or null
+     */
+    folder(name: string): JSZip | null;
+
+    /**
+     * Returns new JSZip instances with the matching folders as root
+     *
+     * @param name RegExp to match
+     * @return New array of JSZipFile objects which match the RegExp
+     */
+    folder(name: RegExp): JSZip.JSZipObject[];
+
+    /**
+     * Call a callback function for each entry at this folder level.
+     *
+     * @param callback function
+     */
+    forEach(callback: (relativePath: string, file: JSZip.JSZipObject) => void): void;
+
+    /**
+     * Get all files which match the given filter function
+     *
+     * @param predicate Filter function
+     * @return Array of matched elements
+     */
+    filter(predicate: (relativePath: string, file: JSZip.JSZipObject) => boolean): JSZip.JSZipObject[];
+
+    /**
+     * Removes the file or folder from the archive
+     *
+     * @param path Relative path of file or folder
+     * @return Returns the JSZip instance
+     */
+    remove(path: string): JSZip;
+
+    /**
+     * Generates a new archive asynchronously
+     *
+     * @param options Optional options for the generator
+     * @param onUpdate The optional function called on each internal update with the metadata.
+     * @return The serialized archive
+     */
+    generateAsync<T extends JSZip.OutputType>(options?: JSZip.JSZipGeneratorOptions<T>, onUpdate?: JSZip.OnUpdateCallback): Promise<OutputByType[T]>;
+
+    /**
+     * Generates a new archive asynchronously
+     *
+     * @param options Optional options for the generator
+     * @param onUpdate The optional function called on each internal update with the metadata.
+     * @return A Node.js `ReadableStream`
+     */
+    generateNodeStream(options?: JSZip.JSZipGeneratorOptions<'nodebuffer'>, onUpdate?: JSZip.OnUpdateCallback): NodeJS.ReadableStream;
+
+    /**
+     * Generates the complete zip file with the internal stream implementation
+     *
+     * @param options Optional options for the generator
+     * @return a StreamHelper
+     */
+    generateInternalStream<T extends JSZip.OutputType>(options?: JSZip.JSZipGeneratorOptions<T>): JSZip.JSZipStreamHelper<OutputByType[T]>;
+
+    /**
+     * Deserialize zip file asynchronously
+     *
+     * @param data Serialized zip file
+     * @param options Options for deserializing
+     * @return Returns promise
+     */
+    loadAsync(data: InputFileFormat, options?: JSZip.JSZipLoadOptions): Promise<JSZip>;
+
+    /**
+     * Create JSZip instance
+     */
+    new(): this;
+
+    (): JSZip;
+
+    prototype: JSZip;
+    support: JSZipSupport;
+    external: {
+        Promise: PromiseConstructorLike;
+    };
+    version: string;
+}
+
+declare var JSZip: JSZip;
+
+export = JSZip;

package/node_modules/jszip/lib/base64.js

@@ -0,0 +1,106 @@
+"use strict";
+var utils = require("./utils");
+var support = require("./support");
+// private property
+var _keyStr = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=";
+
+
+// public method for encoding
+exports.encode = function(input) {
+    var output = [];
+    var chr1, chr2, chr3, enc1, enc2, enc3, enc4;
+    var i = 0, len = input.length, remainingBytes = len;
+
+    var isArray = utils.getTypeOf(input) !== "string";
+    while (i < input.length) {
+        remainingBytes = len - i;
+
+        if (!isArray) {
+            chr1 = input.charCodeAt(i++);
+            chr2 = i < len ? input.charCodeAt(i++) : 0;
+            chr3 = i < len ? input.charCodeAt(i++) : 0;
+        } else {
+            chr1 = input[i++];
+            chr2 = i < len ? input[i++] : 0;
+            chr3 = i < len ? input[i++] : 0;
+        }
+
+        enc1 = chr1 >> 2;
+        enc2 = ((chr1 & 3) << 4) | (chr2 >> 4);
+        enc3 = remainingBytes > 1 ? (((chr2 & 15) << 2) | (chr3 >> 6)) : 64;
+        enc4 = remainingBytes > 2 ? (chr3 & 63) : 64;
+
+        output.push(_keyStr.charAt(enc1) + _keyStr.charAt(enc2) + _keyStr.charAt(enc3) + _keyStr.charAt(enc4));
+
+    }
+
+    return output.join("");
+};
+
+// public method for decoding
+exports.decode = function(input) {
+    var chr1, chr2, chr3;
+    var enc1, enc2, enc3, enc4;
+    var i = 0, resultIndex = 0;
+
+    var dataUrlPrefix = "data:";
+
+    if (input.substr(0, dataUrlPrefix.length) === dataUrlPrefix) {
+        // This is a common error: people give a data url
+        // (data:image/png;base64,iVBOR...) with a {base64: true} and
+        // wonders why things don't work.
+        // We can detect that the string input looks like a data url but we
+        // *can't* be sure it is one: removing everything up to the comma would
+        // be too dangerous.
+        throw new Error("Invalid base64 input, it looks like a data url.");
+    }
+
+    input = input.replace(/[^A-Za-z0-9+/=]/g, "");
+
+    var totalLength = input.length * 3 / 4;
+    if(input.charAt(input.length - 1) === _keyStr.charAt(64)) {
+        totalLength--;
+    }
+    if(input.charAt(input.length - 2) === _keyStr.charAt(64)) {
+        totalLength--;
+    }
+    if (totalLength % 1 !== 0) {
+        // totalLength is not an integer, the length does not match a valid
+        // base64 content. That can happen if:
+        // - the input is not a base64 content
+        // - the input is *almost* a base64 content, with a extra chars at the
+        //   beginning or at the end
+        // - the input uses a base64 variant (base64url for example)
+        throw new Error("Invalid base64 input, bad content length.");
+    }
+    var output;
+    if (support.uint8array) {
+        output = new Uint8Array(totalLength|0);
+    } else {
+        output = new Array(totalLength|0);
+    }
+
+    while (i < input.length) {
+
+        enc1 = _keyStr.indexOf(input.charAt(i++));
+        enc2 = _keyStr.indexOf(input.charAt(i++));
+        enc3 = _keyStr.indexOf(input.charAt(i++));
+        enc4 = _keyStr.indexOf(input.charAt(i++));
+
+        chr1 = (enc1 << 2) | (enc2 >> 4);
+        chr2 = ((enc2 & 15) << 4) | (enc3 >> 2);
+        chr3 = ((enc3 & 3) << 6) | enc4;
+
+        output[resultIndex++] = chr1;
+
+        if (enc3 !== 64) {
+            output[resultIndex++] = chr2;
+        }
+        if (enc4 !== 64) {
+            output[resultIndex++] = chr3;
+        }
+
+    }
+
+    return output;
+};

package/node_modules/jszip/lib/compressedObject.js

@@ -0,0 +1,74 @@
+"use strict";
+
+var external = require("./external");
+var DataWorker = require("./stream/DataWorker");
+var Crc32Probe = require("./stream/Crc32Probe");
+var DataLengthProbe = require("./stream/DataLengthProbe");
+
+/**
+ * Represent a compressed object, with everything needed to decompress it.
+ * @constructor
+ * @param {number} compressedSize the size of the data compressed.
+ * @param {number} uncompressedSize the size of the data after decompression.
+ * @param {number} crc32 the crc32 of the decompressed file.
+ * @param {object} compression the type of compression, see lib/compressions.js.
+ * @param {String|ArrayBuffer|Uint8Array|Buffer} data the compressed data.
+ */
+function CompressedObject(compressedSize, uncompressedSize, crc32, compression, data) {
+    this.compressedSize = compressedSize;
+    this.uncompressedSize = uncompressedSize;
+    this.crc32 = crc32;
+    this.compression = compression;
+    this.compressedContent = data;
+}
+
+CompressedObject.prototype = {
+    /**
+     * Create a worker to get the uncompressed content.
+     * @return {GenericWorker} the worker.
+     */
+    getContentWorker: function () {
+        var worker = new DataWorker(external.Promise.resolve(this.compressedContent))
+            .pipe(this.compression.uncompressWorker())
+            .pipe(new DataLengthProbe("data_length"));
+
+        var that = this;
+        worker.on("end", function () {
+            if (this.streamInfo["data_length"] !== that.uncompressedSize) {
+                throw new Error("Bug : uncompressed data size mismatch");
+            }
+        });
+        return worker;
+    },
+    /**
+     * Create a worker to get the compressed content.
+     * @return {GenericWorker} the worker.
+     */
+    getCompressedWorker: function () {
+        return new DataWorker(external.Promise.resolve(this.compressedContent))
+            .withStreamInfo("compressedSize", this.compressedSize)
+            .withStreamInfo("uncompressedSize", this.uncompressedSize)
+            .withStreamInfo("crc32", this.crc32)
+            .withStreamInfo("compression", this.compression)
+        ;
+    }
+};
+
+/**
+ * Chain the given worker with other workers to compress the content with the
+ * given compression.
+ * @param {GenericWorker} uncompressedWorker the worker to pipe.
+ * @param {Object} compression the compression object.
+ * @param {Object} compressionOptions the options to use when compressing.
+ * @return {GenericWorker} the new worker compressing the content.
+ */
+CompressedObject.createWorkerFrom = function (uncompressedWorker, compression, compressionOptions) {
+    return uncompressedWorker
+        .pipe(new Crc32Probe())
+        .pipe(new DataLengthProbe("uncompressedSize"))
+        .pipe(compression.compressWorker(compressionOptions))
+        .pipe(new DataLengthProbe("compressedSize"))
+        .withStreamInfo("compression", compression);
+};
+
+module.exports = CompressedObject;

package/node_modules/jszip/lib/compressions.js

@@ -0,0 +1,14 @@
+"use strict";
+
+var GenericWorker = require("./stream/GenericWorker");
+
+exports.STORE = {
+    magic: "\x00\x00",
+    compressWorker : function () {
+        return new GenericWorker("STORE compression");
+    },
+    uncompressWorker : function () {
+        return new GenericWorker("STORE decompression");
+    }
+};
+exports.DEFLATE = require("./flate");

package/node_modules/jszip/lib/crc32.js

@@ -0,0 +1,77 @@
+"use strict";
+
+var utils = require("./utils");
+
+/**
+ * The following functions come from pako, from pako/lib/zlib/crc32.js
+ * released under the MIT license, see pako https://github.com/nodeca/pako/
+ */
+
+// Use ordinary array, since untyped makes no boost here
+function makeTable() {
+    var c, table = [];
+
+    for(var n =0; n < 256; n++){
+        c = n;
+        for(var k =0; k < 8; k++){
+            c = ((c&1) ? (0xEDB88320 ^ (c >>> 1)) : (c >>> 1));
+        }
+        table[n] = c;
+    }
+
+    return table;
+}
+
+// Create table on load. Just 255 signed longs. Not a problem.
+var crcTable = makeTable();
+
+
+function crc32(crc, buf, len, pos) {
+    var t = crcTable, end = pos + len;
+
+    crc = crc ^ (-1);
+
+    for (var i = pos; i < end; i++ ) {
+        crc = (crc >>> 8) ^ t[(crc ^ buf[i]) & 0xFF];
+    }
+
+    return (crc ^ (-1)); // >>> 0;
+}
+
+// That's all for the pako functions.
+
+/**
+ * Compute the crc32 of a string.
+ * This is almost the same as the function crc32, but for strings. Using the
+ * same function for the two use cases leads to horrible performances.
+ * @param {Number} crc the starting value of the crc.
+ * @param {String} str the string to use.
+ * @param {Number} len the length of the string.
+ * @param {Number} pos the starting position for the crc32 computation.
+ * @return {Number} the computed crc32.
+ */
+function crc32str(crc, str, len, pos) {
+    var t = crcTable, end = pos + len;
+
+    crc = crc ^ (-1);
+
+    for (var i = pos; i < end; i++ ) {
+        crc = (crc >>> 8) ^ t[(crc ^ str.charCodeAt(i)) & 0xFF];
+    }
+
+    return (crc ^ (-1)); // >>> 0;
+}
+
+module.exports = function crc32wrapper(input, crc) {
+    if (typeof input === "undefined" || !input.length) {
+        return 0;
+    }
+
+    var isArray = utils.getTypeOf(input) !== "string";
+
+    if(isArray) {
+        return crc32(crc|0, input, input.length, 0);
+    } else {
+        return crc32str(crc|0, input, input.length, 0);
+    }
+};

package/node_modules/jszip/lib/defaults.js

@@ -0,0 +1,11 @@
+"use strict";
+exports.base64 = false;
+exports.binary = false;
+exports.dir = false;
+exports.createFolders = true;
+exports.date = null;
+exports.compression = null;
+exports.compressionOptions = null;
+exports.comment = null;
+exports.unixPermissions = null;
+exports.dosPermissions = null;

package/node_modules/jszip/lib/external.js

@@ -0,0 +1,18 @@
+"use strict";
+
+// load the global object first:
+// - it should be better integrated in the system (unhandledRejection in node)
+// - the environment may have a custom Promise implementation (see zone.js)
+var ES6Promise = null;
+if (typeof Promise !== "undefined") {
+    ES6Promise = Promise;
+} else {
+    ES6Promise = require("lie");
+}
+
+/**
+ * Let the user use/change some implementations.
+ */
+module.exports = {
+    Promise: ES6Promise
+};