@aws-sdk/lib-storage 3.34.0 → 3.35.0

package/dist-es/Upload.js

@@ -0,0 +1,262 @@
+import { __assign, __asyncValues, __awaiter, __extends, __generator } from "tslib";
+import { CompleteMultipartUploadCommand, CreateMultipartUploadCommand, PutObjectCommand, PutObjectTaggingCommand, UploadPartCommand, } from "@aws-sdk/client-s3";
+import { EventEmitter } from "events";
+import { getChunk } from "./chunker";
+import { byteLength } from "./bytelength";
+import { AbortController } from "@aws-sdk/abort-controller";
+var MIN_PART_SIZE = 1024 * 1024 * 5;
+var Upload = (function (_super) {
+    __extends(Upload, _super);
+    function Upload(options) {
+        var _this = _super.call(this) || this;
+        _this.MAX_PARTS = 10000;
+        _this.queueSize = 4;
+        _this.partSize = MIN_PART_SIZE;
+        _this.leavePartsOnError = false;
+        _this.tags = [];
+        _this.concurrentUploaders = [];
+        _this.uploadedParts = [];
+        _this.isMultiPart = true;
+        _this.queueSize = options.queueSize || _this.queueSize;
+        _this.partSize = options.partSize || _this.partSize;
+        _this.leavePartsOnError = options.leavePartsOnError || _this.leavePartsOnError;
+        _this.tags = options.tags || _this.tags;
+        _this.client = options.client;
+        _this.params = options.params;
+        _this.__validateInput();
+        _this.totalBytes = byteLength(_this.params.Body);
+        _this.bytesUploadedSoFar = 0;
+        _this.abortController = new AbortController();
+        return _this;
+    }
+    Upload.prototype.abort = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                this.abortController.abort();
+                return [2];
+            });
+        });
+    };
+    Upload.prototype.done = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4, Promise.race([this.__doMultipartUpload(), this.__abortTimeout(this.abortController.signal)])];
+                    case 1: return [2, _a.sent()];
+                }
+            });
+        });
+    };
+    Upload.prototype.on = function (event, listener) {
+        this.uploadEvent = event;
+        _super.prototype.on.call(this, event, listener);
+    };
+    Upload.prototype.__uploadUsingPut = function (dataPart) {
+        return __awaiter(this, void 0, void 0, function () {
+            var params, putResult, totalSize;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        this.isMultiPart = false;
+                        params = __assign(__assign({}, this.params), { Body: dataPart.data });
+                        return [4, this.client.send(new PutObjectCommand(params))];
+                    case 1:
+                        putResult = _a.sent();
+                        this.putResponse = putResult;
+                        totalSize = byteLength(dataPart.data);
+                        this.__notifyProgress({
+                            loaded: totalSize,
+                            total: totalSize,
+                            part: 1,
+                            Key: this.params.Key,
+                            Bucket: this.params.Bucket,
+                        });
+                        return [2];
+                }
+            });
+        });
+    };
+    Upload.prototype.__createMultipartUpload = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var createCommandParams, createMultipartUploadResult;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (!this.createMultiPartPromise) {
+                            createCommandParams = __assign(__assign({}, this.params), { Body: undefined });
+                            this.createMultiPartPromise = this.client.send(new CreateMultipartUploadCommand(createCommandParams));
+                        }
+                        return [4, this.createMultiPartPromise];
+                    case 1:
+                        createMultipartUploadResult = _a.sent();
+                        this.uploadId = createMultipartUploadResult.UploadId;
+                        return [2];
+                }
+            });
+        });
+    };
+    Upload.prototype.__doConcurrentUpload = function (dataFeeder) {
+        var dataFeeder_1, dataFeeder_1_1;
+        var e_1, _a;
+        return __awaiter(this, void 0, void 0, function () {
+            var dataPart, partResult, e_2, e_1_1;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        _b.trys.push([0, 12, 13, 18]);
+                        dataFeeder_1 = __asyncValues(dataFeeder);
+                        _b.label = 1;
+                    case 1: return [4, dataFeeder_1.next()];
+                    case 2:
+                        if (!(dataFeeder_1_1 = _b.sent(), !dataFeeder_1_1.done)) return [3, 11];
+                        dataPart = dataFeeder_1_1.value;
+                        if (this.uploadedParts.length > this.MAX_PARTS) {
+                            throw new Error("Exceeded " + this.MAX_PARTS + " as part of the upload to " + this.params.Key + " and " + this.params.Bucket + ".");
+                        }
+                        _b.label = 3;
+                    case 3:
+                        _b.trys.push([3, 9, , 10]);
+                        if (this.abortController.signal.aborted) {
+                            return [2];
+                        }
+                        if (!(dataPart.partNumber === 1 && dataPart.lastPart)) return [3, 5];
+                        return [4, this.__uploadUsingPut(dataPart)];
+                    case 4: return [2, _b.sent()];
+                    case 5:
+                        if (!!this.uploadId) return [3, 7];
+                        return [4, this.__createMultipartUpload()];
+                    case 6:
+                        _b.sent();
+                        if (this.abortController.signal.aborted) {
+                            return [2];
+                        }
+                        _b.label = 7;
+                    case 7: return [4, this.client.send(new UploadPartCommand(__assign(__assign({}, this.params), { UploadId: this.uploadId, Body: dataPart.data, PartNumber: dataPart.partNumber })))];
+                    case 8:
+                        partResult = _b.sent();
+                        if (this.abortController.signal.aborted) {
+                            return [2];
+                        }
+                        this.uploadedParts.push({
+                            PartNumber: dataPart.partNumber,
+                            ETag: partResult.ETag,
+                        });
+                        this.bytesUploadedSoFar += byteLength(dataPart.data);
+                        this.__notifyProgress({
+                            loaded: this.bytesUploadedSoFar,
+                            total: this.totalBytes,
+                            part: dataPart.partNumber,
+                            Key: this.params.Key,
+                            Bucket: this.params.Bucket,
+                        });
+                        return [3, 10];
+                    case 9:
+                        e_2 = _b.sent();
+                        if (!this.uploadId) {
+                            throw e_2;
+                        }
+                        if (this.leavePartsOnError) {
+                            throw e_2;
+                        }
+                        return [3, 10];
+                    case 10: return [3, 1];
+                    case 11: return [3, 18];
+                    case 12:
+                        e_1_1 = _b.sent();
+                        e_1 = { error: e_1_1 };
+                        return [3, 18];
+                    case 13:
+                        _b.trys.push([13, , 16, 17]);
+                        if (!(dataFeeder_1_1 && !dataFeeder_1_1.done && (_a = dataFeeder_1.return))) return [3, 15];
+                        return [4, _a.call(dataFeeder_1)];
+                    case 14:
+                        _b.sent();
+                        _b.label = 15;
+                    case 15: return [3, 17];
+                    case 16:
+                        if (e_1) throw e_1.error;
+                        return [7];
+                    case 17: return [7];
+                    case 18: return [2];
+                }
+            });
+        });
+    };
+    Upload.prototype.__doMultipartUpload = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var dataFeeder, index, currentUpload, result, uploadCompleteParams;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        dataFeeder = getChunk(this.params.Body, this.partSize);
+                        for (index = 0; index < this.queueSize; index++) {
+                            currentUpload = this.__doConcurrentUpload(dataFeeder);
+                            this.concurrentUploaders.push(currentUpload);
+                        }
+                        return [4, Promise.all(this.concurrentUploaders)];
+                    case 1:
+                        _a.sent();
+                        if (this.abortController.signal.aborted) {
+                            throw Object.assign(new Error("Upload aborted."), { name: "AbortError" });
+                        }
+                        if (!this.isMultiPart) return [3, 3];
+                        this.uploadedParts.sort(function (a, b) { return a.PartNumber - b.PartNumber; });
+                        uploadCompleteParams = __assign(__assign({}, this.params), { Body: undefined, UploadId: this.uploadId, MultipartUpload: {
+                                Parts: this.uploadedParts,
+                            } });
+                        return [4, this.client.send(new CompleteMultipartUploadCommand(uploadCompleteParams))];
+                    case 2:
+                        result = _a.sent();
+                        return [3, 4];
+                    case 3:
+                        result = this.putResponse;
+                        _a.label = 4;
+                    case 4:
+                        if (!this.tags.length) return [3, 6];
+                        return [4, this.client.send(new PutObjectTaggingCommand(__assign(__assign({}, this.params), { Tagging: {
+                                    TagSet: this.tags,
+                                } })))];
+                    case 5:
+                        _a.sent();
+                        _a.label = 6;
+                    case 6: return [2, result];
+                }
+            });
+        });
+    };
+    Upload.prototype.__notifyProgress = function (progress) {
+        if (this.uploadEvent) {
+            this.emit(this.uploadEvent, progress);
+        }
+    };
+    Upload.prototype.__abortTimeout = function (abortSignal) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2, new Promise(function (resolve, reject) {
+                        abortSignal.onabort = function () {
+                            var abortError = new Error("Upload aborted.");
+                            abortError.name = "AbortError";
+                            reject(abortError);
+                        };
+                    })];
+            });
+        });
+    };
+    Upload.prototype.__validateInput = function () {
+        if (!this.params) {
+            throw new Error("InputError: Upload requires params to be passed to upload.");
+        }
+        if (!this.client) {
+            throw new Error("InputError: Upload requires a AWS client to do uploads with.");
+        }
+        if (this.partSize < MIN_PART_SIZE) {
+            throw new Error("EntityTooSmall: Your proposed upload partsize [" + this.partSize + "] is smaller than the minimum allowed size [" + MIN_PART_SIZE + "] (5MB)");
+        }
+        if (this.queueSize < 1) {
+            throw new Error("Queue size: Must have at least one uploading queue.");
+        }
+    };
+    return Upload;
+}(EventEmitter));
+export { Upload };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"Upload.js","sourceRoot":"","sources":["../src/Upload.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  CompletedPart,\n  CompleteMultipartUploadCommand,\n  CreateMultipartUploadCommand,\n  CreateMultipartUploadCommandOutput,\n  PutObjectCommand,\n  PutObjectCommandInput,\n  PutObjectCommandOutput,\n  PutObjectTaggingCommand,\n  ServiceOutputTypes,\n  Tag,\n  UploadPartCommand,\n} from \"@aws-sdk/client-s3\";\nimport { EventEmitter } from \"events\";\nimport { BodyDataTypes, Options, Progress, ServiceClients } from \"./types\";\nimport { getChunk } from \"./chunker\";\nimport { byteLength } from \"./bytelength\";\nimport { AbortController, AbortSignal } from \"@aws-sdk/abort-controller\";\n\nexport interface RawDataPart {\n  partNumber: number;\n  data: BodyDataTypes;\n  lastPart?: boolean;\n}\n\nconst MIN_PART_SIZE = 1024 * 1024 * 5;\n\nexport class Upload extends EventEmitter {\n  /**\n   * S3 multipart upload does not allow more than 10000 parts.\n   */\n  private MAX_PARTS = 10000;\n\n  // Defaults.\n  private queueSize = 4;\n  private partSize = MIN_PART_SIZE;\n  private leavePartsOnError = false;\n  private tags: Tag[] = [];\n\n  private client: ServiceClients;\n  private params: PutObjectCommandInput;\n\n  // used for reporting progress.\n  private totalBytes?: number;\n  private bytesUploadedSoFar: number;\n\n  // used in the upload.\n  private abortController: AbortController;\n  private concurrentUploaders: Promise<void>[] = [];\n  private createMultiPartPromise?: Promise<CreateMultipartUploadCommandOutput>;\n\n  private uploadedParts: CompletedPart[] = [];\n  private uploadId?: string;\n  uploadEvent?: string;\n\n  private isMultiPart: boolean = true;\n  private putResponse?: PutObjectCommandOutput;\n\n  constructor(options: Options) {\n    super();\n\n    // set defaults from options.\n    this.queueSize = options.queueSize || this.queueSize;\n    this.partSize = options.partSize || this.partSize;\n    this.leavePartsOnError = options.leavePartsOnError || this.leavePartsOnError;\n    this.tags = options.tags || this.tags;\n\n    this.client = options.client;\n    this.params = options.params;\n\n    this.__validateInput();\n\n    // set progress defaults\n    this.totalBytes = byteLength(this.params.Body);\n    this.bytesUploadedSoFar = 0;\n    this.abortController = new AbortController();\n  }\n\n  async abort(): Promise<void> {\n    /**\n     * Abort stops all new uploads and immediately exists the top level promise on this.done()\n     * Concurrent threads in flight clean up eventually.\n     */\n    this.abortController.abort();\n  }\n\n  async done(): Promise<ServiceOutputTypes> {\n    return await Promise.race([this.__doMultipartUpload(), this.__abortTimeout(this.abortController.signal)]);\n  }\n\n  on(event: \"httpUploadProgress\", listener: (progress: Progress) => void): any {\n    this.uploadEvent = event;\n    super.on(event, listener);\n  }\n\n  async __uploadUsingPut(dataPart: RawDataPart) {\n    this.isMultiPart = false;\n    const params = { ...this.params, Body: dataPart.data };\n    const putResult = await this.client.send(new PutObjectCommand(params));\n    this.putResponse = putResult;\n    const totalSize = byteLength(dataPart.data);\n    this.__notifyProgress({\n      loaded: totalSize,\n      total: totalSize,\n      part: 1,\n      Key: this.params.Key,\n      Bucket: this.params.Bucket,\n    });\n  }\n\n  async __createMultipartUpload() {\n    if (!this.createMultiPartPromise) {\n      const createCommandParams = { ...this.params, Body: undefined };\n      this.createMultiPartPromise = this.client.send(new CreateMultipartUploadCommand(createCommandParams));\n    }\n    const createMultipartUploadResult = await this.createMultiPartPromise;\n    this.uploadId = createMultipartUploadResult.UploadId;\n  }\n\n  async __doConcurrentUpload(dataFeeder: AsyncGenerator<RawDataPart, void, undefined>): Promise<void> {\n    for await (const dataPart of dataFeeder) {\n      if (this.uploadedParts.length > this.MAX_PARTS) {\n        throw new Error(\n          `Exceeded ${this.MAX_PARTS} as part of the upload to ${this.params.Key} and ${this.params.Bucket}.`\n        );\n      }\n\n      try {\n        if (this.abortController.signal.aborted) {\n          return;\n        }\n\n        // Use put instead of multi-part for one chunk uploads.\n        if (dataPart.partNumber === 1 && dataPart.lastPart) {\n          return await this.__uploadUsingPut(dataPart);\n        }\n\n        if (!this.uploadId) {\n          await this.__createMultipartUpload();\n          if (this.abortController.signal.aborted) {\n            return;\n          }\n        }\n\n        const partResult = await this.client.send(\n          new UploadPartCommand({\n            ...this.params,\n            UploadId: this.uploadId,\n            Body: dataPart.data,\n            PartNumber: dataPart.partNumber,\n          })\n        );\n\n        if (this.abortController.signal.aborted) {\n          return;\n        }\n\n        this.uploadedParts.push({\n          PartNumber: dataPart.partNumber,\n          ETag: partResult.ETag,\n        });\n\n        this.bytesUploadedSoFar += byteLength(dataPart.data);\n        this.__notifyProgress({\n          loaded: this.bytesUploadedSoFar,\n          total: this.totalBytes,\n          part: dataPart.partNumber,\n          Key: this.params.Key,\n          Bucket: this.params.Bucket,\n        });\n      } catch (e) {\n        // Failed to create multi-part or put\n        if (!this.uploadId) {\n          throw e;\n        }\n        // on leavePartsOnError throw an error so users can deal with it themselves,\n        // otherwise swallow the error.\n        if (this.leavePartsOnError) {\n          throw e;\n        }\n      }\n    }\n  }\n\n  async __doMultipartUpload(): Promise<ServiceOutputTypes> {\n    // Set up data input chunks.\n    const dataFeeder = getChunk(this.params.Body, this.partSize);\n\n    // Create and start concurrent uploads.\n    for (let index = 0; index < this.queueSize; index++) {\n      const currentUpload = this.__doConcurrentUpload(dataFeeder);\n      this.concurrentUploaders.push(currentUpload);\n    }\n\n    // Create and start concurrent uploads.\n    await Promise.all(this.concurrentUploaders);\n    if (this.abortController.signal.aborted) {\n      throw Object.assign(new Error(\"Upload aborted.\"), { name: \"AbortError\" });\n    }\n\n    let result;\n    if (this.isMultiPart) {\n      this.uploadedParts.sort((a, b) => a.PartNumber! - b.PartNumber!);\n\n      const uploadCompleteParams = {\n        ...this.params,\n        Body: undefined,\n        UploadId: this.uploadId,\n        MultipartUpload: {\n          Parts: this.uploadedParts,\n        },\n      };\n      result = await this.client.send(new CompleteMultipartUploadCommand(uploadCompleteParams));\n    } else {\n      result = this.putResponse!;\n    }\n\n    // Add tags to the object after it's completed the upload.\n    if (this.tags.length) {\n      await this.client.send(\n        new PutObjectTaggingCommand({\n          ...this.params,\n          Tagging: {\n            TagSet: this.tags,\n          },\n        })\n      );\n    }\n\n    return result;\n  }\n\n  __notifyProgress(progress: Progress) {\n    if (this.uploadEvent) {\n      this.emit(this.uploadEvent, progress);\n    }\n  }\n\n  async __abortTimeout(abortSignal: AbortSignal): Promise<ServiceOutputTypes> {\n    return new Promise((resolve, reject) => {\n      abortSignal.onabort = () => {\n        const abortError = new Error(\"Upload aborted.\");\n        abortError.name = \"AbortError\";\n        reject(abortError);\n      };\n    });\n  }\n\n  __validateInput() {\n    if (!this.params) {\n      throw new Error(`InputError: Upload requires params to be passed to upload.`);\n    }\n\n    if (!this.client) {\n      throw new Error(`InputError: Upload requires a AWS client to do uploads with.`);\n    }\n\n    if (this.partSize < MIN_PART_SIZE) {\n      throw new Error(\n        `EntityTooSmall: Your proposed upload partsize [${this.partSize}] is smaller than the minimum allowed size [${MIN_PART_SIZE}] (5MB)`\n      );\n    }\n\n    if (this.queueSize < 1) {\n      throw new Error(`Queue size: Must have at least one uploading queue.`);\n    }\n  }\n}\n"]}

