@ustorage/sdk 0.1.0

package/dist/node/index.d.cts

@@ -0,0 +1,59 @@
+import { NodeCredentialAuth, BearerAuth, UStorageCoreClient, ResumeStore, PutObjectOptions, UploadObjectResult, UploadFileOptions, MemoryResumeStore, UploadSource, UploadChunk } from '../core/index.cjs';
+export { AuthHeadersProvider, BrowserAuth, CompleteUploadRequest, CompleteUploadResponse, CreateFileUrlRequest, CreateFileUrlResponse, CreateUploadSessionRequest, CreateUploadSessionResponse, CreateUploadTokenRequest, CreateUploadTokenResponse, ErrorResponse, FetchHttpClient, GetObjectUrlInput, GetObjectUrlResult, HeaderValue, HttpClient, HttpRequestOptions, JsonValue, FetchHttpClient as NodeHttpClient, UStorageClientOptions, UStorageError, UploadApi, UploadBody, UploadChunkResponse, UploadProgressEvent, UploadStatus, UploadStatusResponse, Uploader, resolveToken, toUStorageError } from '../core/index.cjs';
+
+type UStorageNodeAuth = NodeCredentialAuth | BearerAuth;
+interface UStorageNodeClientOptions {
+    uploadBaseUrl: string;
+    auth: UStorageNodeAuth;
+    resumeStore?: ResumeStore;
+}
+declare class UStorageNodeClient extends UStorageCoreClient {
+    constructor(options: UStorageNodeClientOptions);
+    putObject(options: PutObjectOptions & {
+        body: Buffer | string;
+    }): Promise<UploadObjectResult>;
+    uploadFile(path: string, options: UploadFileOptions): Promise<UploadObjectResult>;
+}
+
+declare class NodeMemoryResumeStore extends MemoryResumeStore {
+}
+declare class NodeFileResumeStore implements ResumeStore {
+    private readonly path;
+    constructor(path: string);
+    get(key: string): Promise<string | undefined>;
+    set(key: string, uploadId: string): Promise<void>;
+    delete(key: string): Promise<void>;
+    private read;
+    private write;
+    clear(): Promise<void>;
+}
+
+interface SignedRequestPlaceholder {
+    readonly supported: false;
+}
+declare const nodeSigner: SignedRequestPlaceholder;
+
+declare class NodeFileUploadSource implements UploadSource {
+    private readonly path;
+    readonly name: string;
+    readonly size: number;
+    readonly type?: string;
+    private constructor();
+    static fromPath(path: string, options?: {
+        name?: string;
+        type?: string;
+    }): Promise<NodeFileUploadSource>;
+    fingerprint(key?: string): string;
+    slice(start: number, end: number): Promise<UploadChunk>;
+}
+declare class NodeBufferUploadSource implements UploadSource {
+    private readonly buffer;
+    readonly name: string;
+    readonly size: number;
+    readonly type?: string;
+    constructor(buffer: Buffer, name: string, type?: string);
+    fingerprint(key?: string): string;
+    slice(start: number, end: number): UploadChunk;
+}
+
+export { BearerAuth, MemoryResumeStore, NodeBufferUploadSource, NodeCredentialAuth, NodeFileResumeStore, NodeFileUploadSource, NodeMemoryResumeStore, PutObjectOptions, ResumeStore, type SignedRequestPlaceholder, UStorageCoreClient, type UStorageNodeAuth, UStorageNodeClient, type UStorageNodeClientOptions, UploadChunk, UploadFileOptions, UploadObjectResult, UploadSource, nodeSigner };

package/dist/node/index.d.ts

