@parsrun/storage 0.1.0

package/README.md

@@ -0,0 +1,176 @@
+# @parsrun/storage
+
+Edge-compatible object storage for Pars with S3 and R2 support.
+
+## Features
+
+- **Multi-Adapter**: S3, Cloudflare R2, Memory
+- **Edge-Compatible**: Works on all runtimes
+- **Presigned URLs**: Secure direct uploads
+- **Streaming**: Large file support
+- **Metadata**: File metadata management
+
+## Installation
+
+```bash
+pnpm add @parsrun/storage
+```
+
+## Quick Start
+
+```typescript
+import { createStorage } from '@parsrun/storage';
+
+const storage = createStorage({
+  adapter: 'r2', // or 's3', 'memory'
+  bucket: 'my-bucket',
+});
+
+// Upload file
+await storage.put('uploads/photo.jpg', fileBuffer, {
+  contentType: 'image/jpeg',
+});
+
+// Get file
+const file = await storage.get('uploads/photo.jpg');
+
+// Delete file
+await storage.delete('uploads/photo.jpg');
+```
+
+## API Overview
+
+### Adapters
+
+#### S3
+
+```typescript
+import { createS3Adapter } from '@parsrun/storage/adapters/s3';
+
+const storage = createS3Adapter({
+  region: 'us-east-1',
+  bucket: 'my-bucket',
+  accessKeyId: process.env.AWS_ACCESS_KEY_ID,
+  secretAccessKey: process.env.AWS_SECRET_ACCESS_KEY,
+});
+```
+
+#### Cloudflare R2
+
+```typescript
+import { createR2Adapter } from '@parsrun/storage/adapters/r2';
+
+// In Cloudflare Worker
+const storage = createR2Adapter({
+  bucket: env.MY_BUCKET,
+});
+```
+
+#### Memory (Development)
+
+```typescript
+import { createMemoryAdapter } from '@parsrun/storage/adapters/memory';
+
+const storage = createMemoryAdapter();
+```
+
+### File Operations
+
+```typescript
+// Upload
+await storage.put('path/to/file.txt', 'Hello World', {
+  contentType: 'text/plain',
+  metadata: { uploadedBy: 'user:1' },
+});
+
+// Upload from stream
+await storage.put('path/to/large-file.zip', readableStream, {
+  contentType: 'application/zip',
+});
+
+// Get file
+const file = await storage.get('path/to/file.txt');
+console.log(file.body);      // Content
+console.log(file.metadata);  // Metadata
+console.log(file.size);      // Size in bytes
+
+// Get as stream
+const stream = await storage.getStream('path/to/large-file.zip');
+
+// Check existence
+const exists = await storage.exists('path/to/file.txt');
+
+// Delete
+await storage.delete('path/to/file.txt');
+
+// Delete multiple
+await storage.deleteMany(['file1.txt', 'file2.txt']);
+```
+
+### Listing Files
+
+```typescript
+// List files
+const files = await storage.list('uploads/', {
+  limit: 100,
+  cursor: 'next-page-token',
+});
+
+for (const file of files.objects) {
+  console.log(file.key, file.size, file.lastModified);
+}
+
+// Continue with next page
+if (files.cursor) {
+  const nextPage = await storage.list('uploads/', {
+    cursor: files.cursor,
+  });
+}
+```
+
+### Presigned URLs
+
+```typescript
+// Generate upload URL (PUT)
+const uploadUrl = await storage.getPresignedUrl('uploads/new-file.jpg', {
+  method: 'PUT',
+  expiresIn: 3600, // 1 hour
+  contentType: 'image/jpeg',
+});
+
+// Generate download URL (GET)
+const downloadUrl = await storage.getPresignedUrl('uploads/photo.jpg', {
+  method: 'GET',
+  expiresIn: 3600,
+});
+
+// Client-side upload
+await fetch(uploadUrl, {
+  method: 'PUT',
+  body: file,
+  headers: { 'Content-Type': 'image/jpeg' },
+});
+```
+
+### Copy & Move
+
+```typescript
+// Copy file
+await storage.copy('source/file.txt', 'dest/file.txt');
+
+// Move file
+await storage.move('old/path.txt', 'new/path.txt');
+```
+
+## Exports
+
+```typescript
+import { ... } from '@parsrun/storage';              // Main exports
+import { ... } from '@parsrun/storage/adapters/s3';    // S3 adapter
+import { ... } from '@parsrun/storage/adapters/r2';    // R2 adapter
+import { ... } from '@parsrun/storage/adapters/memory'; // Memory adapter
+```
+
+## License
+
+MIT

package/dist/adapters/memory.d.ts

@@ -0,0 +1,67 @@
+import { a as StorageAdapter, M as MemoryConfig, U as UploadOptions, F as FileMetadata, D as DownloadOptions, d as DeleteResult, B as BatchDeleteResult, L as ListOptions, c as ListResult, C as CopyOptions, P as PresignedUrlOptions } from '../types-CCTK5LsZ.js';
+
+/**
+ * @parsrun/storage - Memory Adapter
+ * In-memory storage adapter for development and testing
+ */
+
+/**
+ * Memory Storage Adapter
+ * Stores files in memory - useful for development and testing
+ *
+ * @example
+ * ```typescript
+ * const storage = new MemoryAdapter({
+ *   type: 'memory',
+ *   bucket: 'test-bucket',
+ * });
+ *
+ * await storage.upload('test.txt', 'Hello, World!');
+ * const data = await storage.download('test.txt');
+ * ```
+ */
+declare class MemoryAdapter implements StorageAdapter {
+    readonly type: "memory";
+    readonly bucket: string;
+    private files;
+    private maxSize;
+    private currentSize;
+    private basePath;
+    constructor(config: MemoryConfig);
+    private getFullKey;
+    private validateKey;
+    private dataToUint8Array;
+    private streamToUint8Array;
+    upload(key: string, data: Uint8Array | ReadableStream<Uint8Array> | Blob | string, options?: UploadOptions): Promise<FileMetadata>;
+    download(key: string, _options?: DownloadOptions): Promise<Uint8Array>;
+    downloadStream(key: string, _options?: DownloadOptions): Promise<ReadableStream<Uint8Array>>;
+    head(key: string): Promise<FileMetadata | null>;
+    exists(key: string): Promise<boolean>;
+    delete(key: string): Promise<DeleteResult>;
+    deleteMany(keys: string[]): Promise<BatchDeleteResult>;
+    list(options?: ListOptions): Promise<ListResult>;
+    copy(sourceKey: string, destKey: string, options?: CopyOptions): Promise<FileMetadata>;
+    move(sourceKey: string, destKey: string): Promise<FileMetadata>;
+    getPresignedUrl(key: string, options?: PresignedUrlOptions): Promise<string>;
+    getUploadUrl(key: string, options?: PresignedUrlOptions): Promise<string>;
+    /**
+     * Clear all files (useful for testing)
+     */
+    clear(): void;
+    /**
+     * Get current storage size
+     */
+    getSize(): number;
+    /**
+     * Get file count
+     */
+    getFileCount(): number;
+    private guessContentType;
+    private generateEtag;
+}
+/**
+ * Create a memory storage adapter
+ */
+declare function createMemoryAdapter(config: Omit<MemoryConfig, "type">): MemoryAdapter;
+
+export { MemoryAdapter, createMemoryAdapter };