package/dist-es/bytelength.js

@@ -0,0 +1,26 @@
+import { ClientDefaultValues } from "./runtimeConfig";
+export var byteLength = function (input) {
+    if (input === null || input === undefined)
+        return 0;
+    if (typeof input === "string")
+        input = Buffer.from(input);
+    if (typeof input.byteLength === "number") {
+        return input.byteLength;
+    }
+    else if (typeof input.length === "number") {
+        return input.length;
+    }
+    else if (typeof input.size === "number") {
+        return input.size;
+    }
+    else if (typeof input.path === "string") {
+        try {
+            return ClientDefaultValues.lstatSync(input.path).size;
+        }
+        catch (error) {
+            return undefined;
+        }
+    }
+    return undefined;
+};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYnl0ZWxlbmd0aC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uL3NyYy9ieXRlbGVuZ3RoLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxtQkFBbUIsRUFBRSxNQUFNLGlCQUFpQixDQUFDO0FBRXRELE1BQU0sQ0FBQyxJQUFNLFVBQVUsR0FBRyxVQUFDLEtBQVU7SUFDbkMsSUFBSSxLQUFLLEtBQUssSUFBSSxJQUFJLEtBQUssS0FBSyxTQUFTO1FBQUUsT0FBTyxDQUFDLENBQUM7SUFDcEQsSUFBSSxPQUFPLEtBQUssS0FBSyxRQUFRO1FBQUUsS0FBSyxHQUFHLE1BQU0sQ0FBQyxJQUFJLENBQUMsS0FBSyxDQUFDLENBQUM7SUFDMUQsSUFBSSxPQUFPLEtBQUssQ0FBQyxVQUFVLEtBQUssUUFBUSxFQUFFO1FBQ3hDLE9BQU8sS0FBSyxDQUFDLFVBQVUsQ0FBQztLQUN6QjtTQUFNLElBQUksT0FBTyxLQUFLLENBQUMsTUFBTSxLQUFLLFFBQVEsRUFBRTtRQUMzQyxPQUFPLEtBQUssQ0FBQyxNQUFNLENBQUM7S0FDckI7U0FBTSxJQUFJLE9BQU8sS0FBSyxDQUFDLElBQUksS0FBSyxRQUFRLEVBQUU7UUFDekMsT0FBTyxLQUFLLENBQUMsSUFBSSxDQUFDO0tBQ25CO1NBQU0sSUFBSSxPQUFPLEtBQUssQ0FBQyxJQUFJLEtBQUssUUFBUSxFQUFFO1FBQ3pDLElBQUk7WUFDRixPQUFPLG1CQUFtQixDQUFDLFNBQVMsQ0FBQyxLQUFLLENBQUMsSUFBSSxDQUFDLENBQUMsSUFBSSxDQUFDO1NBQ3ZEO1FBQUMsT0FBTyxLQUFLLEVBQUU7WUFDZCxPQUFPLFNBQVMsQ0FBQztTQUNsQjtLQUNGO0lBQ0QsT0FBTyxTQUFTLENBQUM7QUFDbkIsQ0FBQyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgQ2xpZW50RGVmYXVsdFZhbHVlcyB9IGZyb20gXCIuL3J1bnRpbWVDb25maWdcIjtcblxuZXhwb3J0IGNvbnN0IGJ5dGVMZW5ndGggPSAoaW5wdXQ6IGFueSkgPT4ge1xuICBpZiAoaW5wdXQgPT09IG51bGwgfHwgaW5wdXQgPT09IHVuZGVmaW5lZCkgcmV0dXJuIDA7XG4gIGlmICh0eXBlb2YgaW5wdXQgPT09IFwic3RyaW5nXCIpIGlucHV0ID0gQnVmZmVyLmZyb20oaW5wdXQpO1xuICBpZiAodHlwZW9mIGlucHV0LmJ5dGVMZW5ndGggPT09IFwibnVtYmVyXCIpIHtcbiAgICByZXR1cm4gaW5wdXQuYnl0ZUxlbmd0aDtcbiAgfSBlbHNlIGlmICh0eXBlb2YgaW5wdXQubGVuZ3RoID09PSBcIm51bWJlclwiKSB7XG4gICAgcmV0dXJuIGlucHV0Lmxlbmd0aDtcbiAgfSBlbHNlIGlmICh0eXBlb2YgaW5wdXQuc2l6ZSA9PT0gXCJudW1iZXJcIikge1xuICAgIHJldHVybiBpbnB1dC5zaXplO1xuICB9IGVsc2UgaWYgKHR5cGVvZiBpbnB1dC5wYXRoID09PSBcInN0cmluZ1wiKSB7XG4gICAgdHJ5IHtcbiAgICAgIHJldHVybiBDbGllbnREZWZhdWx0VmFsdWVzLmxzdGF0U3luYyhpbnB1dC5wYXRoKS5zaXplO1xuICAgIH0gY2F0Y2ggKGVycm9yKSB7XG4gICAgICByZXR1cm4gdW5kZWZpbmVkO1xuICAgIH1cbiAgfVxuICByZXR1cm4gdW5kZWZpbmVkO1xufTtcbiJdfQ==