@@ -0,0 +1,59 @@
+import { NodeCredentialAuth, BearerAuth, UStorageCoreClient, ResumeStore, PutObjectOptions, UploadObjectResult, UploadFileOptions, MemoryResumeStore, UploadSource, UploadChunk } from '../core/index.js';
+export { AuthHeadersProvider, BrowserAuth, CompleteUploadRequest, CompleteUploadResponse, CreateFileUrlRequest, CreateFileUrlResponse, CreateUploadSessionRequest, CreateUploadSessionResponse, CreateUploadTokenRequest, CreateUploadTokenResponse, ErrorResponse, FetchHttpClient, GetObjectUrlInput, GetObjectUrlResult, HeaderValue, HttpClient, HttpRequestOptions, JsonValue, FetchHttpClient as NodeHttpClient, UStorageClientOptions, UStorageError, UploadApi, UploadBody, UploadChunkResponse, UploadProgressEvent, UploadStatus, UploadStatusResponse, Uploader, resolveToken, toUStorageError } from '../core/index.js';
+
+type UStorageNodeAuth = NodeCredentialAuth | BearerAuth;
+interface UStorageNodeClientOptions {
+    uploadBaseUrl: string;
+    auth: UStorageNodeAuth;
+    resumeStore?: ResumeStore;
+}
+declare class UStorageNodeClient extends UStorageCoreClient {
+    constructor(options: UStorageNodeClientOptions);
+    putObject(options: PutObjectOptions & {
+        body: Buffer | string;
+    }): Promise<UploadObjectResult>;
+    uploadFile(path: string, options: UploadFileOptions): Promise<UploadObjectResult>;
+}
+
+declare class NodeMemoryResumeStore extends MemoryResumeStore {
+}
+declare class NodeFileResumeStore implements ResumeStore {
+    private readonly path;
+    constructor(path: string);
+    get(key: string): Promise<string | undefined>;
+    set(key: string, uploadId: string): Promise<void>;
+    delete(key: string): Promise<void>;
+    private read;
+    private write;
+    clear(): Promise<void>;
+}
+
+interface SignedRequestPlaceholder {
+    readonly supported: false;
+}
+declare const nodeSigner: SignedRequestPlaceholder;
+
+declare class NodeFileUploadSource implements UploadSource {
+    private readonly path;
+    readonly name: string;
+    readonly size: number;
+    readonly type?: string;
+    private constructor();
+    static fromPath(path: string, options?: {
+        name?: string;
+        type?: string;
+    }): Promise<NodeFileUploadSource>;
+    fingerprint(key?: string): string;
+    slice(start: number, end: number): Promise<UploadChunk>;
+}
+declare class NodeBufferUploadSource implements UploadSource {
+    private readonly buffer;
+    readonly name: string;
+    readonly size: number;
+    readonly type?: string;
+    constructor(buffer: Buffer, name: string, type?: string);
+    fingerprint(key?: string): string;
+    slice(start: number, end: number): UploadChunk;
+}
+
+export { BearerAuth, MemoryResumeStore, NodeBufferUploadSource, NodeCredentialAuth, NodeFileResumeStore, NodeFileUploadSource, NodeMemoryResumeStore, PutObjectOptions, ResumeStore, type SignedRequestPlaceholder, UStorageCoreClient, type UStorageNodeAuth, UStorageNodeClient, type UStorageNodeClientOptions, UploadChunk, UploadFileOptions, UploadObjectResult, UploadSource, nodeSigner };

package/dist/node/index.js