package/dist/adapters/memory.js

@@ -0,0 +1,311 @@
+// src/types.ts
+import {
+  type,
+  fileMetadata,
+  uploadOptions,
+  signedUrlOptions,
+  listFilesOptions,
+  listFilesResult,
+  localStorageConfig,
+  s3StorageConfig,
+  r2StorageConfig,
+  gcsStorageConfig,
+  storageProviderConfig
+} from "@parsrun/types";
+var StorageError = class extends Error {
+  constructor(message, code, statusCode, cause) {
+    super(message);
+    this.code = code;
+    this.statusCode = statusCode;
+    this.cause = cause;
+    this.name = "StorageError";
+  }
+};
+var StorageErrorCodes = {
+  NOT_FOUND: "NOT_FOUND",
+  ACCESS_DENIED: "ACCESS_DENIED",
+  BUCKET_NOT_FOUND: "BUCKET_NOT_FOUND",
+  INVALID_KEY: "INVALID_KEY",
+  UPLOAD_FAILED: "UPLOAD_FAILED",
+  DOWNLOAD_FAILED: "DOWNLOAD_FAILED",
+  DELETE_FAILED: "DELETE_FAILED",
+  COPY_FAILED: "COPY_FAILED",
+  LIST_FAILED: "LIST_FAILED",
+  PRESIGN_FAILED: "PRESIGN_FAILED",
+  QUOTA_EXCEEDED: "QUOTA_EXCEEDED",
+  INVALID_CONFIG: "INVALID_CONFIG",
+  ADAPTER_NOT_AVAILABLE: "ADAPTER_NOT_AVAILABLE"
+};
+
+// src/adapters/memory.ts
+var MemoryAdapter = class {
+  type = "memory";
+  bucket;
+  files = /* @__PURE__ */ new Map();
+  maxSize;
+  currentSize = 0;
+  basePath;
+  constructor(config) {
+    this.bucket = config.bucket;
+    this.maxSize = config.maxSize ?? Infinity;
+    this.basePath = config.basePath ?? "";
+  }
+  getFullKey(key) {
+    return this.basePath ? `${this.basePath}/${key}` : key;
+  }
+  validateKey(key) {
+    if (!key || key.includes("..") || key.startsWith("/")) {
+      throw new StorageError(
+        `Invalid key: ${key}`,
+        StorageErrorCodes.INVALID_KEY
+      );
+    }
+  }
+  dataToUint8Array(data) {
+    if (data instanceof Uint8Array) {
+      return data;
+    }
+    if (typeof data === "string") {
+      return new TextEncoder().encode(data);
+    }
+    if (data instanceof Blob) {
+      return data.arrayBuffer().then((buffer) => new Uint8Array(buffer));
+    }
+    return this.streamToUint8Array(data);
+  }
+  async streamToUint8Array(stream) {
+    const reader = stream.getReader();
+    const chunks = [];
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      chunks.push(value);
+    }
+    const totalLength = chunks.reduce((sum, chunk) => sum + chunk.length, 0);
+    const result = new Uint8Array(totalLength);
+    let offset = 0;
+    for (const chunk of chunks) {
+      result.set(chunk, offset);
+      offset += chunk.length;
+    }
+    return result;
+  }
+  async upload(key, data, options) {
+    this.validateKey(key);
+    const fullKey = this.getFullKey(key);
+    const uint8Data = await this.dataToUint8Array(data);
+    const existingFile = this.files.get(fullKey);
+    const sizeDiff = uint8Data.length - (existingFile?.data.length ?? 0);
+    if (this.currentSize + sizeDiff > this.maxSize) {
+      throw new StorageError(
+        "Storage quota exceeded",
+        StorageErrorCodes.QUOTA_EXCEEDED
+      );
+    }
+    const metadata = {
+      key: fullKey,
+      size: uint8Data.length,
+      contentType: options?.contentType ?? this.guessContentType(key),
+      lastModified: /* @__PURE__ */ new Date(),
+      etag: this.generateEtag(uint8Data),
+      metadata: options?.metadata ?? void 0
+    };
+    this.files.set(fullKey, { data: uint8Data, metadata });
+    this.currentSize += sizeDiff;
+    return metadata;
+  }
+  async download(key, _options) {
+    this.validateKey(key);
+    const fullKey = this.getFullKey(key);
+    const file = this.files.get(fullKey);
+    if (!file) {
+      throw new StorageError(
+        `File not found: ${key}`,
+        StorageErrorCodes.NOT_FOUND,
+        404
+      );
+    }
+    return file.data;
+  }
+  async downloadStream(key, _options) {
+    const data = await this.download(key);
+    return new ReadableStream({
+      start(controller) {
+        controller.enqueue(data);
+        controller.close();
+      }
+    });
+  }
+  async head(key) {
+    this.validateKey(key);
+    const fullKey = this.getFullKey(key);
+    const file = this.files.get(fullKey);
+    return file?.metadata ?? null;
+  }
+  async exists(key) {
+    this.validateKey(key);
+    const fullKey = this.getFullKey(key);
+    return this.files.has(fullKey);
+  }
+  async delete(key) {
+    this.validateKey(key);
+    const fullKey = this.getFullKey(key);
+    const file = this.files.get(fullKey);
+    if (file) {
+      this.currentSize -= file.data.length;
+      this.files.delete(fullKey);
+    }
+    return { success: true, key: fullKey };
+  }
+  async deleteMany(keys) {
+    const deleted = [];
+    const errors = [];
+    for (const key of keys) {
+      try {
+        await this.delete(key);
+        deleted.push(this.getFullKey(key));
+      } catch (err) {
+        errors.push({
+          key: this.getFullKey(key),
+          error: err instanceof Error ? err.message : "Unknown error"
+        });
+      }
+    }
+    return { deleted, errors };
+  }
+  async list(options) {
+    const prefix = options?.prefix ? this.getFullKey(options.prefix) : this.basePath;
+    const delimiter = options?.delimiter ?? "/";
+    const maxKeys = options?.maxKeys ?? 1e3;
+    const files = [];
+    const prefixSet = /* @__PURE__ */ new Set();
+    for (const [key, file] of this.files) {
+      if (prefix && !key.startsWith(prefix)) {
+        continue;
+      }
+      const relativePath = prefix ? key.slice(prefix.length) : key;
+      if (delimiter) {
+        const delimiterIndex = relativePath.indexOf(delimiter);
+        if (delimiterIndex !== -1) {
+          const commonPrefix = key.slice(0, prefix.length + delimiterIndex + 1);
+          prefixSet.add(commonPrefix);
+          continue;
+        }
+      }
+      files.push(file.metadata);
+      if (files.length >= maxKeys) {
+        break;
+      }
+    }
+    return {
+      files,
+      prefixes: Array.from(prefixSet),
+      isTruncated: files.length >= maxKeys,
+      continuationToken: void 0
+    };
+  }
+  async copy(sourceKey, destKey, options) {
+    this.validateKey(sourceKey);
+    this.validateKey(destKey);
+    const sourceFullKey = this.getFullKey(sourceKey);
+    const destFullKey = this.getFullKey(destKey);
+    const sourceFile = this.files.get(sourceFullKey);
+    if (!sourceFile) {
+      throw new StorageError(
+        `Source file not found: ${sourceKey}`,
+        StorageErrorCodes.NOT_FOUND,
+        404
+      );
+    }
+    const newMetadata = options?.metadataDirective === "REPLACE" ? {
+      key: destFullKey,
+      size: sourceFile.data.length,
+      contentType: options.contentType ?? sourceFile.metadata.contentType,
+      lastModified: /* @__PURE__ */ new Date(),
+      etag: sourceFile.metadata.etag,
+      metadata: options.metadata ?? void 0
+    } : {
+      ...sourceFile.metadata,
+      key: destFullKey,
+      lastModified: /* @__PURE__ */ new Date()
+    };
+    this.files.set(destFullKey, {
+      data: sourceFile.data,
+      metadata: newMetadata
+    });
+    this.currentSize += sourceFile.data.length;
+    return newMetadata;
+  }
+  async move(sourceKey, destKey) {
+    const metadata = await this.copy(sourceKey, destKey);
+    await this.delete(sourceKey);
+    return metadata;
+  }
+  async getPresignedUrl(key, options) {
+    this.validateKey(key);
+    const fullKey = this.getFullKey(key);
+    const expiresIn = options?.expiresIn ?? 3600;
+    const expires = Date.now() + expiresIn * 1e3;
+    return `memory://${this.bucket}/${fullKey}?expires=${expires}`;
+  }
+  async getUploadUrl(key, options) {
+    return this.getPresignedUrl(key, options);
+  }
+  /**
+   * Clear all files (useful for testing)
+   */
+  clear() {
+    this.files.clear();
+    this.currentSize = 0;
+  }
+  /**
+   * Get current storage size
+   */
+  getSize() {
+    return this.currentSize;
+  }
+  /**
+   * Get file count
+   */
+  getFileCount() {
+    return this.files.size;
+  }
+  guessContentType(key) {
+    const ext = key.split(".").pop()?.toLowerCase();
+    const contentTypes = {
+      txt: "text/plain",
+      html: "text/html",
+      css: "text/css",
+      js: "application/javascript",
+      json: "application/json",
+      xml: "application/xml",
+      pdf: "application/pdf",
+      zip: "application/zip",
+      png: "image/png",
+      jpg: "image/jpeg",
+      jpeg: "image/jpeg",
+      gif: "image/gif",
+      webp: "image/webp",
+      svg: "image/svg+xml",
+      mp3: "audio/mpeg",
+      mp4: "video/mp4",
+      webm: "video/webm"
+    };
+    return contentTypes[ext ?? ""] ?? "application/octet-stream";
+  }
+  generateEtag(data) {
+    let hash = 0;
+    for (const byte of data) {
+      hash = (hash << 5) - hash + byte | 0;
+    }
+    return `"${Math.abs(hash).toString(16)}"`;
+  }
+};
+function createMemoryAdapter(config) {
+  return new MemoryAdapter({ ...config, type: "memory" });
+}
+export {
+  MemoryAdapter,
+  createMemoryAdapter
+};
+//# sourceMappingURL=memory.js.map