package/dist-es/chunker.js

@@ -0,0 +1,27 @@
+import { Readable } from "stream";
+import { Buffer } from "buffer";
+import { getChunkBuffer } from "./chunks/getChunkBuffer";
+import { getChunkStream } from "./chunks/getChunkStream";
+import { getDataReadableStream } from "./chunks/getDataReadableStream";
+import { getDataReadable } from "./chunks/getDataReadable";
+export var getChunk = function (data, partSize) {
+    if (data instanceof Buffer) {
+        return getChunkBuffer(data, partSize);
+    }
+    else if (data instanceof Readable) {
+        return getChunkStream(data, partSize, getDataReadable);
+    }
+    else if (data instanceof String || typeof data === "string" || data instanceof Uint8Array) {
+        return getChunkBuffer(Buffer.from(data), partSize);
+    }
+    if (typeof data.stream === "function") {
+        return getChunkStream(data.stream(), partSize, getDataReadableStream);
+    }
+    else if (data instanceof ReadableStream) {
+        return getChunkStream(data, partSize, getDataReadableStream);
+    }
+    else {
+        throw new Error("Body Data is unsupported format, expected data to be one of: string | Uint8Array | Buffer | Readable | ReadableStream | Blob;.");
+    }
+};
+//# sourceMappingURL=data:application/json;base64,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

