@datrix/api-upload 0.1.0

package/dist/index.js

@@ -0,0 +1,736 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  LocalStorageProvider: () => LocalStorageProvider,
+  S3StorageProvider: () => S3StorageProvider,
+  Upload: () => Upload
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/schema.ts
+var import_core = require("@datrix/core");
+function createMediaSchema(options, permission) {
+  const modelName = options.modelName ?? "media";
+  return (0, import_core.defineSchema)({
+    name: modelName,
+    fields: {
+      filename: { type: "string", required: true },
+      originalName: { type: "string", required: true },
+      mimeType: { type: "string", required: true },
+      size: { type: "number", required: true, integer: true },
+      key: { type: "string", required: true },
+      variants: { type: "json" }
+    },
+    ...permission !== void 0 && { permission }
+  });
+}
+
+// src/handler.ts
+var import_api = require("@datrix/api");
+var import_core3 = require("@datrix/core");
+
+// src/processor.ts
+var import_core2 = require("@datrix/core");
+var IMAGE_MIME_TYPES = /* @__PURE__ */ new Set([
+  "image/jpeg",
+  "image/png",
+  "image/webp",
+  "image/avif",
+  "image/gif",
+  "image/tiff"
+]);
+function isImage(mimetype) {
+  return IMAGE_MIME_TYPES.has(mimetype);
+}
+function getMimeType(format) {
+  const map = {
+    webp: "image/webp",
+    jpeg: "image/jpeg",
+    png: "image/png",
+    avif: "image/avif"
+  };
+  return map[format];
+}
+function getExtension(format) {
+  return format === "jpeg" ? "jpg" : format;
+}
+async function convertFormat(file, format, quality) {
+  if (!isImage(file.mimetype)) {
+    return {
+      buffer: file.buffer,
+      mimetype: file.mimetype,
+      filename: file.filename
+    };
+  }
+  let sharp;
+  try {
+    sharp = (await import("sharp")).default;
+  } catch (error) {
+    throw new import_core2.DatrixError("sharp is not installed", {
+      code: "SHARP_NOT_FOUND",
+      operation: "upload:convertFormat"
+    });
+  }
+  try {
+    const converted = await sharp(file.buffer).toFormat(format, { quality }).toBuffer();
+    const ext = getExtension(format);
+    const baseName = file.filename.replace(/\.[^.]+$/, "");
+    const newFilename = `${baseName}.${ext}`;
+    return {
+      buffer: new Uint8Array(converted),
+      mimetype: getMimeType(format),
+      filename: newFilename
+    };
+  } catch (error) {
+    throw new import_core2.DatrixError("Failed to convert image format", {
+      code: "IMAGE_CONVERT_ERROR",
+      operation: "upload:convertFormat",
+      cause: error instanceof Error ? error : void 0
+    });
+  }
+}
+async function generateVariants(file, resolutions, format, quality, uploadFn) {
+  if (!isImage(file.mimetype)) {
+    return {};
+  }
+  let sharp;
+  try {
+    sharp = (await import("sharp")).default;
+  } catch (error) {
+    throw new import_core2.DatrixError("sharp is not installed", {
+      code: "SHARP_NOT_FOUND",
+      operation: "upload:generateVariants"
+    });
+  }
+  const targetFormat = format ?? "jpeg";
+  const outputMime = getMimeType(targetFormat);
+  const outputExt = getExtension(targetFormat);
+  const variants = {};
+  for (const [name, config] of Object.entries(resolutions)) {
+    try {
+      const resizeOptions = {
+        width: config.width,
+        ...config.height !== void 0 && { height: config.height },
+        ...config.fit !== void 0 && config.height !== void 0 && { fit: config.fit }
+      };
+      const variantBuffer = await sharp(file.buffer).resize(resizeOptions).toFormat(targetFormat, { quality }).toBuffer({ resolveWithObject: true });
+      const baseName = file.filename.replace(/\.[^.]+$/, "");
+      const variantFilename = `${baseName}-${name}.${outputExt}`;
+      const variantFile = {
+        filename: variantFilename,
+        originalName: variantFilename,
+        mimetype: outputMime,
+        size: variantBuffer.data.length,
+        buffer: new Uint8Array(variantBuffer.data)
+      };
+      const uploaded = await uploadFn(variantFile);
+      variants[name] = {
+        key: uploaded.key,
+        width: variantBuffer.info.width,
+        height: variantBuffer.info.height,
+        size: variantBuffer.data.length,
+        mimeType: outputMime,
+        url: void 0
+      };
+    } catch (error) {
+      if (error instanceof import_core2.DatrixError) throw error;
+      throw new import_core2.DatrixError(`Failed to generate variant: ${name}`, {
+        code: "VARIANT_GENERATE_ERROR",
+        operation: "upload:generateVariants",
+        cause: error instanceof Error ? error : void 0
+      });
+    }
+  }
+  return variants;
+}
+
+// src/handler.ts
+async function handleUploadRequest(request, options) {
+  try {
+    const { method } = request;
+    const url = new URL(request.url);
+    const pathAfterUpload = url.pathname.replace(/.*\/upload/, "");
+    const idSegment = pathAfterUpload.replace(/^\//, "").split("/")[0];
+    const id = idSegment !== void 0 && idSegment !== "" ? Number(idSegment) : null;
+    if (method === "POST" && id === null) {
+      return await handleUpload(request, options);
+    }
+    if (method === "DELETE" && id !== null) {
+      return await handleDeleteMedia(id, options);
+    }
+    return (0, import_api.datrixErrorResponse)(import_api.handlerError.methodNotAllowed(method));
+  } catch (error) {
+    if (error instanceof import_core3.DatrixValidationError || error instanceof import_core3.DatrixError) {
+      return (0, import_api.datrixErrorResponse)(error);
+    }
+    const message = error instanceof Error ? error.message : "Upload failed";
+    return (0, import_api.datrixErrorResponse)(
+      import_api.handlerError.internalError(
+        message,
+        error instanceof Error ? error : void 0
+      )
+    );
+  }
+}
+async function handleUpload(request, options) {
+  const { datrix, uploadOptions } = options;
+  const modelName = uploadOptions.modelName ?? "media";
+  const contentType = request.headers.get("content-type") ?? "";
+  if (!contentType.includes("multipart/form-data")) {
+    return (0, import_api.datrixErrorResponse)(
+      import_api.handlerError.invalidBody("Expected multipart/form-data")
+    );
+  }
+  let formData;
+  try {
+    formData = await request.formData();
+  } catch (error) {
+    const cause = error instanceof Error ? error : void 0;
+    throw new import_api.DatrixApiError("Failed to parse multipart form data", {
+      code: "MULTIPART_PARSE_ERROR",
+      status: 400,
+      ...cause !== void 0 && { cause }
+    });
+  }
+  const fileEntry = formData.get("file");
+  if (!(fileEntry instanceof File)) {
+    return (0, import_api.datrixErrorResponse)(
+      import_api.handlerError.invalidBody("No file field in form data")
+    );
+  }
+  const buffer = await fileEntry.arrayBuffer();
+  const rawFile = {
+    filename: fileEntry.name,
+    originalName: fileEntry.name,
+    mimetype: fileEntry.type,
+    size: fileEntry.size,
+    buffer: new Uint8Array(buffer)
+  };
+  validateFileLimits(rawFile, uploadOptions);
+  const quality = uploadOptions.quality ?? 80;
+  const fileToUpload = uploadOptions.format !== void 0 && isImage(rawFile.mimetype) ? await convertFormat(rawFile, uploadOptions.format, quality) : rawFile;
+  const uploadFile = {
+    filename: fileToUpload.filename,
+    originalName: rawFile.originalName,
+    mimetype: fileToUpload.mimetype,
+    size: fileToUpload.buffer.length,
+    buffer: fileToUpload.buffer
+  };
+  const result = await uploadOptions.provider.upload(uploadFile);
+  let variants = null;
+  if (uploadOptions.resolutions !== void 0 && isImage(uploadFile.mimetype)) {
+    const generated = await generateVariants(
+      uploadFile,
+      uploadOptions.resolutions,
+      uploadOptions.format,
+      quality,
+      async (variantFile) => {
+        const variantResult = await uploadOptions.provider.upload(variantFile);
+        return { key: variantResult.key };
+      }
+    );
+    variants = generated;
+  }
+  const mediaRecord = await datrix.raw.create(modelName, {
+    filename: result.key,
+    originalName: uploadFile.originalName,
+    mimeType: uploadFile.mimetype,
+    size: uploadFile.size,
+    key: result.key,
+    ...variants !== null && { variants }
+  });
+  const data = options.injectUrls ? await options.injectUrls(mediaRecord) : mediaRecord;
+  return (0, import_api.jsonResponse)({ data }, 201);
+}
+async function handleDeleteMedia(id, options) {
+  const { datrix, uploadOptions } = options;
+  const modelName = uploadOptions.modelName ?? "media";
+  const record = await datrix.raw.findById(modelName, id);
+  if (record === null) {
+    return (0, import_api.datrixErrorResponse)(import_api.handlerError.recordNotFound(modelName, id));
+  }
+  if (record.variants !== null && record.variants !== void 0) {
+    for (const variant of Object.values(record.variants)) {
+      await uploadOptions.provider.delete(variant.key);
+    }
+  }
+  await uploadOptions.provider.delete(record.key);
+  await datrix.raw.delete(modelName, id);
+  return (0, import_api.jsonResponse)({ data: { id } });
+}
+function validateFileLimits(file, options) {
+  if (options.maxSize !== void 0 && file.size > options.maxSize) {
+    throw new import_api.DatrixApiError(
+      `File size ${file.size} exceeds maximum allowed size ${options.maxSize}`,
+      { code: "FILE_TOO_LARGE", status: 400 }
+    );
+  }
+  if (options.allowedMimeTypes !== void 0 && options.allowedMimeTypes.length > 0 && !isMimeTypeAllowed(file.mimetype, options.allowedMimeTypes)) {
+    throw new import_api.DatrixApiError(`MIME type ${file.mimetype} is not allowed`, {
+      code: "INVALID_MIME_TYPE",
+      status: 400
+    });
+  }
+}
+function isMimeTypeAllowed(mimetype, allowedTypes) {
+  for (const allowed of allowedTypes) {
+    if (allowed === mimetype) return true;
+    if (allowed.endsWith("/*")) {
+      const prefix = allowed.slice(0, -2);
+      if (mimetype.startsWith(prefix + "/")) return true;
+    }
+  }
+  return false;
+}
+
+// src/upload.ts
+var Upload = class {
+  options;
+  provider;
+  constructor(options) {
+    this.options = options;
+    this.provider = options.provider;
+  }
+  getModelName() {
+    return this.options.modelName ?? "media";
+  }
+  getSchemas() {
+    const mediaSchema = createMediaSchema(
+      this.options,
+      this.options.permission
+    );
+    return [mediaSchema];
+  }
+  async handleRequest(request, datrix) {
+    return handleUploadRequest(request, {
+      datrix,
+      uploadOptions: this.options,
+      injectUrls: (data) => this.injectUrls(data)
+    });
+  }
+  async injectUrls(data) {
+    return this.traverse(data);
+  }
+  getUrl(key) {
+    return this.options.provider.getUrl(key);
+  }
+  async traverse(node) {
+    if (Array.isArray(node)) {
+      const results = [];
+      for (const item of node) {
+        results.push(await this.traverse(item));
+      }
+      return results;
+    }
+    if (node !== null && typeof node === "object") {
+      const obj = node;
+      const result = {};
+      for (const [k, v] of Object.entries(obj)) {
+        result[k] = await this.traverse(v);
+      }
+      if (typeof result["key"] === "string" && result["url"] === void 0) {
+        result["url"] = this.options.provider.getUrl(result["key"]);
+      }
+      if (result["variants"] !== null && typeof result["variants"] === "object") {
+        const variants = result["variants"];
+        for (const [name, variant] of Object.entries(variants)) {
+          if (variant !== null && typeof variant === "object") {
+            const v = variant;
+            if (typeof v["key"] === "string" && v["url"] === void 0) {
+              variants[name] = {
+                ...v,
+                url: this.options.provider.getUrl(v["key"])
+              };
+            }
+          }
+        }
+      }
+      return result;
+    }
+    return node;
+  }
+};
+
+// src/providers/local.ts
+var import_core4 = require("@datrix/core");
+var import_core5 = require("@datrix/core");
+var UploadError = class extends import_core5.DatrixError {
+  constructor(message, cause) {
+    super(message, {
+      code: "UPLOAD_ERROR",
+      operation: "upload:local",
+      ...cause !== void 0 && { cause }
+    });
+    this.name = "UploadError";
+  }
+};
+var LocalStorageProvider = class {
+  name = "local";
+  basePath;
+  baseUrl;
+  ensureDirectory;
+  constructor(options) {
+    this.basePath = options.basePath;
+    this.baseUrl = options.baseUrl;
+    this.ensureDirectory = options.ensureDirectory ?? true;
+  }
+  async upload(file) {
+    try {
+      const fs = await import("fs/promises");
+      const path = await import("path");
+      const sanitized = (0, import_core4.sanitizeFilename)(file.originalName);
+      const uniqueFilename = (0, import_core4.generateUniqueFilename)(sanitized);
+      const fullPath = path.join(this.basePath, uniqueFilename);
+      if (this.ensureDirectory) {
+        const dirPath = path.dirname(fullPath);
+        await fs.mkdir(dirPath, { recursive: true });
+      }
+      await fs.writeFile(fullPath, file.buffer);
+      return {
+        key: uniqueFilename,
+        size: file.size,
+        mimetype: file.mimetype,
+        uploadedAt: /* @__PURE__ */ new Date()
+      };
+    } catch (error) {
+      const cause = error instanceof Error ? error : void 0;
+      throw new UploadError("Failed to upload file to local filesystem", cause);
+    }
+  }
+  async delete(key) {
+    const fs = await import("fs/promises");
+    const path = await import("path");
+    const fullPath = path.join(this.basePath, key);
+    try {
+      await fs.access(fullPath);
+    } catch (error) {
+      const cause = error instanceof Error ? error : void 0;
+      throw new UploadError("File not found", cause);
+    }
+    try {
+      await fs.unlink(fullPath);
+    } catch (error) {
+      const cause = error instanceof Error ? error : void 0;
+      throw new UploadError(
+        "Failed to delete file from local filesystem",
+        cause
+      );
+    }
+  }
+  getUrl(key) {
+    return this.buildUrl(key);
+  }
+  async exists(key) {
+    try {
+      const fs = await import("fs/promises");
+      const path = await import("path");
+      const fullPath = path.join(this.basePath, key);
+      await fs.access(fullPath);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  buildUrl(key) {
+    const cleanBaseUrl = this.baseUrl.replace(/\/$/, "");
+    const cleanKey = key.replace(/^\//, "");
+    return `${cleanBaseUrl}/${cleanKey}`;
+  }
+};
+
+// src/providers/s3.ts
+var import_core6 = require("@datrix/core");
+var import_core7 = require("@datrix/core");
+var UploadError2 = class extends import_core7.DatrixError {
+  constructor(message, cause) {
+    super(message, {
+      code: "UPLOAD_ERROR",
+      operation: "upload:s3",
+      ...cause !== void 0 && { cause }
+    });
+    this.name = "UploadError";
+  }
+};
+var S3StorageProvider = class {
+  name = "s3";
+  bucket;
+  region;
+  accessKeyId;
+  secretAccessKey;
+  endpoint;
+  pathPrefix;
+  constructor(options) {
+    this.bucket = options.bucket;
+    this.region = options.region;
+    this.accessKeyId = options.accessKeyId;
+    this.secretAccessKey = options.secretAccessKey;
+    this.endpoint = options.endpoint ?? `s3.${options.region}.amazonaws.com`;
+    this.pathPrefix = options.pathPrefix ?? "uploads";
+  }
+  async upload(file) {
+    try {
+      const sanitized = (0, import_core6.sanitizeFilename)(file.originalName);
+      const filename = (0, import_core6.generateUniqueFilename)(sanitized);
+      const key = this.pathPrefix ? `${this.pathPrefix}/${filename}` : filename;
+      await this.putObject(key, file.buffer, file.mimetype);
+      return {
+        key,
+        size: file.size,
+        mimetype: file.mimetype,
+        uploadedAt: /* @__PURE__ */ new Date()
+      };
+    } catch (error) {
+      if (error instanceof UploadError2) throw error;
+      const cause = error instanceof Error ? error : void 0;
+      throw new UploadError2("Failed to upload file to S3", cause);
+    }
+  }
+  async delete(key) {
+    try {
+      await this.deleteObject(key);
+    } catch (error) {
+      if (error instanceof UploadError2) throw error;
+      const cause = error instanceof Error ? error : void 0;
+      throw new UploadError2("Failed to delete file from S3", cause);
+    }
+  }
+  getUrl(key) {
+    return `https://${this.bucket}.${this.endpoint}/${key}`;
+  }
+  async exists(key) {
+    try {
+      await this.headObject(key);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  async putObject(key, buffer, contentType) {
+    const https = await import("https");
+    const crypto = await import("crypto");
+    const host = `${this.bucket}.${this.endpoint}`;
+    const urlPath = `/${key}`;
+    const method = "PUT";
+    const date = (/* @__PURE__ */ new Date()).toUTCString();
+    const contentHash = crypto.createHash("sha256").update(buffer).digest("hex");
+    const authorization = await this.signRequest(
+      method,
+      urlPath,
+      host,
+      date,
+      contentType,
+      contentHash
+    );
+    await new Promise((resolve, reject) => {
+      const req = https.request(
+        {
+          hostname: host,
+          port: 443,
+          path: urlPath,
+          method,
+          headers: {
+            Host: host,
+            Date: date,
+            "Content-Type": contentType,
+            "Content-Length": buffer.length,
+            "x-amz-content-sha256": contentHash,
+            Authorization: authorization
+          }
+        },
+        (res) => {
+          const status = res.statusCode ?? 0;
+          if (status >= 200 && status < 300) {
+            resolve();
+          } else {
+            let body = "";
+            res.on("data", (chunk) => {
+              body += chunk.toString();
+            });
+            res.on("end", () => {
+              reject(new UploadError2(`S3 upload failed: ${status} ${body}`));
+            });
+          }
+        }
+      );
+      req.on("error", (error) => {
+        reject(new UploadError2("S3 request failed", error));
+      });
+      req.write(buffer);
+      req.end();
+    });
+  }
+  async deleteObject(key) {
+    const https = await import("https");
+    const crypto = await import("crypto");
+    const host = `${this.bucket}.${this.endpoint}`;
+    const urlPath = `/${key}`;
+    const method = "DELETE";
+    const date = (/* @__PURE__ */ new Date()).toUTCString();
+    const contentHash = crypto.createHash("sha256").update("").digest("hex");
+    const authorization = await this.signRequest(
+      method,
+      urlPath,
+      host,
+      date,
+      "",
+      contentHash
+    );
+    await new Promise((resolve, reject) => {
+      const req = https.request(
+        {
+          hostname: host,
+          port: 443,
+          path: urlPath,
+          method,
+          headers: {
+            Host: host,
+            Date: date,
+            "x-amz-content-sha256": contentHash,
+            Authorization: authorization
+          }
+        },
+        (res) => {
+          const status = res.statusCode ?? 0;
+          if (status >= 200 && status < 300) {
+            resolve();
+          } else {
+            let body = "";
+            res.on("data", (chunk) => {
+              body += chunk.toString();
+            });
+            res.on("end", () => {
+              reject(new UploadError2(`S3 delete failed: ${status} ${body}`));
+            });
+          }
+        }
+      );
+      req.on("error", (error) => {
+        reject(new UploadError2("S3 request failed", error));
+      });
+      req.end();
+    });
+  }
+  async headObject(key) {
+    const https = await import("https");
+    const crypto = await import("crypto");
+    const host = `${this.bucket}.${this.endpoint}`;
+    const urlPath = `/${key}`;
+    const method = "HEAD";
+    const date = (/* @__PURE__ */ new Date()).toUTCString();
+    const contentHash = crypto.createHash("sha256").update("").digest("hex");
+    const authorization = await this.signRequest(
+      method,
+      urlPath,
+      host,
+      date,
+      "",
+      contentHash
+    );
+    await new Promise((resolve, reject) => {
+      const req = https.request(
+        {
+          hostname: host,
+          port: 443,
+          path: urlPath,
+          method,
+          headers: {
+            Host: host,
+            Date: date,
+            "x-amz-content-sha256": contentHash,
+            Authorization: authorization
+          }
+        },
+        (res) => {
+          const status = res.statusCode ?? 0;
+          if (status >= 200 && status < 300) resolve();
+          else reject(new UploadError2(`Object not found: ${status}`));
+        }
+      );
+      req.on("error", (error) => {
+        reject(new UploadError2("S3 request failed", error));
+      });
+      req.end();
+    });
+  }
+  async signRequest(method, urlPath, host, date, _contentType, contentHash) {
+    const crypto = await import("crypto");
+    const canonicalHeaders = `host:${host}
+x-amz-content-sha256:${contentHash}
+x-amz-date:${date}
+`;
+    const signedHeaders = "host;x-amz-content-sha256;x-amz-date";
+    const canonicalRequest = [
+      method,
+      urlPath,
+      "",
+      canonicalHeaders,
+      signedHeaders,
+      contentHash
+    ].join("\n");
+    const algorithm = "AWS4-HMAC-SHA256";
+    const amzDate = this.getAmzDate();
+    const credentialScope = `${this.getDateStamp()}/${this.region}/s3/aws4_request`;
+    const canonicalRequestHash = crypto.createHash("sha256").update(canonicalRequest).digest("hex");
+    const stringToSign = [
+      algorithm,
+      amzDate,
+      credentialScope,
+      canonicalRequestHash
+    ].join("\n");
+    const signature = this.calculateSignature(crypto, stringToSign);
+    return `${algorithm} Credential=${this.accessKeyId}/${credentialScope}, SignedHeaders=${signedHeaders}, Signature=${signature}`;
+  }
+  calculateSignature(crypto, stringToSign) {
+    const kDate = crypto.createHmac("sha256", `AWS4${this.secretAccessKey}`).update(this.getDateStamp()).digest();
+    const kRegion = crypto.createHmac("sha256", kDate).update(this.region).digest();
+    const kService = crypto.createHmac("sha256", kRegion).update("s3").digest();
+    const kSigning = crypto.createHmac("sha256", kService).update("aws4_request").digest();
+    return crypto.createHmac("sha256", kSigning).update(stringToSign).digest("hex");
+  }
+  getAmzDate() {
+    return (/* @__PURE__ */ new Date()).toISOString().replace(/[:-]|\.\d{3}/g, "");
+  }
+  getDateStamp() {
+    const now = /* @__PURE__ */ new Date();
+    const year = now.getUTCFullYear();
+    const month = String(now.getUTCMonth() + 1).padStart(2, "0");
+    const day = String(now.getUTCDate()).padStart(2, "0");
+    return `${year}${month}${day}`;
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  LocalStorageProvider,
+  S3StorageProvider,
+  Upload
+});
+//# sourceMappingURL=index.js.map