@@ -0,0 +1,514 @@
+// src/core/auth/index.ts
+async function resolveToken(value) {
+  return typeof value === "function" ? value() : value;
+}
+
+// src/core/errors/index.ts
+var UStorageError = class extends Error {
+  code;
+  status;
+  requestId;
+  details;
+  constructor(message, options) {
+    super(message);
+    this.name = "UStorageError";
+    this.code = options.code;
+    this.status = options.status;
+    this.requestId = options.requestId;
+    this.details = options.details;
+  }
+};
+function toUStorageError(status, body) {
+  const parsed = body;
+  if (parsed?.error?.code && parsed.error.message) {
+    return new UStorageError(parsed.error.message, {
+      code: parsed.error.code,
+      status,
+      requestId: parsed.request_id,
+      details: parsed.error.details
+    });
+  }
+  return new UStorageError(`UStorage request failed with status ${status}`, { code: "REQUEST_FAILED", status });
+}
+
+// src/core/http/index.ts
+var FetchHttpClient = class {
+  baseUrl;
+  authHeaders;
+  fetchImpl;
+  constructor(options) {
+    this.baseUrl = options.baseUrl.replace(/\/$/, "");
+    this.authHeaders = options.authHeaders;
+    this.fetchImpl = options.fetchImpl ?? fetch;
+  }
+  async request(options) {
+    const headers = new Headers();
+    for (const [key, value] of Object.entries(options.headers ?? {})) {
+      if (value !== void 0 && value !== null) headers.set(key, value);
+    }
+    let body;
+    if (options.body !== void 0) {
+      if (isBodyInit(options.body)) {
+        body = options.body;
+      } else {
+        headers.set("content-type", headers.get("content-type") ?? "application/json");
+        body = JSON.stringify(options.body);
+      }
+    }
+    const path = this.pathWithQuery(options.path, options.query);
+    const authHeaders = this.authHeaders ? await this.authHeaders({ method: options.method, path, body }) : {};
+    for (const [key, value] of Object.entries(authHeaders)) headers.set(key, value);
+    const response = await this.fetchImpl(this.url(path), {
+      method: options.method,
+      headers,
+      body,
+      signal: options.signal
+    });
+    if (response.status === 204) return void 0;
+    const text = await response.text();
+    const parsed = text ? parseJson(text) : void 0;
+    if (!response.ok) throw toUStorageError(response.status, parsed);
+    return parsed;
+  }
+  url(path) {
+    return new URL(path.startsWith("/") ? path : `/${path}`, `${this.baseUrl}/`).toString();
+  }
+  pathWithQuery(path, query) {
+    const url = new URL(path.startsWith("/") ? path : `/${path}`, "http://sdk.local");
+    for (const [key, value] of Object.entries(query ?? {})) {
+      if (value !== void 0 && value !== null) url.searchParams.set(key, String(value));
+    }
+    return `${url.pathname}${url.search}`;
+  }
+};
+function parseJson(value) {
+  try {
+    return JSON.parse(value);
+  } catch {
+    return value;
+  }
+}
+function isBodyInit(value) {
+  return typeof Blob !== "undefined" && value instanceof Blob || typeof FormData !== "undefined" && value instanceof FormData || typeof URLSearchParams !== "undefined" && value instanceof URLSearchParams || typeof ArrayBuffer !== "undefined" && value instanceof ArrayBuffer || ArrayBuffer.isView(value) || typeof ReadableStream !== "undefined" && value instanceof ReadableStream;
+}
+
+// src/core/upload/api.ts
+var UploadApi = class {
+  constructor(http) {
+    this.http = http;
+  }
+  http;
+  createUploadToken(request) {
+    return this.http.request({ method: "POST", path: "/uploads/tokens", body: request });
+  }
+  createSession(request) {
+    return this.http.request({ method: "POST", path: "/uploads/sessions", body: request });
+  }
+  createFileUrl(request) {
+    return this.http.request({ method: "POST", path: "/files/url", body: request });
+  }
+  uploadChunk(uploadId, index, body, checksum, signal) {
+    return this.http.request({ method: "PUT", path: `/uploads/${uploadId}/chunks/${index}`, headers: { "x-chunk-checksum": checksum }, body, signal });
+  }
+  getStatus(uploadId) {
+    return this.http.request({ method: "GET", path: `/uploads/${uploadId}/status` });
+  }
+  complete(uploadId, request = {}) {
+    return this.http.request({ method: "POST", path: `/uploads/${uploadId}/complete`, body: request });
+  }
+  cancel(uploadId) {
+    return this.http.request({ method: "DELETE", path: `/uploads/${uploadId}` });
+  }
+};
+
+// src/core/upload/checksum.ts
+async function sha256Hex(data) {
+  const bytes = await toBytes(data);
+  const digest = await crypto.subtle.digest("SHA-256", bytes);
+  return Array.from(new Uint8Array(digest), (byte) => byte.toString(16).padStart(2, "0")).join("");
+}
+async function toBytes(data) {
+  if (data instanceof ArrayBuffer) return data;
+  if (ArrayBuffer.isView(data)) return new Uint8Array(data.buffer, data.byteOffset, data.byteLength).slice().buffer;
+  if (typeof Blob !== "undefined" && data instanceof Blob) return data.arrayBuffer();
+  if (typeof data === "string") return new TextEncoder().encode(data).buffer;
+  return new Response(data).arrayBuffer();
+}
+
+// src/core/upload/file-metadata.ts
+var mimeTypesByExtension = {
+  jpg: "image/jpeg",
+  jpeg: "image/jpeg",
+  png: "image/png",
+  gif: "image/gif",
+  webp: "image/webp",
+  bmp: "image/bmp",
+  svg: "image/svg+xml",
+  heic: "image/heic",
+  mp4: "video/mp4",
+  mpeg: "video/mpeg",
+  mov: "video/quicktime",
+  avi: "video/x-msvideo",
+  webm: "video/webm",
+  ogg: "video/ogg",
+  "3gp": "video/3gpp",
+  flv: "video/x-flv",
+  mp3: "audio/mpeg",
+  wav: "audio/wav",
+  aac: "audio/aac",
+  m4a: "audio/x-m4a",
+  flac: "audio/flac",
+  amr: "audio/amr",
+  pdf: "application/pdf",
+  txt: "text/plain",
+  json: "application/json",
+  zip: "application/zip",
+  tar: "application/x-tar",
+  rar: "application/vnd.rar",
+  doc: "application/msword",
+  docx: "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
+  xls: "application/vnd.ms-excel",
+  xlsx: "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+  ppt: "application/vnd.ms-powerpoint",
+  pptx: "application/vnd.openxmlformats-officedocument.presentationml.presentation"
+};
+function extensionFromName(nameOrKey) {
+  const filename = nameOrKey.split(/[\\/]/).filter(Boolean).at(-1) ?? nameOrKey;
+  const dot = filename.lastIndexOf(".");
+  if (dot <= 0 || dot === filename.length - 1) {
+    return null;
+  }
+  return filename.slice(dot + 1).toLowerCase();
+}
+function mimeTypeFromExtension(extension) {
+  return extension ? mimeTypesByExtension[extension.toLowerCase()] ?? null : null;
+}
+function resolveUploadContentType(explicit, sourceType, ...names) {
+  const normalizedExplicit = normalizeContentType(explicit);
+  if (normalizedExplicit) {
+    return normalizedExplicit;
+  }
+  const normalizedSourceType = normalizeContentType(sourceType);
+  if (normalizedSourceType) {
+    return normalizedSourceType;
+  }
+  for (const name of names) {
+    if (!name) continue;
+    const inferred = mimeTypeFromExtension(extensionFromName(name));
+    if (inferred) {
+      return inferred;
+    }
+  }
+  return null;
+}
+function normalizeContentType(value) {
+  const normalized = value?.trim();
+  return normalized ? normalized : null;
+}
+
+// src/core/upload/uploader.ts
+var Uploader = class {
+  constructor(uploads, resumeStore) {
+    this.uploads = uploads;
+    this.resumeStore = resumeStore;
+  }
+  uploads;
+  resumeStore;
+  async putObject(source, options) {
+    const chunkSize = options.chunkSize ?? 8 * 1024 * 1024;
+    if (chunkSize <= 0) throw new Error("chunkSize must be positive");
+    const totalChunks = source.size === 0 ? 1 : Math.ceil(source.size / chunkSize);
+    const useResume = options.resume === true || Boolean(options.resumeKey);
+    const resumeKey = useResume ? options.resumeKey ?? await source.fingerprint(options.key) : void 0;
+    let uploadId = resumeKey && this.resumeStore ? await this.resumeStore.get(resumeKey) : void 0;
+    let missingChunks;
+    if (uploadId) {
+      try {
+        const status = await this.uploads.getStatus(uploadId);
+        missingChunks = status.missing_chunks;
+        options.onProgress?.(statusToProgress(status));
+      } catch {
+        uploadId = void 0;
+        if (resumeKey) await this.resumeStore?.delete(resumeKey);
+      }
+    }
+    if (!uploadId) {
+      const session = await this.uploads.createSession({
+        bucket_name: options.bucketName,
+        key: options.key,
+        workspace_name: options.workspaceName ?? null,
+        mime_type: resolveUploadContentType(
+          options.contentType,
+          source.type,
+          options.key,
+          source.name
+        ),
+        file_size: source.size,
+        chunk_size: chunkSize,
+        total_chunks: totalChunks,
+        checksum: typeof options.checksum === "object" ? options.checksum.file ?? null : null,
+        metadata: options.metadata,
+        overwrite: options.overwrite ?? true,
+        visibility: options.visibility ?? null
+      });
+      uploadId = session.upload_id;
+      missingChunks = Array.from({ length: totalChunks }, (_, index) => index);
+      if (resumeKey) await this.resumeStore?.set(resumeKey, uploadId);
+    }
+    for (const index of missingChunks ?? []) {
+      const start = index * chunkSize;
+      const end = source.size === 0 ? 0 : Math.min(source.size, start + chunkSize);
+      const chunk = await source.slice(start, end);
+      const checksum = await this.chunkChecksum(options.checksum, index, chunk.body);
+      const response = await this.uploads.uploadChunk(uploadId, index, chunk.body, checksum, options.signal);
+      options.onProgress?.(chunkResponseToProgress(response));
+    }
+    const complete = await this.uploads.complete(uploadId, { checksum: typeof options.checksum === "object" ? options.checksum.file : void 0 });
+    if (resumeKey) await this.resumeStore?.delete(resumeKey);
+    return {
+      ...complete,
+      uploadId: complete.upload_id,
+      fileId: complete.file_id,
+      publicId: complete.public_id,
+      visibility: complete.visibility,
+      url: complete.url,
+      expiresAt: complete.expires_at ?? null
+    };
+  }
+  async chunkChecksum(checksum, index, body) {
+    if (!checksum) return void 0;
+    if (checksum === "sha256") return sha256Hex(body);
+    return checksum.chunks?.[index];
+  }
+};
+function chunkResponseToProgress(response) {
+  return {
+    uploadId: response.upload_id,
+    chunkIndex: response.chunk_index,
+    uploadedChunks: response.uploaded_chunks,
+    totalChunks: response.total_chunks,
+    uploadedSize: response.uploaded_size,
+    fileSize: response.file_size,
+    progress: response.progress
+  };
+}
+function statusToProgress(response) {
+  return {
+    uploadId: response.upload_id,
+    uploadedChunks: response.uploaded_chunks.length,
+    totalChunks: response.total_chunks,
+    uploadedSize: response.uploaded_size,
+    fileSize: response.file_size,
+    progress: response.progress
+  };
+}
+
+// src/core/client/index.ts
+var UStorageCoreClient = class {
+  uploads;
+  uploader;
+  constructor(options) {
+    const uploadHttp = options.uploadHttpClient ?? new FetchHttpClient({ baseUrl: options.uploadBaseUrl, authHeaders: options.authHeaders });
+    this.uploads = new UploadApi(uploadHttp);
+    this.uploader = new Uploader(this.uploads, options.resumeStore);
+  }
+  async getObjectUrl(input) {
+    const response = await this.uploads.createFileUrl({
+      file_id: input.fileId ?? null,
+      bucket: input.bucket ?? null,
+      bucket_id: input.bucketId ?? null,
+      key: input.key ?? null,
+      path: input.path ?? null,
+      expires_in: input.expiresIn ?? null
+    });
+    return {
+      fileId: response.file_id,
+      publicId: response.public_id,
+      visibility: response.visibility,
+      url: response.url,
+      expiresAt: response.expires_at
+    };
+  }
+  getSignedUrl(input) {
+    return this.getObjectUrl(input);
+  }
+  uploadSource(source, options) {
+    return this.uploader.putObject(source, options);
+  }
+};
+
+// src/core/upload/source.ts
+var MemoryResumeStore = class {
+  values = /* @__PURE__ */ new Map();
+  get(key) {
+    return this.values.get(key);
+  }
+  set(key, uploadId) {
+    this.values.set(key, uploadId);
+  }
+  delete(key) {
+    this.values.delete(key);
+  }
+};
+
+// src/node/node-client.ts
+import { basename as basename2 } from "path";
+
+// src/node/node-upload-source.ts
+import { basename } from "path";
+import { open, stat } from "fs/promises";
+var NodeFileUploadSource = class _NodeFileUploadSource {
+  constructor(path, size, name, type) {
+    this.path = path;
+    this.name = name ?? basename(path);
+    this.size = size;
+    this.type = type;
+  }
+  path;
+  name;
+  size;
+  type;
+  static async fromPath(path, options = {}) {
+    const info = await stat(path);
+    const name = options.name ?? basename(path);
+    return new _NodeFileUploadSource(
+      path,
+      info.size,
+      name,
+      resolveUploadContentType(options.type, void 0, name, path) ?? void 0
+    );
+  }
+  fingerprint(key) {
+    return ["node-file", key ?? "", this.path, this.name, this.size, this.type ?? ""].join(":");
+  }
+  async slice(start, end) {
+    const length = end - start;
+    if (length === 0) return { body: new Uint8Array(), size: 0 };
+    const file = await open(this.path, "r");
+    try {
+      const buffer = Buffer.alloc(length);
+      await file.read(buffer, 0, length, start);
+      const body = new Uint8Array(buffer.buffer, buffer.byteOffset, buffer.byteLength).slice().buffer;
+      return { body, size: buffer.byteLength };
+    } finally {
+      await closeFile(file);
+    }
+  }
+};
+var NodeBufferUploadSource = class {
+  constructor(buffer, name, type) {
+    this.buffer = buffer;
+    this.name = name;
+    this.type = resolveUploadContentType(type, void 0, name) ?? void 0;
+    this.size = buffer.byteLength;
+  }
+  buffer;
+  name;
+  size;
+  type;
+  fingerprint(key) {
+    return ["node-buffer", key ?? "", this.name, this.size, this.type ?? ""].join(":");
+  }
+  slice(start, end) {
+    const buffer = this.buffer.subarray(start, end);
+    const body = new Uint8Array(buffer.buffer, buffer.byteOffset, buffer.byteLength).slice().buffer;
+    return { body, size: buffer.byteLength };
+  }
+};
+async function closeFile(file) {
+  await file.close();
+}
+
+// src/node/node-client.ts
+var UStorageNodeClient = class extends UStorageCoreClient {
+  constructor(options) {
+    super({
+      uploadBaseUrl: options.uploadBaseUrl,
+      resumeStore: options.resumeStore,
+      authHeaders: async () => {
+        if ("accessKey" in options.auth) {
+          return {
+            "x-access-key": options.auth.accessKey,
+            "x-secret-key": options.auth.secretKey
+          };
+        }
+        return { Authorization: `Bearer ${await resolveToken(options.auth.bearerToken)}` };
+      }
+    });
+  }
+  async putObject(options) {
+    if (typeof options.body === "string") {
+      return this.uploadSource(await NodeFileUploadSource.fromPath(options.body, { name: objectName(options.key), type: options.contentType ?? void 0 }), options);
+    }
+    return this.uploadSource(new NodeBufferUploadSource(options.body, objectName(options.key), options.contentType ?? void 0), options);
+  }
+  async uploadFile(path, options) {
+    const key = options.key ?? basename2(path);
+    return this.uploadSource(await NodeFileUploadSource.fromPath(path, { name: objectName(key), type: options.contentType ?? void 0 }), { ...options, key });
+  }
+};
+function objectName(key) {
+  return key.split("/").filter(Boolean).at(-1) ?? key;
+}
+
+// src/node/node-resume-store.ts
+import { readFile, writeFile, rm } from "fs/promises";
+import { dirname } from "path";
+import { mkdir } from "fs/promises";
+var NodeMemoryResumeStore = class extends MemoryResumeStore {
+};
+var NodeFileResumeStore = class {
+  constructor(path) {
+    this.path = path;
+  }
+  path;
+  async get(key) {
+    const values = await this.read();
+    return values[key];
+  }
+  async set(key, uploadId) {
+    const values = await this.read();
+    values[key] = uploadId;
+    await this.write(values);
+  }
+  async delete(key) {
+    const values = await this.read();
+    delete values[key];
+    await this.write(values);
+  }
+  async read() {
+    try {
+      return JSON.parse(await readFile(this.path, "utf8"));
+    } catch {
+      return {};
+    }
+  }
+  async write(values) {
+    await mkdir(dirname(this.path), { recursive: true });
+    await writeFile(this.path, JSON.stringify(values, null, 2));
+  }
+  async clear() {
+    await rm(this.path, { force: true });
+  }
+};
+
+// src/node/node-signer.ts
+var nodeSigner = { supported: false };
+export {
+  FetchHttpClient,
+  MemoryResumeStore,
+  NodeBufferUploadSource,
+  NodeFileResumeStore,
+  NodeFileUploadSource,
+  FetchHttpClient as NodeHttpClient,
+  NodeMemoryResumeStore,
+  UStorageCoreClient,
+  UStorageError,
+  UStorageNodeClient,
+  UploadApi,
+  Uploader,
+  nodeSigner,
+  resolveToken,
+  toUStorageError
+};
+//# sourceMappingURL=index.js.map