package/dist-es/chunks/getChunkBuffer.js

@@ -0,0 +1,38 @@
+import { __asyncGenerator, __await, __generator } from "tslib";
+export function getChunkBuffer(data, partSize) {
+    return __asyncGenerator(this, arguments, function getChunkBuffer_1() {
+        var partNumber, startByte, endByte;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    partNumber = 1;
+                    startByte = 0;
+                    endByte = partSize;
+                    _a.label = 1;
+                case 1:
+                    if (!(endByte < data.byteLength)) return [3, 4];
+                    return [4, __await({
+                            partNumber: partNumber,
+                            data: data.slice(startByte, endByte),
+                        })];
+                case 2: return [4, _a.sent()];
+                case 3:
+                    _a.sent();
+                    partNumber += 1;
+                    startByte = endByte;
+                    endByte = startByte + partSize;
+                    return [3, 1];
+                case 4: return [4, __await({
+                        partNumber: partNumber,
+                        data: data.slice(startByte),
+                        lastPart: true,
+                    })];
+                case 5: return [4, _a.sent()];
+                case 6:
+                    _a.sent();
+                    return [2];
+            }
+        });
+    });
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZ2V0Q2h1bmtCdWZmZXIuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvY2h1bmtzL2dldENodW5rQnVmZmVyLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7QUFFQSxNQUFNLFVBQWlCLGNBQWMsQ0FBQyxJQUFZLEVBQUUsUUFBZ0I7Ozs7OztvQkFDOUQsVUFBVSxHQUFHLENBQUMsQ0FBQztvQkFDZixTQUFTLEdBQUcsQ0FBQyxDQUFDO29CQUNkLE9BQU8sR0FBRyxRQUFRLENBQUM7Ozt5QkFFaEIsQ0FBQSxPQUFPLEdBQUcsSUFBSSxDQUFDLFVBQVUsQ0FBQTt1Q0FDeEI7NEJBQ0osVUFBVSxZQUFBOzRCQUNWLElBQUksRUFBRSxJQUFJLENBQUMsS0FBSyxDQUFDLFNBQVMsRUFBRSxPQUFPLENBQUM7eUJBQ3JDO3dCQUhELHNCQUdDOztvQkFIRCxTQUdDLENBQUM7b0JBQ0YsVUFBVSxJQUFJLENBQUMsQ0FBQztvQkFDaEIsU0FBUyxHQUFHLE9BQU8sQ0FBQztvQkFDcEIsT0FBTyxHQUFHLFNBQVMsR0FBRyxRQUFRLENBQUM7OzJDQUczQjt3QkFDSixVQUFVLFlBQUE7d0JBQ1YsSUFBSSxFQUFFLElBQUksQ0FBQyxLQUFLLENBQUMsU0FBUyxDQUFDO3dCQUMzQixRQUFRLEVBQUUsSUFBSTtxQkFDZjt3QkFKRCxzQkFJQzs7b0JBSkQsU0FJQyxDQUFDOzs7OztDQUNIIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgUmF3RGF0YVBhcnQgfSBmcm9tIFwiLi4vVXBsb2FkXCI7XG5cbmV4cG9ydCBhc3luYyBmdW5jdGlvbiogZ2V0Q2h1bmtCdWZmZXIoZGF0YTogQnVmZmVyLCBwYXJ0U2l6ZTogbnVtYmVyKTogQXN5bmNHZW5lcmF0b3I8UmF3RGF0YVBhcnQsIHZvaWQsIHVuZGVmaW5lZD4ge1xuICBsZXQgcGFydE51bWJlciA9IDE7XG4gIGxldCBzdGFydEJ5dGUgPSAwO1xuICBsZXQgZW5kQnl0ZSA9IHBhcnRTaXplO1xuXG4gIHdoaWxlIChlbmRCeXRlIDwgZGF0YS5ieXRlTGVuZ3RoKSB7XG4gICAgeWllbGQge1xuICAgICAgcGFydE51bWJlcixcbiAgICAgIGRhdGE6IGRhdGEuc2xpY2Uoc3RhcnRCeXRlLCBlbmRCeXRlKSxcbiAgICB9O1xuICAgIHBhcnROdW1iZXIgKz0gMTtcbiAgICBzdGFydEJ5dGUgPSBlbmRCeXRlO1xuICAgIGVuZEJ5dGUgPSBzdGFydEJ5dGUgKyBwYXJ0U2l6ZTtcbiAgfVxuXG4gIHlpZWxkIHtcbiAgICBwYXJ0TnVtYmVyLFxuICAgIGRhdGE6IGRhdGEuc2xpY2Uoc3RhcnRCeXRlKSxcbiAgICBsYXN0UGFydDogdHJ1ZSxcbiAgfTtcbn1cbiJdfQ==