package/dist/adapters/memory.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/types.ts","../../src/adapters/memory.ts"],"sourcesContent":["/**\n * @parsrun/storage - Type Definitions\n * Storage abstraction types for edge-compatible storage\n */\n\n// Re-export types from @parsrun/types for convenience\nexport {\n  type,\n  fileMetadata,\n  uploadOptions as parsUploadOptions,\n  signedUrlOptions,\n  listFilesOptions,\n  listFilesResult,\n  localStorageConfig,\n  s3StorageConfig,\n  r2StorageConfig,\n  gcsStorageConfig,\n  storageProviderConfig,\n  type FileMetadata as ParsFileMetadata,\n  type UploadOptions as ParsUploadOptions,\n  type SignedUrlOptions,\n  type ListFilesOptions,\n  type ListFilesResult,\n  type LocalStorageConfig,\n  type S3StorageConfig,\n  type R2StorageConfig,\n  type GcsStorageConfig,\n  type StorageProviderConfig,\n} from \"@parsrun/types\";\n\n/**\n * Storage adapter type\n */\nexport type StorageAdapterType = \"s3\" | \"r2\" | \"do-spaces\" | \"memory\" | \"custom\";\n\n/**\n * File metadata\n */\nexport interface FileMetadata {\n  /** File key/path */\n  key: string;\n  /** File size in bytes */\n  size: number;\n  /** Content type (MIME type) */\n  contentType: string | undefined;\n  /** Last modified date */\n  lastModified: Date | undefined;\n  /** ETag (entity tag) */\n  etag: string | undefined;\n  /** Custom metadata */\n  metadata: Record<string, string> | undefined;\n}\n\n/**\n * Upload options\n */\nexport interface UploadOptions {\n  /** Content type override */\n  contentType?: string | undefined;\n  /** Content disposition */\n  contentDisposition?: string | undefined;\n  /** Cache control header */\n  cacheControl?: string | undefined;\n  /** Content encoding */\n  contentEncoding?: string | undefined;\n  /** Custom metadata */\n  metadata?: Record<string, string> | undefined;\n  /** ACL (access control list) */\n  acl?: \"private\" | \"public-read\" | undefined;\n}\n\n/**\n * Download options\n */\nexport interface DownloadOptions {\n  /** Range start (for partial downloads) */\n  rangeStart?: number | undefined;\n  /** Range end (for partial downloads) */\n  rangeEnd?: number | undefined;\n  /** If-None-Match (ETag) */\n  ifNoneMatch?: string | undefined;\n  /** If-Modified-Since */\n  ifModifiedSince?: Date | undefined;\n}\n\n/**\n * List options\n */\nexport interface ListOptions {\n  /** Prefix to filter by */\n  prefix?: string | undefined;\n  /** Delimiter for hierarchy */\n  delimiter?: string | undefined;\n  /** Maximum keys to return */\n  maxKeys?: number | undefined;\n  /** Continuation token for pagination */\n  continuationToken?: string | undefined;\n}\n\n/**\n * List result\n */\nexport interface ListResult {\n  /** List of files */\n  files: FileMetadata[];\n  /** Common prefixes (for hierarchical listing) */\n  prefixes: string[];\n  /** Whether there are more results */\n  isTruncated: boolean;\n  /** Continuation token for next page */\n  continuationToken: string | undefined;\n}\n\n/**\n * Presigned URL options\n */\nexport interface PresignedUrlOptions {\n  /** URL expiration in seconds (default: 3600) */\n  expiresIn?: number | undefined;\n  /** Content type (for upload URLs) */\n  contentType?: string | undefined;\n  /** Content disposition */\n  contentDisposition?: string | undefined;\n  /** Response cache control */\n  responseCacheControl?: string | undefined;\n  /** Response content type */\n  responseContentType?: string | undefined;\n}\n\n/**\n * Copy options\n */\nexport interface CopyOptions {\n  /** Source bucket (if different from destination) */\n  sourceBucket?: string | undefined;\n  /** Metadata directive */\n  metadataDirective?: \"COPY\" | \"REPLACE\" | undefined;\n  /** New metadata (if REPLACE) */\n  metadata?: Record<string, string> | undefined;\n  /** New content type (if REPLACE) */\n  contentType?: string | undefined;\n}\n\n/**\n * Delete result\n */\nexport interface DeleteResult {\n  /** Whether deletion was successful */\n  success: boolean;\n  /** Deleted key */\n  key: string;\n}\n\n/**\n * Batch delete result\n */\nexport interface BatchDeleteResult {\n  /** Successfully deleted keys */\n  deleted: string[];\n  /** Failed deletions */\n  errors: Array<{ key: string; error: string }>;\n}\n\n/**\n * Storage adapter interface\n * All storage adapters must implement this interface\n */\nexport interface StorageAdapter {\n  /** Adapter type */\n  readonly type: StorageAdapterType;\n\n  /** Bucket name */\n  readonly bucket: string;\n\n  /**\n   * Upload a file\n   * @param key - File key/path\n   * @param data - File data\n   * @param options - Upload options\n   */\n  upload(\n    key: string,\n    data: Uint8Array | ReadableStream<Uint8Array> | Blob | string,\n    options?: UploadOptions\n  ): Promise<FileMetadata>;\n\n  /**\n   * Download a file\n   * @param key - File key/path\n   * @param options - Download options\n   */\n  download(key: string, options?: DownloadOptions): Promise<Uint8Array>;\n\n  /**\n   * Download a file as a stream\n   * @param key - File key/path\n   * @param options - Download options\n   */\n  downloadStream(\n    key: string,\n    options?: DownloadOptions\n  ): Promise<ReadableStream<Uint8Array>>;\n\n  /**\n   * Get file metadata\n   * @param key - File key/path\n   */\n  head(key: string): Promise<FileMetadata | null>;\n\n  /**\n   * Check if file exists\n   * @param key - File key/path\n   */\n  exists(key: string): Promise<boolean>;\n\n  /**\n   * Delete a file\n   * @param key - File key/path\n   */\n  delete(key: string): Promise<DeleteResult>;\n\n  /**\n   * Delete multiple files\n   * @param keys - File keys/paths\n   */\n  deleteMany(keys: string[]): Promise<BatchDeleteResult>;\n\n  /**\n   * List files\n   * @param options - List options\n   */\n  list(options?: ListOptions): Promise<ListResult>;\n\n  /**\n   * Copy a file\n   * @param sourceKey - Source key\n   * @param destKey - Destination key\n   * @param options - Copy options\n   */\n  copy(sourceKey: string, destKey: string, options?: CopyOptions): Promise<FileMetadata>;\n\n  /**\n   * Move/rename a file\n   * @param sourceKey - Source key\n   * @param destKey - Destination key\n   */\n  move(sourceKey: string, destKey: string): Promise<FileMetadata>;\n\n  /**\n   * Generate a presigned URL for download\n   * @param key - File key/path\n   * @param options - URL options\n   */\n  getPresignedUrl(key: string, options?: PresignedUrlOptions): Promise<string>;\n\n  /**\n   * Generate a presigned URL for upload\n   * @param key - File key/path\n   * @param options - URL options\n   */\n  getUploadUrl(key: string, options?: PresignedUrlOptions): Promise<string>;\n}\n\n/**\n * Storage configuration\n */\nexport interface StorageConfig {\n  /** Default bucket name */\n  bucket: string;\n  /** Storage adapter type */\n  type: StorageAdapterType;\n  /** Base path prefix for all operations */\n  basePath?: string | undefined;\n  /** Public URL prefix */\n  publicUrl?: string | undefined;\n}\n\n/**\n * S3 configuration\n */\nexport interface S3Config extends StorageConfig {\n  type: \"s3\" | \"do-spaces\";\n  /** AWS region */\n  region: string;\n  /** Access key ID */\n  accessKeyId: string;\n  /** Secret access key */\n  secretAccessKey: string;\n  /** Custom endpoint (for DO Spaces, MinIO, etc.) */\n  endpoint?: string | undefined;\n  /** Force path style (for MinIO) */\n  forcePathStyle?: boolean | undefined;\n}\n\n/**\n * R2 configuration\n */\nexport interface R2Config extends StorageConfig {\n  type: \"r2\";\n  /** Cloudflare account ID */\n  accountId: string;\n  /** R2 access key ID */\n  accessKeyId: string;\n  /** R2 secret access key */\n  secretAccessKey: string;\n  /** Custom domain for public access */\n  customDomain?: string | undefined;\n}\n\n/**\n * Memory storage configuration (for testing)\n */\nexport interface MemoryConfig extends StorageConfig {\n  type: \"memory\";\n  /** Maximum storage size in bytes */\n  maxSize?: number | undefined;\n}\n\n/**\n * Storage error\n */\nexport class StorageError extends Error {\n  constructor(\n    message: string,\n    public readonly code: string,\n    public readonly statusCode?: number | undefined,\n    public readonly cause?: unknown\n  ) {\n    super(message);\n    this.name = \"StorageError\";\n  }\n}\n\n/**\n * Common storage error codes\n */\nexport const StorageErrorCodes = {\n  NOT_FOUND: \"NOT_FOUND\",\n  ACCESS_DENIED: \"ACCESS_DENIED\",\n  BUCKET_NOT_FOUND: \"BUCKET_NOT_FOUND\",\n  INVALID_KEY: \"INVALID_KEY\",\n  UPLOAD_FAILED: \"UPLOAD_FAILED\",\n  DOWNLOAD_FAILED: \"DOWNLOAD_FAILED\",\n  DELETE_FAILED: \"DELETE_FAILED\",\n  COPY_FAILED: \"COPY_FAILED\",\n  LIST_FAILED: \"LIST_FAILED\",\n  PRESIGN_FAILED: \"PRESIGN_FAILED\",\n  QUOTA_EXCEEDED: \"QUOTA_EXCEEDED\",\n  INVALID_CONFIG: \"INVALID_CONFIG\",\n  ADAPTER_NOT_AVAILABLE: \"ADAPTER_NOT_AVAILABLE\",\n} as const;\n","/**\n * @parsrun/storage - Memory Adapter\n * In-memory storage adapter for development and testing\n */\n\nimport {\n  type BatchDeleteResult,\n  type CopyOptions,\n  type DeleteResult,\n  type DownloadOptions,\n  type FileMetadata,\n  type ListOptions,\n  type ListResult,\n  type MemoryConfig,\n  type PresignedUrlOptions,\n  type StorageAdapter,\n  type UploadOptions,\n  StorageError,\n  StorageErrorCodes,\n} from \"../types.js\";\n\n/**\n * Internal file storage structure\n */\ninterface StoredFile {\n  data: Uint8Array;\n  metadata: FileMetadata;\n}\n\n/**\n * Memory Storage Adapter\n * Stores files in memory - useful for development and testing\n *\n * @example\n * ```typescript\n * const storage = new MemoryAdapter({\n *   type: 'memory',\n *   bucket: 'test-bucket',\n * });\n *\n * await storage.upload('test.txt', 'Hello, World!');\n * const data = await storage.download('test.txt');\n * ```\n */\nexport class MemoryAdapter implements StorageAdapter {\n  readonly type = \"memory\" as const;\n  readonly bucket: string;\n\n  private files: Map<string, StoredFile> = new Map();\n  private maxSize: number;\n  private currentSize = 0;\n  private basePath: string;\n\n  constructor(config: MemoryConfig) {\n    this.bucket = config.bucket;\n    this.maxSize = config.maxSize ?? Infinity;\n    this.basePath = config.basePath ?? \"\";\n  }\n\n  private getFullKey(key: string): string {\n    return this.basePath ? `${this.basePath}/${key}` : key;\n  }\n\n  private validateKey(key: string): void {\n    if (!key || key.includes(\"..\") || key.startsWith(\"/\")) {\n      throw new StorageError(\n        `Invalid key: ${key}`,\n        StorageErrorCodes.INVALID_KEY\n      );\n    }\n  }\n\n  private dataToUint8Array(\n    data: Uint8Array | ReadableStream<Uint8Array> | Blob | string\n  ): Promise<Uint8Array> | Uint8Array {\n    if (data instanceof Uint8Array) {\n      return data;\n    }\n\n    if (typeof data === \"string\") {\n      return new TextEncoder().encode(data);\n    }\n\n    if (data instanceof Blob) {\n      return data.arrayBuffer().then((buffer) => new Uint8Array(buffer));\n    }\n\n    // ReadableStream\n    return this.streamToUint8Array(data);\n  }\n\n  private async streamToUint8Array(\n    stream: ReadableStream<Uint8Array>\n  ): Promise<Uint8Array> {\n    const reader = stream.getReader();\n    const chunks: Uint8Array[] = [];\n\n    while (true) {\n      const { done, value } = await reader.read();\n      if (done) break;\n      chunks.push(value);\n    }\n\n    const totalLength = chunks.reduce((sum, chunk) => sum + chunk.length, 0);\n    const result = new Uint8Array(totalLength);\n    let offset = 0;\n\n    for (const chunk of chunks) {\n      result.set(chunk, offset);\n      offset += chunk.length;\n    }\n\n    return result;\n  }\n\n  async upload(\n    key: string,\n    data: Uint8Array | ReadableStream<Uint8Array> | Blob | string,\n    options?: UploadOptions\n  ): Promise<FileMetadata> {\n    this.validateKey(key);\n    const fullKey = this.getFullKey(key);\n\n    const uint8Data = await this.dataToUint8Array(data);\n\n    // Check quota\n    const existingFile = this.files.get(fullKey);\n    const sizeDiff = uint8Data.length - (existingFile?.data.length ?? 0);\n\n    if (this.currentSize + sizeDiff > this.maxSize) {\n      throw new StorageError(\n        \"Storage quota exceeded\",\n        StorageErrorCodes.QUOTA_EXCEEDED\n      );\n    }\n\n    const metadata: FileMetadata = {\n      key: fullKey,\n      size: uint8Data.length,\n      contentType: options?.contentType ?? this.guessContentType(key),\n      lastModified: new Date(),\n      etag: this.generateEtag(uint8Data),\n      metadata: options?.metadata ?? undefined,\n    };\n\n    this.files.set(fullKey, { data: uint8Data, metadata });\n    this.currentSize += sizeDiff;\n\n    return metadata;\n  }\n\n  async download(key: string, _options?: DownloadOptions): Promise<Uint8Array> {\n    this.validateKey(key);\n    const fullKey = this.getFullKey(key);\n\n    const file = this.files.get(fullKey);\n    if (!file) {\n      throw new StorageError(\n        `File not found: ${key}`,\n        StorageErrorCodes.NOT_FOUND,\n        404\n      );\n    }\n\n    return file.data;\n  }\n\n  async downloadStream(\n    key: string,\n    _options?: DownloadOptions\n  ): Promise<ReadableStream<Uint8Array>> {\n    const data = await this.download(key);\n\n    return new ReadableStream({\n      start(controller) {\n        controller.enqueue(data);\n        controller.close();\n      },\n    });\n  }\n\n  async head(key: string): Promise<FileMetadata | null> {\n    this.validateKey(key);\n    const fullKey = this.getFullKey(key);\n\n    const file = this.files.get(fullKey);\n    return file?.metadata ?? null;\n  }\n\n  async exists(key: string): Promise<boolean> {\n    this.validateKey(key);\n    const fullKey = this.getFullKey(key);\n    return this.files.has(fullKey);\n  }\n\n  async delete(key: string): Promise<DeleteResult> {\n    this.validateKey(key);\n    const fullKey = this.getFullKey(key);\n\n    const file = this.files.get(fullKey);\n    if (file) {\n      this.currentSize -= file.data.length;\n      this.files.delete(fullKey);\n    }\n\n    return { success: true, key: fullKey };\n  }\n\n  async deleteMany(keys: string[]): Promise<BatchDeleteResult> {\n    const deleted: string[] = [];\n    const errors: Array<{ key: string; error: string }> = [];\n\n    for (const key of keys) {\n      try {\n        await this.delete(key);\n        deleted.push(this.getFullKey(key));\n      } catch (err) {\n        errors.push({\n          key: this.getFullKey(key),\n          error: err instanceof Error ? err.message : \"Unknown error\",\n        });\n      }\n    }\n\n    return { deleted, errors };\n  }\n\n  async list(options?: ListOptions): Promise<ListResult> {\n    const prefix = options?.prefix\n      ? this.getFullKey(options.prefix)\n      : this.basePath;\n    const delimiter = options?.delimiter ?? \"/\";\n    const maxKeys = options?.maxKeys ?? 1000;\n\n    const files: FileMetadata[] = [];\n    const prefixSet = new Set<string>();\n\n    for (const [key, file] of this.files) {\n      if (prefix && !key.startsWith(prefix)) {\n        continue;\n      }\n\n      const relativePath = prefix ? key.slice(prefix.length) : key;\n\n      // Handle delimiter for hierarchical listing\n      if (delimiter) {\n        const delimiterIndex = relativePath.indexOf(delimiter);\n        if (delimiterIndex !== -1) {\n          const commonPrefix = key.slice(0, prefix.length + delimiterIndex + 1);\n          prefixSet.add(commonPrefix);\n          continue;\n        }\n      }\n\n      files.push(file.metadata);\n\n      if (files.length >= maxKeys) {\n        break;\n      }\n    }\n\n    return {\n      files,\n      prefixes: Array.from(prefixSet),\n      isTruncated: files.length >= maxKeys,\n      continuationToken: undefined,\n    };\n  }\n\n  async copy(\n    sourceKey: string,\n    destKey: string,\n    options?: CopyOptions\n  ): Promise<FileMetadata> {\n    this.validateKey(sourceKey);\n    this.validateKey(destKey);\n\n    const sourceFullKey = this.getFullKey(sourceKey);\n    const destFullKey = this.getFullKey(destKey);\n\n    const sourceFile = this.files.get(sourceFullKey);\n    if (!sourceFile) {\n      throw new StorageError(\n        `Source file not found: ${sourceKey}`,\n        StorageErrorCodes.NOT_FOUND,\n        404\n      );\n    }\n\n    const newMetadata: FileMetadata =\n      options?.metadataDirective === \"REPLACE\"\n        ? {\n            key: destFullKey,\n            size: sourceFile.data.length,\n            contentType: options.contentType ?? sourceFile.metadata.contentType,\n            lastModified: new Date(),\n            etag: sourceFile.metadata.etag,\n            metadata: options.metadata ?? undefined,\n          }\n        : {\n            ...sourceFile.metadata,\n            key: destFullKey,\n            lastModified: new Date(),\n          };\n\n    this.files.set(destFullKey, {\n      data: sourceFile.data,\n      metadata: newMetadata,\n    });\n    this.currentSize += sourceFile.data.length;\n\n    return newMetadata;\n  }\n\n  async move(sourceKey: string, destKey: string): Promise<FileMetadata> {\n    const metadata = await this.copy(sourceKey, destKey);\n    await this.delete(sourceKey);\n    return metadata;\n  }\n\n  async getPresignedUrl(\n    key: string,\n    options?: PresignedUrlOptions\n  ): Promise<string> {\n    this.validateKey(key);\n    const fullKey = this.getFullKey(key);\n\n    // Memory adapter doesn't support real presigned URLs\n    // Return a fake URL for testing purposes\n    const expiresIn = options?.expiresIn ?? 3600;\n    const expires = Date.now() + expiresIn * 1000;\n\n    return `memory://${this.bucket}/${fullKey}?expires=${expires}`;\n  }\n\n  async getUploadUrl(\n    key: string,\n    options?: PresignedUrlOptions\n  ): Promise<string> {\n    return this.getPresignedUrl(key, options);\n  }\n\n  /**\n   * Clear all files (useful for testing)\n   */\n  clear(): void {\n    this.files.clear();\n    this.currentSize = 0;\n  }\n\n  /**\n   * Get current storage size\n   */\n  getSize(): number {\n    return this.currentSize;\n  }\n\n  /**\n   * Get file count\n   */\n  getFileCount(): number {\n    return this.files.size;\n  }\n\n  private guessContentType(key: string): string {\n    const ext = key.split(\".\").pop()?.toLowerCase();\n    const contentTypes: Record<string, string> = {\n      txt: \"text/plain\",\n      html: \"text/html\",\n      css: \"text/css\",\n      js: \"application/javascript\",\n      json: \"application/json\",\n      xml: \"application/xml\",\n      pdf: \"application/pdf\",\n      zip: \"application/zip\",\n      png: \"image/png\",\n      jpg: \"image/jpeg\",\n      jpeg: \"image/jpeg\",\n      gif: \"image/gif\",\n      webp: \"image/webp\",\n      svg: \"image/svg+xml\",\n      mp3: \"audio/mpeg\",\n      mp4: \"video/mp4\",\n      webm: \"video/webm\",\n    };\n    return contentTypes[ext ?? \"\"] ?? \"application/octet-stream\";\n  }\n\n  private generateEtag(data: Uint8Array): string {\n    // Simple hash for testing - not cryptographically secure\n    let hash = 0;\n    for (const byte of data) {\n      hash = ((hash << 5) - hash + byte) | 0;\n    }\n    return `\"${Math.abs(hash).toString(16)}\"`;\n  }\n}\n\n/**\n * Create a memory storage adapter\n */\nexport function createMemoryAdapter(\n  config: Omit<MemoryConfig, \"type\">\n): MemoryAdapter {\n  return new MemoryAdapter({ ...config, type: \"memory\" });\n}\n"],"mappings":";AAMA;AAAA,EACE;AAAA,EACA;AAAA,EACiB;AAAA,EACjB;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,OAWK;AAqSA,IAAM,eAAN,cAA2B,MAAM;AAAA,EACtC,YACE,SACgB,MACA,YACA,OAChB;AACA,UAAM,OAAO;AAJG;AACA;AACA;AAGhB,SAAK,OAAO;AAAA,EACd;AACF;AAKO,IAAM,oBAAoB;AAAA,EAC/B,WAAW;AAAA,EACX,eAAe;AAAA,EACf,kBAAkB;AAAA,EAClB,aAAa;AAAA,EACb,eAAe;AAAA,EACf,iBAAiB;AAAA,EACjB,eAAe;AAAA,EACf,aAAa;AAAA,EACb,aAAa;AAAA,EACb,gBAAgB;AAAA,EAChB,gBAAgB;AAAA,EAChB,gBAAgB;AAAA,EAChB,uBAAuB;AACzB;;;AClTO,IAAM,gBAAN,MAA8C;AAAA,EAC1C,OAAO;AAAA,EACP;AAAA,EAED,QAAiC,oBAAI,IAAI;AAAA,EACzC;AAAA,EACA,cAAc;AAAA,EACd;AAAA,EAER,YAAY,QAAsB;AAChC,SAAK,SAAS,OAAO;AACrB,SAAK,UAAU,OAAO,WAAW;AACjC,SAAK,WAAW,OAAO,YAAY;AAAA,EACrC;AAAA,EAEQ,WAAW,KAAqB;AACtC,WAAO,KAAK,WAAW,GAAG,KAAK,QAAQ,IAAI,GAAG,KAAK;AAAA,EACrD;AAAA,EAEQ,YAAY,KAAmB;AACrC,QAAI,CAAC,OAAO,IAAI,SAAS,IAAI,KAAK,IAAI,WAAW,GAAG,GAAG;AACrD,YAAM,IAAI;AAAA,QACR,gBAAgB,GAAG;AAAA,QACnB,kBAAkB;AAAA,MACpB;AAAA,IACF;AAAA,EACF;AAAA,EAEQ,iBACN,MACkC;AAClC,QAAI,gBAAgB,YAAY;AAC9B,aAAO;AAAA,IACT;AAEA,QAAI,OAAO,SAAS,UAAU;AAC5B,aAAO,IAAI,YAAY,EAAE,OAAO,IAAI;AAAA,IACtC;AAEA,QAAI,gBAAgB,MAAM;AACxB,aAAO,KAAK,YAAY,EAAE,KAAK,CAAC,WAAW,IAAI,WAAW,MAAM,CAAC;AAAA,IACnE;AAGA,WAAO,KAAK,mBAAmB,IAAI;AAAA,EACrC;AAAA,EAEA,MAAc,mBACZ,QACqB;AACrB,UAAM,SAAS,OAAO,UAAU;AAChC,UAAM,SAAuB,CAAC;AAE9B,WAAO,MAAM;AACX,YAAM,EAAE,MAAM,MAAM,IAAI,MAAM,OAAO,KAAK;AAC1C,UAAI,KAAM;AACV,aAAO,KAAK,KAAK;AAAA,IACnB;AAEA,UAAM,cAAc,OAAO,OAAO,CAAC,KAAK,UAAU,MAAM,MAAM,QAAQ,CAAC;AACvE,UAAM,SAAS,IAAI,WAAW,WAAW;AACzC,QAAI,SAAS;AAEb,eAAW,SAAS,QAAQ;AAC1B,aAAO,IAAI,OAAO,MAAM;AACxB,gBAAU,MAAM;AAAA,IAClB;AAEA,WAAO;AAAA,EACT;AAAA,EAEA,MAAM,OACJ,KACA,MACA,SACuB;AACvB,SAAK,YAAY,GAAG;AACpB,UAAM,UAAU,KAAK,WAAW,GAAG;AAEnC,UAAM,YAAY,MAAM,KAAK,iBAAiB,IAAI;AAGlD,UAAM,eAAe,KAAK,MAAM,IAAI,OAAO;AAC3C,UAAM,WAAW,UAAU,UAAU,cAAc,KAAK,UAAU;AAElE,QAAI,KAAK,cAAc,WAAW,KAAK,SAAS;AAC9C,YAAM,IAAI;AAAA,QACR;AAAA,QACA,kBAAkB;AAAA,MACpB;AAAA,IACF;AAEA,UAAM,WAAyB;AAAA,MAC7B,KAAK;AAAA,MACL,MAAM,UAAU;AAAA,MAChB,aAAa,SAAS,eAAe,KAAK,iBAAiB,GAAG;AAAA,MAC9D,cAAc,oBAAI,KAAK;AAAA,MACvB,MAAM,KAAK,aAAa,SAAS;AAAA,MACjC,UAAU,SAAS,YAAY;AAAA,IACjC;AAEA,SAAK,MAAM,IAAI,SAAS,EAAE,MAAM,WAAW,SAAS,CAAC;AACrD,SAAK,eAAe;AAEpB,WAAO;AAAA,EACT;AAAA,EAEA,MAAM,SAAS,KAAa,UAAiD;AAC3E,SAAK,YAAY,GAAG;AACpB,UAAM,UAAU,KAAK,WAAW,GAAG;AAEnC,UAAM,OAAO,KAAK,MAAM,IAAI,OAAO;AACnC,QAAI,CAAC,MAAM;AACT,YAAM,IAAI;AAAA,QACR,mBAAmB,GAAG;AAAA,QACtB,kBAAkB;AAAA,QAClB;AAAA,MACF;AAAA,IACF;AAEA,WAAO,KAAK;AAAA,EACd;AAAA,EAEA,MAAM,eACJ,KACA,UACqC;AACrC,UAAM,OAAO,MAAM,KAAK,SAAS,GAAG;AAEpC,WAAO,IAAI,eAAe;AAAA,MACxB,MAAM,YAAY;AAChB,mBAAW,QAAQ,IAAI;AACvB,mBAAW,MAAM;AAAA,MACnB;AAAA,IACF,CAAC;AAAA,EACH;AAAA,EAEA,MAAM,KAAK,KAA2C;AACpD,SAAK,YAAY,GAAG;AACpB,UAAM,UAAU,KAAK,WAAW,GAAG;AAEnC,UAAM,OAAO,KAAK,MAAM,IAAI,OAAO;AACnC,WAAO,MAAM,YAAY;AAAA,EAC3B;AAAA,EAEA,MAAM,OAAO,KAA+B;AAC1C,SAAK,YAAY,GAAG;AACpB,UAAM,UAAU,KAAK,WAAW,GAAG;AACnC,WAAO,KAAK,MAAM,IAAI,OAAO;AAAA,EAC/B;AAAA,EAEA,MAAM,OAAO,KAAoC;AAC/C,SAAK,YAAY,GAAG;AACpB,UAAM,UAAU,KAAK,WAAW,GAAG;AAEnC,UAAM,OAAO,KAAK,MAAM,IAAI,OAAO;AACnC,QAAI,MAAM;AACR,WAAK,eAAe,KAAK,KAAK;AAC9B,WAAK,MAAM,OAAO,OAAO;AAAA,IAC3B;AAEA,WAAO,EAAE,SAAS,MAAM,KAAK,QAAQ;AAAA,EACvC;AAAA,EAEA,MAAM,WAAW,MAA4C;AAC3D,UAAM,UAAoB,CAAC;AAC3B,UAAM,SAAgD,CAAC;AAEvD,eAAW,OAAO,MAAM;AACtB,UAAI;AACF,cAAM,KAAK,OAAO,GAAG;AACrB,gBAAQ,KAAK,KAAK,WAAW,GAAG,CAAC;AAAA,MACnC,SAAS,KAAK;AACZ,eAAO,KAAK;AAAA,UACV,KAAK,KAAK,WAAW,GAAG;AAAA,UACxB,OAAO,eAAe,QAAQ,IAAI,UAAU;AAAA,QAC9C,CAAC;AAAA,MACH;AAAA,IACF;AAEA,WAAO,EAAE,SAAS,OAAO;AAAA,EAC3B;AAAA,EAEA,MAAM,KAAK,SAA4C;AACrD,UAAM,SAAS,SAAS,SACpB,KAAK,WAAW,QAAQ,MAAM,IAC9B,KAAK;AACT,UAAM,YAAY,SAAS,aAAa;AACxC,UAAM,UAAU,SAAS,WAAW;AAEpC,UAAM,QAAwB,CAAC;AAC/B,UAAM,YAAY,oBAAI,IAAY;AAElC,eAAW,CAAC,KAAK,IAAI,KAAK,KAAK,OAAO;AACpC,UAAI,UAAU,CAAC,IAAI,WAAW,MAAM,GAAG;AACrC;AAAA,MACF;AAEA,YAAM,eAAe,SAAS,IAAI,MAAM,OAAO,MAAM,IAAI;AAGzD,UAAI,WAAW;AACb,cAAM,iBAAiB,aAAa,QAAQ,SAAS;AACrD,YAAI,mBAAmB,IAAI;AACzB,gBAAM,eAAe,IAAI,MAAM,GAAG,OAAO,SAAS,iBAAiB,CAAC;AACpE,oBAAU,IAAI,YAAY;AAC1B;AAAA,QACF;AAAA,MACF;AAEA,YAAM,KAAK,KAAK,QAAQ;AAExB,UAAI,MAAM,UAAU,SAAS;AAC3B;AAAA,MACF;AAAA,IACF;AAEA,WAAO;AAAA,MACL;AAAA,MACA,UAAU,MAAM,KAAK,SAAS;AAAA,MAC9B,aAAa,MAAM,UAAU;AAAA,MAC7B,mBAAmB;AAAA,IACrB;AAAA,EACF;AAAA,EAEA,MAAM,KACJ,WACA,SACA,SACuB;AACvB,SAAK,YAAY,SAAS;AAC1B,SAAK,YAAY,OAAO;AAExB,UAAM,gBAAgB,KAAK,WAAW,SAAS;AAC/C,UAAM,cAAc,KAAK,WAAW,OAAO;AAE3C,UAAM,aAAa,KAAK,MAAM,IAAI,aAAa;AAC/C,QAAI,CAAC,YAAY;AACf,YAAM,IAAI;AAAA,QACR,0BAA0B,SAAS;AAAA,QACnC,kBAAkB;AAAA,QAClB;AAAA,MACF;AAAA,IACF;AAEA,UAAM,cACJ,SAAS,sBAAsB,YAC3B;AAAA,MACE,KAAK;AAAA,MACL,MAAM,WAAW,KAAK;AAAA,MACtB,aAAa,QAAQ,eAAe,WAAW,SAAS;AAAA,MACxD,cAAc,oBAAI,KAAK;AAAA,MACvB,MAAM,WAAW,SAAS;AAAA,MAC1B,UAAU,QAAQ,YAAY;AAAA,IAChC,IACA;AAAA,MACE,GAAG,WAAW;AAAA,MACd,KAAK;AAAA,MACL,cAAc,oBAAI,KAAK;AAAA,IACzB;AAEN,SAAK,MAAM,IAAI,aAAa;AAAA,MAC1B,MAAM,WAAW;AAAA,MACjB,UAAU;AAAA,IACZ,CAAC;AACD,SAAK,eAAe,WAAW,KAAK;AAEpC,WAAO;AAAA,EACT;AAAA,EAEA,MAAM,KAAK,WAAmB,SAAwC;AACpE,UAAM,WAAW,MAAM,KAAK,KAAK,WAAW,OAAO;AACnD,UAAM,KAAK,OAAO,SAAS;AAC3B,WAAO;AAAA,EACT;AAAA,EAEA,MAAM,gBACJ,KACA,SACiB;AACjB,SAAK,YAAY,GAAG;AACpB,UAAM,UAAU,KAAK,WAAW,GAAG;AAInC,UAAM,YAAY,SAAS,aAAa;AACxC,UAAM,UAAU,KAAK,IAAI,IAAI,YAAY;AAEzC,WAAO,YAAY,KAAK,MAAM,IAAI,OAAO,YAAY,OAAO;AAAA,EAC9D;AAAA,EAEA,MAAM,aACJ,KACA,SACiB;AACjB,WAAO,KAAK,gBAAgB,KAAK,OAAO;AAAA,EAC1C;AAAA;AAAA;AAAA;AAAA,EAKA,QAAc;AACZ,SAAK,MAAM,MAAM;AACjB,SAAK,cAAc;AAAA,EACrB;AAAA;AAAA;AAAA;AAAA,EAKA,UAAkB;AAChB,WAAO,KAAK;AAAA,EACd;AAAA;AAAA;AAAA;AAAA,EAKA,eAAuB;AACrB,WAAO,KAAK,MAAM;AAAA,EACpB;AAAA,EAEQ,iBAAiB,KAAqB;AAC5C,UAAM,MAAM,IAAI,MAAM,GAAG,EAAE,IAAI,GAAG,YAAY;AAC9C,UAAM,eAAuC;AAAA,MAC3C,KAAK;AAAA,MACL,MAAM;AAAA,MACN,KAAK;AAAA,MACL,IAAI;AAAA,MACJ,MAAM;AAAA,MACN,KAAK;AAAA,MACL,KAAK;AAAA,MACL,KAAK;AAAA,MACL,KAAK;AAAA,MACL,KAAK;AAAA,MACL,MAAM;AAAA,MACN,KAAK;AAAA,MACL,MAAM;AAAA,MACN,KAAK;AAAA,MACL,KAAK;AAAA,MACL,KAAK;AAAA,MACL,MAAM;AAAA,IACR;AACA,WAAO,aAAa,OAAO,EAAE,KAAK;AAAA,EACpC;AAAA,EAEQ,aAAa,MAA0B;AAE7C,QAAI,OAAO;AACX,eAAW,QAAQ,MAAM;AACvB,cAAS,QAAQ,KAAK,OAAO,OAAQ;AAAA,IACvC;AACA,WAAO,IAAI,KAAK,IAAI,IAAI,EAAE,SAAS,EAAE,CAAC;AAAA,EACxC;AACF;AAKO,SAAS,oBACd,QACe;AACf,SAAO,IAAI,cAAc,EAAE,GAAG,QAAQ,MAAM,SAAS,CAAC;AACxD;","names":[]}