@design-edito/tools 0.1.72 → 0.2.0

package/chunks/chunk-XKMSDS3Z.js

@@ -1,18 +0,0 @@
-import {
-  OperationNames
-} from "./chunk-MOVLLUDL.js";
-import {
-  esm_default
-} from "./chunk-T4KFB6QN.js";
-
-// src/node/images/transform/rotate/index.ts
-var rotateSchema = esm_default.object({
-  name: esm_default.literal(OperationNames.Rotate),
-  params: esm_default.object({
-    angle: esm_default.number()
-  })
-});
-
-export {
-  rotateSchema
-};

package/chunks/chunk-XYNIGHGL.js

@@ -1,654 +0,0 @@
-import {
-  require_dist_cjs,
-  require_dist_cjs2,
-  require_dist_cjs3,
-  require_dist_cjs4
-} from "./chunk-IZP4VIFZ.js";
-import {
-  Outcome
-} from "./chunk-JMU5PDBD.js";
-import {
-  unknownToString
-} from "./chunk-FENXVJYO.js";
-import {
-  __commonJS,
-  __export,
-  __require,
-  __toESM
-} from "./chunk-KH45J4DC.js";
-
-// node_modules/@smithy/abort-controller/dist-cjs/index.js
-var require_dist_cjs5 = __commonJS({
-  "node_modules/@smithy/abort-controller/dist-cjs/index.js"(exports, module) {
-    var __defProp = Object.defineProperty;
-    var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-    var __getOwnPropNames = Object.getOwnPropertyNames;
-    var __hasOwnProp = Object.prototype.hasOwnProperty;
-    var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
-    var __export2 = (target, all) => {
-      for (var name in all)
-        __defProp(target, name, { get: all[name], enumerable: true });
-    };
-    var __copyProps = (to, from, except, desc) => {
-      if (from && typeof from === "object" || typeof from === "function") {
-        for (let key of __getOwnPropNames(from))
-          if (!__hasOwnProp.call(to, key) && key !== except)
-            __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-      }
-      return to;
-    };
-    var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-    var src_exports = {};
-    __export2(src_exports, {
-      AbortController: () => AbortController,
-      AbortHandler: () => import_types.AbortHandler,
-      AbortSignal: () => AbortSignal,
-      IAbortController: () => import_types.AbortController,
-      IAbortSignal: () => import_types.AbortSignal
-    });
-    module.exports = __toCommonJS(src_exports);
-    var import_types = require_dist_cjs();
-    var AbortSignal = class {
-      constructor() {
-        this.onabort = null;
-        this._aborted = false;
-        Object.defineProperty(this, "_aborted", {
-          value: false,
-          writable: true
-        });
-      }
-      static {
-        __name(this, "AbortSignal");
-      }
-      /**
-       * Whether the associated operation has already been cancelled.
-       */
-      get aborted() {
-        return this._aborted;
-      }
-      /**
-       * @internal
-       */
-      abort() {
-        this._aborted = true;
-        if (this.onabort) {
-          this.onabort(this);
-          this.onabort = null;
-        }
-      }
-    };
-    var AbortController = class {
-      constructor() {
-        this.signal = new AbortSignal();
-      }
-      static {
-        __name(this, "AbortController");
-      }
-      abort() {
-        this.signal.abort();
-      }
-    };
-  }
-});
-
-// node_modules/@aws-sdk/lib-storage/dist-cjs/runtimeConfig.shared.js
-var require_runtimeConfig_shared = __commonJS({
-  "node_modules/@aws-sdk/lib-storage/dist-cjs/runtimeConfig.shared.js"(exports) {
-    "use strict";
-    Object.defineProperty(exports, "__esModule", { value: true });
-    exports.ClientSharedValues = void 0;
-    exports.ClientSharedValues = {
-      lstatSync: () => {
-      }
-    };
-  }
-});
-
-// node_modules/@aws-sdk/lib-storage/dist-cjs/runtimeConfig.js
-var require_runtimeConfig = __commonJS({
-  "node_modules/@aws-sdk/lib-storage/dist-cjs/runtimeConfig.js"(exports) {
-    "use strict";
-    Object.defineProperty(exports, "__esModule", { value: true });
-    exports.ClientDefaultValues = void 0;
-    var fs_1 = __require("fs");
-    var runtimeConfig_shared_1 = require_runtimeConfig_shared();
-    exports.ClientDefaultValues = {
-      ...runtimeConfig_shared_1.ClientSharedValues,
-      runtime: "node",
-      lstatSync: fs_1.lstatSync
-    };
-  }
-});
-
-// node_modules/@aws-sdk/lib-storage/dist-cjs/index.js
-var require_dist_cjs6 = __commonJS({
-  "node_modules/@aws-sdk/lib-storage/dist-cjs/index.js"(exports, module) {
-    "use strict";
-    var __defProp = Object.defineProperty;
-    var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-    var __getOwnPropNames = Object.getOwnPropertyNames;
-    var __hasOwnProp = Object.prototype.hasOwnProperty;
-    var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
-    var __export2 = (target, all) => {
-      for (var name in all)
-        __defProp(target, name, { get: all[name], enumerable: true });
-    };
-    var __copyProps = (to, from, except, desc) => {
-      if (from && typeof from === "object" || typeof from === "function") {
-        for (let key of __getOwnPropNames(from))
-          if (!__hasOwnProp.call(to, key) && key !== except)
-            __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-      }
-      return to;
-    };
-    var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-    var index_exports = {};
-    __export2(index_exports, {
-      Upload: () => Upload2
-    });
-    module.exports = __toCommonJS(index_exports);
-    var import_client_s32 = require_dist_cjs4();
-    var import_abort_controller = require_dist_cjs5();
-    var import_middleware_endpoint = require_dist_cjs3();
-    var import_smithy_client = require_dist_cjs2();
-    var import_events = __require("events");
-    var import_buffer = __require("buffer");
-    var import_runtimeConfig = require_runtimeConfig();
-    var byteLength = /* @__PURE__ */ __name((input) => {
-      if (input === null || input === void 0) return 0;
-      if (typeof input === "string") {
-        return import_buffer.Buffer.byteLength(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 import_runtimeConfig.ClientDefaultValues.lstatSync(input.path).size;
-        } catch (error) {
-          return void 0;
-        }
-      }
-      return void 0;
-    }, "byteLength");
-    var import_stream = __require("stream");
-    async function* getChunkStream(data, partSize, getNextData) {
-      let partNumber = 1;
-      const currentBuffer = { chunks: [], length: 0 };
-      for await (const datum of getNextData(data)) {
-        currentBuffer.chunks.push(datum);
-        currentBuffer.length += datum.byteLength;
-        while (currentBuffer.length > partSize) {
-          const dataChunk = currentBuffer.chunks.length > 1 ? import_buffer.Buffer.concat(currentBuffer.chunks) : currentBuffer.chunks[0];
-          yield {
-            partNumber,
-            data: dataChunk.subarray(0, partSize)
-          };
-          currentBuffer.chunks = [dataChunk.subarray(partSize)];
-          currentBuffer.length = currentBuffer.chunks[0].byteLength;
-          partNumber += 1;
-        }
-      }
-      yield {
-        partNumber,
-        data: currentBuffer.chunks.length !== 1 ? import_buffer.Buffer.concat(currentBuffer.chunks) : currentBuffer.chunks[0],
-        lastPart: true
-      };
-    }
-    __name(getChunkStream, "getChunkStream");
-    async function* getChunkUint8Array(data, partSize) {
-      let partNumber = 1;
-      let startByte = 0;
-      let endByte = partSize;
-      while (endByte < data.byteLength) {
-        yield {
-          partNumber,
-          data: data.subarray(startByte, endByte)
-        };
-        partNumber += 1;
-        startByte = endByte;
-        endByte = startByte + partSize;
-      }
-      yield {
-        partNumber,
-        data: data.subarray(startByte),
-        lastPart: true
-      };
-    }
-    __name(getChunkUint8Array, "getChunkUint8Array");
-    async function* getDataReadable(data) {
-      for await (const chunk of data) {
-        if (import_buffer.Buffer.isBuffer(chunk) || chunk instanceof Uint8Array) {
-          yield chunk;
-        } else {
-          yield import_buffer.Buffer.from(chunk);
-        }
-      }
-    }
-    __name(getDataReadable, "getDataReadable");
-    async function* getDataReadableStream(data) {
-      const reader = data.getReader();
-      try {
-        while (true) {
-          const { done, value } = await reader.read();
-          if (done) {
-            return;
-          }
-          if (import_buffer.Buffer.isBuffer(value) || value instanceof Uint8Array) {
-            yield value;
-          } else {
-            yield import_buffer.Buffer.from(value);
-          }
-        }
-      } catch (e) {
-        throw e;
-      } finally {
-        reader.releaseLock();
-      }
-    }
-    __name(getDataReadableStream, "getDataReadableStream");
-    var getChunk = /* @__PURE__ */ __name((data, partSize) => {
-      if (data instanceof Uint8Array) {
-        return getChunkUint8Array(data, partSize);
-      }
-      if (data instanceof import_stream.Readable) {
-        return getChunkStream(data, partSize, getDataReadable);
-      }
-      if (data instanceof String || typeof data === "string") {
-        return getChunkUint8Array(import_buffer.Buffer.from(data), partSize);
-      }
-      if (typeof data.stream === "function") {
-        return getChunkStream(data.stream(), partSize, getDataReadableStream);
-      }
-      if (data instanceof ReadableStream) {
-        return getChunkStream(data, partSize, getDataReadableStream);
-      }
-      throw new Error(
-        "Body Data is unsupported format, expected data to be one of: string | Uint8Array | Buffer | Readable | ReadableStream | Blob;."
-      );
-    }, "getChunk");
-    var Upload2 = class _Upload extends import_events.EventEmitter {
-      static {
-        __name(this, "Upload");
-      }
-      /**
-       * @internal
-       * modified in testing only.
-       */
-      static MIN_PART_SIZE = 1024 * 1024 * 5;
-      /**
-       * S3 multipart upload does not allow more than 10,000 parts.
-       */
-      MAX_PARTS = 1e4;
-      // Defaults.
-      queueSize = 4;
-      partSize = _Upload.MIN_PART_SIZE;
-      leavePartsOnError = false;
-      tags = [];
-      client;
-      params;
-      // used for reporting progress.
-      totalBytes;
-      bytesUploadedSoFar;
-      // used in the upload.
-      abortController;
-      concurrentUploaders = [];
-      createMultiPartPromise;
-      abortMultipartUploadCommand = null;
-      uploadedParts = [];
-      uploadEnqueuedPartsCount = 0;
-      /**
-       * Last UploadId if the upload was done with MultipartUpload and not PutObject.
-       */
-      uploadId;
-      uploadEvent;
-      isMultiPart = true;
-      singleUploadResult;
-      sent = false;
-      constructor(options) {
-        super();
-        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 = options.abortController ?? new import_abort_controller.AbortController();
-      }
-      async abort() {
-        this.abortController.abort();
-      }
-      async done() {
-        if (this.sent) {
-          throw new Error(
-            "@aws-sdk/lib-storage: this instance of Upload has already executed .done(). Create a new instance."
-          );
-        }
-        this.sent = true;
-        return await Promise.race([this.__doMultipartUpload(), this.__abortTimeout(this.abortController.signal)]);
-      }
-      on(event, listener) {
-        this.uploadEvent = event;
-        return super.on(event, listener);
-      }
-      async __uploadUsingPut(dataPart) {
-        this.isMultiPart = false;
-        const params = { ...this.params, Body: dataPart.data };
-        const clientConfig = this.client.config;
-        const requestHandler = clientConfig.requestHandler;
-        const eventEmitter = requestHandler instanceof import_events.EventEmitter ? requestHandler : null;
-        const uploadEventListener = /* @__PURE__ */ __name((event) => {
-          this.bytesUploadedSoFar = event.loaded;
-          this.totalBytes = event.total;
-          this.__notifyProgress({
-            loaded: this.bytesUploadedSoFar,
-            total: this.totalBytes,
-            part: dataPart.partNumber,
-            Key: this.params.Key,
-            Bucket: this.params.Bucket
-          });
-        }, "uploadEventListener");
-        if (eventEmitter !== null) {
-          eventEmitter.on("xhr.upload.progress", uploadEventListener);
-        }
-        const resolved = await Promise.all([this.client.send(new import_client_s32.PutObjectCommand(params)), clientConfig?.endpoint?.()]);
-        const putResult = resolved[0];
-        let endpoint = resolved[1];
-        if (!endpoint) {
-          endpoint = (0, import_middleware_endpoint.toEndpointV1)(
-            await (0, import_middleware_endpoint.getEndpointFromInstructions)(params, import_client_s32.PutObjectCommand, {
-              ...clientConfig
-            })
-          );
-        }
-        if (!endpoint) {
-          throw new Error('Could not resolve endpoint from S3 "client.config.endpoint()" nor EndpointsV2.');
-        }
-        if (eventEmitter !== null) {
-          eventEmitter.off("xhr.upload.progress", uploadEventListener);
-        }
-        const locationKey = this.params.Key.split("/").map((segment) => (0, import_smithy_client.extendedEncodeURIComponent)(segment)).join("/");
-        const locationBucket = (0, import_smithy_client.extendedEncodeURIComponent)(this.params.Bucket);
-        const Location = (() => {
-          const endpointHostnameIncludesBucket = endpoint.hostname.startsWith(`${locationBucket}.`);
-          const forcePathStyle = this.client.config.forcePathStyle;
-          const optionalPort = endpoint.port ? `:${endpoint.port}` : ``;
-          if (forcePathStyle) {
-            return `${endpoint.protocol}//${endpoint.hostname}${optionalPort}/${locationBucket}/${locationKey}`;
-          }
-          if (endpointHostnameIncludesBucket) {
-            return `${endpoint.protocol}//${endpoint.hostname}${optionalPort}/${locationKey}`;
-          }
-          return `${endpoint.protocol}//${locationBucket}.${endpoint.hostname}${optionalPort}/${locationKey}`;
-        })();
-        this.singleUploadResult = {
-          ...putResult,
-          Bucket: this.params.Bucket,
-          Key: this.params.Key,
-          Location
-        };
-        const totalSize = byteLength(dataPart.data);
-        this.__notifyProgress({
-          loaded: totalSize,
-          total: totalSize,
-          part: 1,
-          Key: this.params.Key,
-          Bucket: this.params.Bucket
-        });
-      }
-      async __createMultipartUpload() {
-        const requestChecksumCalculation = await this.client.config.requestChecksumCalculation();
-        if (!this.createMultiPartPromise) {
-          const createCommandParams = { ...this.params, Body: void 0 };
-          if (requestChecksumCalculation === "WHEN_SUPPORTED") {
-            createCommandParams.ChecksumAlgorithm = this.params.ChecksumAlgorithm || import_client_s32.ChecksumAlgorithm.CRC32;
-          }
-          this.createMultiPartPromise = this.client.send(new import_client_s32.CreateMultipartUploadCommand(createCommandParams)).then((createMpuResponse) => {
-            this.abortMultipartUploadCommand = new import_client_s32.AbortMultipartUploadCommand({
-              Bucket: this.params.Bucket,
-              Key: this.params.Key,
-              UploadId: createMpuResponse.UploadId
-            });
-            return createMpuResponse;
-          });
-        }
-        return this.createMultiPartPromise;
-      }
-      async __doConcurrentUpload(dataFeeder) {
-        for await (const dataPart of dataFeeder) {
-          if (this.uploadEnqueuedPartsCount > this.MAX_PARTS) {
-            throw new Error(
-              `Exceeded ${this.MAX_PARTS} parts in multipart upload to Bucket: ${this.params.Bucket} Key: ${this.params.Key}.`
-            );
-          }
-          if (this.abortController.signal.aborted) {
-            return;
-          }
-          if (dataPart.partNumber === 1 && dataPart.lastPart) {
-            return await this.__uploadUsingPut(dataPart);
-          }
-          if (!this.uploadId) {
-            const { UploadId } = await this.__createMultipartUpload();
-            this.uploadId = UploadId;
-            if (this.abortController.signal.aborted) {
-              return;
-            }
-          }
-          const partSize = byteLength(dataPart.data) || 0;
-          const requestHandler = this.client.config.requestHandler;
-          const eventEmitter = requestHandler instanceof import_events.EventEmitter ? requestHandler : null;
-          let lastSeenBytes = 0;
-          const uploadEventListener = /* @__PURE__ */ __name((event, request) => {
-            const requestPartSize = Number(request.query["partNumber"]) || -1;
-            if (requestPartSize !== dataPart.partNumber) {
-              return;
-            }
-            if (event.total && partSize) {
-              this.bytesUploadedSoFar += event.loaded - lastSeenBytes;
-              lastSeenBytes = event.loaded;
-            }
-            this.__notifyProgress({
-              loaded: this.bytesUploadedSoFar,
-              total: this.totalBytes,
-              part: dataPart.partNumber,
-              Key: this.params.Key,
-              Bucket: this.params.Bucket
-            });
-          }, "uploadEventListener");
-          if (eventEmitter !== null) {
-            eventEmitter.on("xhr.upload.progress", uploadEventListener);
-          }
-          this.uploadEnqueuedPartsCount += 1;
-          const partResult = await this.client.send(
-            new import_client_s32.UploadPartCommand({
-              ...this.params,
-              // dataPart.data is chunked into a non-streaming buffer
-              // so the ContentLength from the input should not be used for MPU.
-              ContentLength: void 0,
-              UploadId: this.uploadId,
-              Body: dataPart.data,
-              PartNumber: dataPart.partNumber
-            })
-          );
-          if (eventEmitter !== null) {
-            eventEmitter.off("xhr.upload.progress", uploadEventListener);
-          }
-          if (this.abortController.signal.aborted) {
-            return;
-          }
-          if (!partResult.ETag) {
-            throw new Error(
-              `Part ${dataPart.partNumber} is missing ETag in UploadPart response. Missing Bucket CORS configuration for ETag header?`
-            );
-          }
-          this.uploadedParts.push({
-            PartNumber: dataPart.partNumber,
-            ETag: partResult.ETag,
-            ...partResult.ChecksumCRC32 && { ChecksumCRC32: partResult.ChecksumCRC32 },
-            ...partResult.ChecksumCRC32C && { ChecksumCRC32C: partResult.ChecksumCRC32C },
-            ...partResult.ChecksumSHA1 && { ChecksumSHA1: partResult.ChecksumSHA1 },
-            ...partResult.ChecksumSHA256 && { ChecksumSHA256: partResult.ChecksumSHA256 }
-          });
-          if (eventEmitter === null) {
-            this.bytesUploadedSoFar += partSize;
-          }
-          this.__notifyProgress({
-            loaded: this.bytesUploadedSoFar,
-            total: this.totalBytes,
-            part: dataPart.partNumber,
-            Key: this.params.Key,
-            Bucket: this.params.Bucket
-          });
-        }
-      }
-      async __doMultipartUpload() {
-        const dataFeeder = getChunk(this.params.Body, this.partSize);
-        const concurrentUploaderFailures = [];
-        for (let index = 0; index < this.queueSize; index++) {
-          const currentUpload = this.__doConcurrentUpload(dataFeeder).catch((err) => {
-            concurrentUploaderFailures.push(err);
-          });
-          this.concurrentUploaders.push(currentUpload);
-        }
-        await Promise.all(this.concurrentUploaders);
-        if (concurrentUploaderFailures.length >= 1) {
-          await this.markUploadAsAborted();
-          throw concurrentUploaderFailures[0];
-        }
-        if (this.abortController.signal.aborted) {
-          await this.markUploadAsAborted();
-          throw Object.assign(new Error("Upload aborted."), { name: "AbortError" });
-        }
-        let result;
-        if (this.isMultiPart) {
-          this.uploadedParts.sort((a, b) => a.PartNumber - b.PartNumber);
-          const uploadCompleteParams = {
-            ...this.params,
-            Body: void 0,
-            UploadId: this.uploadId,
-            MultipartUpload: {
-              Parts: this.uploadedParts
-            }
-          };
-          result = await this.client.send(new import_client_s32.CompleteMultipartUploadCommand(uploadCompleteParams));
-          if (typeof result?.Location === "string" && result.Location.includes("%2F")) {
-            result.Location = result.Location.replace(/%2F/g, "/");
-          }
-        } else {
-          result = this.singleUploadResult;
-        }
-        this.abortMultipartUploadCommand = null;
-        if (this.tags.length) {
-          await this.client.send(
-            new import_client_s32.PutObjectTaggingCommand({
-              ...this.params,
-              Tagging: {
-                TagSet: this.tags
-              }
-            })
-          );
-        }
-        return result;
-      }
-      /**
-       * Abort the last multipart upload in progress
-       * if we know the upload id, the user did not specify to leave the parts, and
-       * we have a prepared AbortMultipartUpload command.
-       */
-      async markUploadAsAborted() {
-        if (this.uploadId && !this.leavePartsOnError && null !== this.abortMultipartUploadCommand) {
-          await this.client.send(this.abortMultipartUploadCommand);
-          this.abortMultipartUploadCommand = null;
-        }
-      }
-      __notifyProgress(progress) {
-        if (this.uploadEvent) {
-          this.emit(this.uploadEvent, progress);
-        }
-      }
-      async __abortTimeout(abortSignal) {
-        return new Promise((resolve, reject) => {
-          abortSignal.onabort = () => {
-            const abortError = new Error("Upload aborted.");
-            abortError.name = "AbortError";
-            reject(abortError);
-          };
-        });
-      }
-      __validateInput() {
-        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 < _Upload.MIN_PART_SIZE) {
-          throw new Error(
-            `EntityTooSmall: Your proposed upload partsize [${this.partSize}] is smaller than the minimum allowed size [${_Upload.MIN_PART_SIZE}] (5MB)`
-          );
-        }
-        if (this.queueSize < 1) {
-          throw new Error(`Queue size: Must have at least one uploading queue.`);
-        }
-      }
-    };
-  }
-});
-
-// src/node/@aws-s3/storage/file/upload/index.ts
-var upload_exports = {};
-__export(upload_exports, {
-  upload: () => upload
-});
-var import_client_s3 = __toESM(require_dist_cjs4(), 1);
-var import_lib_storage = __toESM(require_dist_cjs6(), 1);
-async function upload(s3, bucketName, targetPath, fileStream, options) {
-  const {
-    uploadSettings,
-    fileMetadata,
-    overwrite = false
-  } = options ?? {};
-  if (!overwrite) {
-    try {
-      const headCommand = new import_client_s3.HeadObjectCommand({
-        Bucket: bucketName,
-        Key: targetPath
-      });
-      await s3.send(headCommand);
-      return Outcome.makeFailure(`File already exists at ${targetPath}.`);
-    } catch (err) {
-      const code = err?.name ?? err?.$metadata?.httpStatusCode;
-      if (code !== "NotFound" && code !== 404) {
-        return Outcome.makeFailure(unknownToString(err));
-      }
-    }
-  }
-  const params = {
-    ...fileMetadata,
-    Bucket: bucketName,
-    Key: targetPath,
-    Body: fileStream
-  };
-  try {
-    const upload2 = new import_lib_storage.Upload({
-      client: s3,
-      params,
-      ...uploadSettings
-    });
-    await upload2.done();
-    return Outcome.makeSuccess(true);
-  } catch (err) {
-    return Outcome.makeFailure(unknownToString(err));
-  }
-}
-
-export {
-  upload,
-  upload_exports
-};