package/dist-es/chunks/getChunkStream.js

@@ -0,0 +1,69 @@
+import { __asyncGenerator, __asyncValues, __await, __generator } from "tslib";
+import { Buffer } from "buffer";
+export function getChunkStream(data, partSize, getNextData) {
+    return __asyncGenerator(this, arguments, function getChunkStream_1() {
+        var partNumber, currentBuffer, _a, _b, datum, dataChunk, e_1_1;
+        var e_1, _c;
+        return __generator(this, function (_d) {
+            switch (_d.label) {
+                case 0:
+                    partNumber = 1;
+                    currentBuffer = { chunks: [], length: 0 };
+                    _d.label = 1;
+                case 1:
+                    _d.trys.push([1, 9, 10, 15]);
+                    _a = __asyncValues(getNextData(data));
+                    _d.label = 2;
+                case 2: return [4, __await(_a.next())];
+                case 3:
+                    if (!(_b = _d.sent(), !_b.done)) return [3, 8];
+                    datum = _b.value;
+                    currentBuffer.chunks.push(datum);
+                    currentBuffer.length += datum.length;
+                    _d.label = 4;
+                case 4:
+                    if (!(currentBuffer.length >= partSize)) return [3, 7];
+                    dataChunk = currentBuffer.chunks.length > 1 ? Buffer.concat(currentBuffer.chunks) : currentBuffer.chunks[0];
+                    return [4, __await({
+                            partNumber: partNumber,
+                            data: dataChunk.slice(0, partSize),
+                        })];
+                case 5: return [4, _d.sent()];
+                case 6:
+                    _d.sent();
+                    currentBuffer.chunks = [dataChunk.slice(partSize)];
+                    currentBuffer.length = currentBuffer.chunks[0].length;
+                    partNumber += 1;
+                    return [3, 4];
+                case 7: return [3, 2];
+                case 8: return [3, 15];
+                case 9:
+                    e_1_1 = _d.sent();
+                    e_1 = { error: e_1_1 };
+                    return [3, 15];
+                case 10:
+                    _d.trys.push([10, , 13, 14]);
+                    if (!(_b && !_b.done && (_c = _a.return))) return [3, 12];
+                    return [4, __await(_c.call(_a))];
+                case 11:
+                    _d.sent();
+                    _d.label = 12;
+                case 12: return [3, 14];
+                case 13:
+                    if (e_1) throw e_1.error;
+                    return [7];
+                case 14: return [7];
+                case 15: return [4, __await({
+                        partNumber: partNumber,
+                        data: Buffer.concat(currentBuffer.chunks),
+                        lastPart: true,
+                    })];
+                case 16: return [4, _d.sent()];
+                case 17:
+                    _d.sent();
+                    return [2];
+            }
+        });
+    });
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist-es/chunks/getDataReadable.js

@@ -0,0 +1,45 @@
+import { __asyncGenerator, __asyncValues, __await, __generator } from "tslib";
+import { Buffer } from "buffer";
+export function getDataReadable(data) {
+    return __asyncGenerator(this, arguments, function getDataReadable_1() {
+        var data_1, data_1_1, chunk, e_1_1;
+        var e_1, _a;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    _b.trys.push([0, 7, 8, 13]);
+                    data_1 = __asyncValues(data);
+                    _b.label = 1;
+                case 1: return [4, __await(data_1.next())];
+                case 2:
+                    if (!(data_1_1 = _b.sent(), !data_1_1.done)) return [3, 6];
+                    chunk = data_1_1.value;
+                    return [4, __await(Buffer.from(chunk))];
+                case 3: return [4, _b.sent()];
+                case 4:
+                    _b.sent();
+                    _b.label = 5;
+                case 5: return [3, 1];
+                case 6: return [3, 13];
+                case 7:
+                    e_1_1 = _b.sent();
+                    e_1 = { error: e_1_1 };
+                    return [3, 13];
+                case 8:
+                    _b.trys.push([8, , 11, 12]);
+                    if (!(data_1_1 && !data_1_1.done && (_a = data_1.return))) return [3, 10];
+                    return [4, __await(_a.call(data_1))];
+                case 9:
+                    _b.sent();
+                    _b.label = 10;
+                case 10: return [3, 12];
+                case 11:
+                    if (e_1) throw e_1.error;
+                    return [7];
+                case 12: return [7];
+                case 13: return [2];
+            }
+        });
+    });
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZ2V0RGF0YVJlYWRhYmxlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL2NodW5rcy9nZXREYXRhUmVhZGFibGUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IjtBQUNBLE9BQU8sRUFBRSxNQUFNLEVBQUUsTUFBTSxRQUFRLENBQUM7QUFFaEMsTUFBTSxVQUFpQixlQUFlLENBQUMsSUFBYzs7Ozs7Ozs7b0JBQ3pCLFNBQUEsY0FBQSxJQUFJLENBQUE7Ozs7O29CQUFiLEtBQUssaUJBQUEsQ0FBQTt1Q0FDZCxNQUFNLENBQUMsSUFBSSxDQUFDLEtBQUssQ0FBQzt3QkFBeEIsc0JBQXdCOztvQkFBeEIsU0FBd0IsQ0FBQzs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7O0NBRTVCIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgUmVhZGFibGUgfSBmcm9tIFwic3RyZWFtXCI7XG5pbXBvcnQgeyBCdWZmZXIgfSBmcm9tIFwiYnVmZmVyXCI7XG5cbmV4cG9ydCBhc3luYyBmdW5jdGlvbiogZ2V0RGF0YVJlYWRhYmxlKGRhdGE6IFJlYWRhYmxlKTogQXN5bmNHZW5lcmF0b3I8QnVmZmVyPiB7XG4gIGZvciBhd2FpdCAoY29uc3QgY2h1bmsgb2YgZGF0YSkge1xuICAgIHlpZWxkIEJ1ZmZlci5mcm9tKGNodW5rKTtcbiAgfVxufVxuIl19

package/dist-es/chunks/getDataReadableStream.js

@@ -0,0 +1,39 @@
+import { __asyncGenerator, __await, __generator } from "tslib";
+import { Buffer } from "buffer";
+export function getDataReadableStream(data) {
+    return __asyncGenerator(this, arguments, function getDataReadableStream_1() {
+        var reader, _a, done, value, e_1;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    reader = data.getReader();
+                    _b.label = 1;
+                case 1:
+                    _b.trys.push([1, 9, 10, 11]);
+                    _b.label = 2;
+                case 2:
+                    if (!true) return [3, 8];
+                    return [4, __await(reader.read())];
+                case 3:
+                    _a = _b.sent(), done = _a.done, value = _a.value;
+                    if (!done) return [3, 5];
+                    return [4, __await(void 0)];
+                case 4: return [2, _b.sent()];
+                case 5: return [4, __await(Buffer.from(value))];
+                case 6: return [4, _b.sent()];
+                case 7:
+                    _b.sent();
+                    return [3, 2];
+                case 8: return [3, 11];
+                case 9:
+                    e_1 = _b.sent();
+                    throw e_1;
+                case 10:
+                    reader.releaseLock();
+                    return [7];
+                case 11: return [2];
+            }
+        });
+    });
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZ2V0RGF0YVJlYWRhYmxlU3RyZWFtLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL2NodW5rcy9nZXREYXRhUmVhZGFibGVTdHJlYW0udHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IjtBQUFBLE9BQU8sRUFBRSxNQUFNLEVBQUUsTUFBTSxRQUFRLENBQUM7QUFFaEMsTUFBTSxVQUFpQixxQkFBcUIsQ0FBQyxJQUFvQjs7Ozs7O29CQUV6RCxNQUFNLEdBQUcsSUFBSSxDQUFDLFNBQVMsRUFBRSxDQUFDOzs7Ozs7eUJBR3ZCLElBQUk7b0JBRWUsbUJBQU0sTUFBTSxDQUFDLElBQUksRUFBRSxHQUFBOztvQkFBckMsS0FBa0IsU0FBbUIsRUFBbkMsSUFBSSxVQUFBLEVBQUUsS0FBSyxXQUFBO3lCQUVmLElBQUksRUFBSixjQUFJOzt3QkFBRSxzQkFBTzsyQ0FFWCxNQUFNLENBQUMsSUFBSSxDQUFDLEtBQUssQ0FBQzt3QkFBeEIsc0JBQXdCOztvQkFBeEIsU0FBd0IsQ0FBQzs7Ozs7b0JBRzNCLE1BQU0sR0FBQyxDQUFDOztvQkFHUixNQUFNLENBQUMsV0FBVyxFQUFFLENBQUM7Ozs7OztDQUV4QiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IEJ1ZmZlciB9IGZyb20gXCJidWZmZXJcIjtcblxuZXhwb3J0IGFzeW5jIGZ1bmN0aW9uKiBnZXREYXRhUmVhZGFibGVTdHJlYW0oZGF0YTogUmVhZGFibGVTdHJlYW0pOiBBc3luY0dlbmVyYXRvcjxCdWZmZXI+IHtcbiAgLy8gR2V0IGEgbG9jayBvbiB0aGUgc3RyZWFtLlxuICBjb25zdCByZWFkZXIgPSBkYXRhLmdldFJlYWRlcigpO1xuXG4gIHRyeSB7XG4gICAgd2hpbGUgKHRydWUpIHtcbiAgICAgIC8vIFJlYWQgZnJvbSB0aGUgc3RyZWFtLlxuICAgICAgY29uc3QgeyBkb25lLCB2YWx1ZSB9ID0gYXdhaXQgcmVhZGVyLnJlYWQoKTtcbiAgICAgIC8vIEV4aXQgaWYgd2UncmUgZG9uZS5cbiAgICAgIGlmIChkb25lKSByZXR1cm47XG4gICAgICAvLyBFbHNlIHlpZWxkIHRoZSBjaHVuay5cbiAgICAgIHlpZWxkIEJ1ZmZlci5mcm9tKHZhbHVlKTtcbiAgICB9XG4gIH0gY2F0Y2ggKGUpIHtcbiAgICB0aHJvdyBlO1xuICB9IGZpbmFsbHkge1xuICAgIC8vIHJlbGVhc2UgdGhlIGxvY2sgZm9yIHJlYWRpbmcgZnJvbSB0aGlzIHN0cmVhbS5cbiAgICByZWFkZXIucmVsZWFzZUxvY2soKTtcbiAgfVxufVxuIl19

package/dist-es/index.js

@@ -0,0 +1,3 @@
+export * from "./Upload";
+export * from "./types";
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9zcmMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyxVQUFVLENBQUM7QUFDekIsY0FBYyxTQUFTLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tIFwiLi9VcGxvYWRcIjtcbmV4cG9ydCAqIGZyb20gXCIuL3R5cGVzXCI7XG4iXX0=

package/dist-es/runtimeConfig.browser.js

@@ -0,0 +1,4 @@
+import { __assign } from "tslib";
+import { ClientSharedValues } from "./runtimeConfig.shared";
+export var ClientDefaultValues = __assign(__assign({}, ClientSharedValues), { runtime: "browser" });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicnVudGltZUNvbmZpZy5icm93c2VyLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vc3JjL3J1bnRpbWVDb25maWcuYnJvd3Nlci50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiO0FBQUEsT0FBTyxFQUFFLGtCQUFrQixFQUFFLE1BQU0sd0JBQXdCLENBQUM7QUFLNUQsTUFBTSxDQUFDLElBQU0sbUJBQW1CLHlCQUMzQixrQkFBa0IsS0FDckIsT0FBTyxFQUFFLFNBQVMsR0FDbkIsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IENsaWVudFNoYXJlZFZhbHVlcyB9IGZyb20gXCIuL3J1bnRpbWVDb25maWcuc2hhcmVkXCI7XG5cbi8qKlxuICogQGludGVybmFsXG4gKi9cbmV4cG9ydCBjb25zdCBDbGllbnREZWZhdWx0VmFsdWVzID0ge1xuICAuLi5DbGllbnRTaGFyZWRWYWx1ZXMsXG4gIHJ1bnRpbWU6IFwiYnJvd3NlclwiLFxufTtcbiJdfQ==

package/dist-es/runtimeConfig.js

@@ -0,0 +1,5 @@
+import { __assign } from "tslib";
+import { ClientSharedValues } from "./runtimeConfig.shared";
+import { lstatSync } from "fs";
+export var ClientDefaultValues = __assign(__assign({}, ClientSharedValues), { runtime: "node", lstatSync: lstatSync });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicnVudGltZUNvbmZpZy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uL3NyYy9ydW50aW1lQ29uZmlnLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7QUFBQSxPQUFPLEVBQUUsa0JBQWtCLEVBQUUsTUFBTSx3QkFBd0IsQ0FBQztBQUM1RCxPQUFPLEVBQUUsU0FBUyxFQUFFLE1BQU0sSUFBSSxDQUFDO0FBSy9CLE1BQU0sQ0FBQyxJQUFNLG1CQUFtQix5QkFDM0Isa0JBQWtCLEtBQ3JCLE9BQU8sRUFBRSxNQUFNLEVBQ2YsU0FBUyxXQUFBLEdBQ1YsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IENsaWVudFNoYXJlZFZhbHVlcyB9IGZyb20gXCIuL3J1bnRpbWVDb25maWcuc2hhcmVkXCI7XG5pbXBvcnQgeyBsc3RhdFN5bmMgfSBmcm9tIFwiZnNcIjtcblxuLyoqXG4gKiBAaW50ZXJuYWxcbiAqL1xuZXhwb3J0IGNvbnN0IENsaWVudERlZmF1bHRWYWx1ZXMgPSB7XG4gIC4uLkNsaWVudFNoYXJlZFZhbHVlcyxcbiAgcnVudGltZTogXCJub2RlXCIsXG4gIGxzdGF0U3luYyxcbn07XG4iXX0=

package/dist-es/runtimeConfig.native.js

@@ -0,0 +1,4 @@
+import { __assign } from "tslib";
+import { ClientDefaultValues as BrowserDefaults } from "./runtimeConfig.browser";
+export var ClientDefaultValues = __assign(__assign({}, BrowserDefaults), { runtime: "react-native" });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicnVudGltZUNvbmZpZy5uYXRpdmUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9zcmMvcnVudGltZUNvbmZpZy5uYXRpdmUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IjtBQUFBLE9BQU8sRUFBRSxtQkFBbUIsSUFBSSxlQUFlLEVBQUUsTUFBTSx5QkFBeUIsQ0FBQztBQUtqRixNQUFNLENBQUMsSUFBTSxtQkFBbUIseUJBQzNCLGVBQWUsS0FDbEIsT0FBTyxFQUFFLGNBQWMsR0FDeEIsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IENsaWVudERlZmF1bHRWYWx1ZXMgYXMgQnJvd3NlckRlZmF1bHRzIH0gZnJvbSBcIi4vcnVudGltZUNvbmZpZy5icm93c2VyXCI7XG5cbi8qKlxuICogQGludGVybmFsXG4gKi9cbmV4cG9ydCBjb25zdCBDbGllbnREZWZhdWx0VmFsdWVzID0ge1xuICAuLi5Ccm93c2VyRGVmYXVsdHMsXG4gIHJ1bnRpbWU6IFwicmVhY3QtbmF0aXZlXCIsXG59O1xuIl19

package/dist-es/runtimeConfig.shared.js

@@ -0,0 +1,4 @@
+export var ClientSharedValues = {
+    lstatSync: function () { },
+};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicnVudGltZUNvbmZpZy5zaGFyZWQuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9zcmMvcnVudGltZUNvbmZpZy5zaGFyZWQudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBR0EsTUFBTSxDQUFDLElBQU0sa0JBQWtCLEdBQUc7SUFDaEMsU0FBUyxFQUFFLGNBQU8sQ0FBQztDQUNwQixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBAaW50ZXJuYWxcbiAqL1xuZXhwb3J0IGNvbnN0IENsaWVudFNoYXJlZFZhbHVlcyA9IHtcbiAgbHN0YXRTeW5jOiAoKSA9PiB7fSxcbn07XG4iXX0=

package/dist-es/types.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,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