@nest-toolbox/typeorm-soft-delete 1.8.0

package/README.md

@@ -0,0 +1,540 @@
+# @nest-toolbox/typeorm-soft-delete
+
+Soft delete utilities for TypeORM with enhanced developer experience.
+
+## Features
+
+- 🎯 **Function-based API** following TypeORM patterns
+- 🔧 **Optional method-based wrapper** for enhanced DX
+- 🔍 **Query utilities** for finding deleted records
+- 📊 **Pagination integration** with `@nest-toolbox/typeorm-paginate`
+- 🎨 **TypeScript-first** with full type safety
+- ✅ **Well-tested** with 90%+ coverage
+
+## Installation
+
+```bash
+npm install @nest-toolbox/typeorm-soft-delete typeorm reflect-metadata
+```
+
+## Quick Start
+
+### 1. Setup Your Entity
+
+```typescript
+import { Entity, PrimaryGeneratedColumn, Column, DeleteDateColumn } from 'typeorm';
+import { SoftDeletable } from '@nest-toolbox/typeorm-soft-delete';
+
+@Entity()
+@SoftDeletable() // Optional decorator for metadata
+export class User {
+  @PrimaryGeneratedColumn()
+  id: number;
+
+  @Column()
+  name: string;
+
+  @Column()
+  email: string;
+
+  @DeleteDateColumn() // Required - TypeORM's built-in soft delete column
+  deletedAt?: Date;
+}
+```
+
+### 2. Use Soft Delete Functions (Recommended)
+
+```typescript
+import { softDelete, restore, findOnlyDeleted } from '@nest-toolbox/typeorm-soft-delete';
+import { Repository } from 'typeorm';
+import { InjectRepository } from '@nestjs/typeorm';
+
+@Injectable()
+export class UserService {
+  constructor(
+    @InjectRepository(User)
+    private userRepository: Repository<User>,
+  ) {}
+
+  async deleteUser(id: number) {
+    // Soft delete by ID
+    const result = await softDelete(this.userRepository, id);
+    console.log(`Soft deleted ${result.affected} user(s)`);
+  }
+
+  async restoreUser(id: number) {
+    // Restore soft-deleted user
+    await restore(this.userRepository, id);
+  }
+
+  async getDeletedUsers() {
+    // Find only deleted users
+    return findOnlyDeleted(this.userRepository);
+  }
+}
+```
+
+### 3. Alternative: Method-Based API (Optional)
+
+```typescript
+import { withSoftDelete } from '@nest-toolbox/typeorm-soft-delete';
+
+@Injectable()
+export class UserService {
+  private userRepo: SoftDeleteRepository<User>;
+
+  constructor(
+    @InjectRepository(User)
+    private userRepository: Repository<User>,
+  ) {
+    this.userRepo = withSoftDelete(userRepository);
+  }
+
+  async deleteUser(id: number) {
+    await this.userRepo.softDelete(id);
+  }
+
+  async restoreUser(id: number) {
+    await this.userRepo.restore(id);
+  }
+}
+```
+
+## API Reference
+
+### Core Functions
+
+#### `softDelete(repository, criteria, options?)`
+
+Soft delete entities by setting `deletedAt` to current timestamp.
+
+**Parameters:**
+- `repository: Repository<T>` - TypeORM repository
+- `criteria: string | number | array | FindOptionsWhere<T>` - Entity ID(s) or where clause
+- `options?: { validateExists?: boolean }` - Optional validation
+
+**Returns:** `Promise<{ affected: number }>`
+
+**Examples:**
+
+```typescript
+// Single ID
+await softDelete(repo, 123);
+
+// Multiple IDs
+await softDelete(repo, [1, 2, 3]);
+
+// Where clause
+await softDelete(repo, { email: 'test@example.com' });
+
+// With validation
+await softDelete(repo, 123, { validateExists: true });
+```
+
+#### `restore(repository, criteria, options?)`
+
+Restore soft-deleted entities by setting `deletedAt` back to null.
+
+**Parameters:** Same as `softDelete()`
+
+**Returns:** `Promise<{ affected: number }>`
+
+**Examples:**
+
+```typescript
+// Restore single user
+await restore(userRepo, 123);
+
+// Restore multiple users
+await restore(userRepo, [1, 2, 3]);
+
+// Restore with validation
+await restore(userRepo, 123, { validateExists: true });
+```
+
+#### `forceDelete(repository, criteria)`
+
+Permanently delete soft-deleted entities (hard delete). Only deletes records where `deletedAt IS NOT NULL`.
+
+**Safety:** This prevents accidentally hard-deleting active records.
+
+**Examples:**
+
+```typescript
+// Permanently delete soft-deleted user
+await forceDelete(userRepo, 123);
+
+// Permanently delete multiple
+await forceDelete(userRepo, [1, 2, 3]);
+```
+
+#### `findWithDeleted(repository, options?)`
+
+Find entities including soft-deleted ones.
+
+**Examples:**
+
+```typescript
+// Find all users including deleted
+const allUsers = await findWithDeleted(userRepo);
+
+// Find with additional options
+const users = await findWithDeleted(userRepo, {
+  where: { role: 'admin' },
+  take: 10,
+});
+```
+
+#### `findOnlyDeleted(repository, options?)`
+
+Find only soft-deleted entities.
+
+**Examples:**
+
+```typescript
+// Find all deleted users
+const deletedUsers = await findOnlyDeleted(userRepo);
+
+// Find deleted with filter
+const deletedAdmins = await findOnlyDeleted(userRepo, {
+  where: { role: 'admin' },
+});
+```
+
+#### `count(repository, options?)`
+
+Count entities with optional inclusion of soft-deleted.
+
+**Examples:**
+
+```typescript
+// Count active users
+const activeCount = await count(userRepo);
+
+// Count all users including deleted
+const totalCount = await count(userRepo, { includeDeleted: true });
+
+// Count with filter
+const adminCount = await count(userRepo, {
+  where: { role: 'admin' },
+  includeDeleted: false,
+});
+```
+
+#### `isSoftDeleted(repository, id)`
+
+Check if entity is soft-deleted.
+
+**Examples:**
+
+```typescript
+if (await isSoftDeleted(userRepo, 123)) {
+  console.log('User is deleted');
+}
+```
+
+### Pagination Integration
+
+Works seamlessly with `@nest-toolbox/typeorm-paginate`:
+
+```typescript
+import { rowsWithDeleted, rowsOnlyDeleted } from '@nest-toolbox/typeorm-soft-delete';
+
+// Paginate excluding deleted (default)
+for await (const row of rowsWithDeleted({
+  repository: userRepo,
+  where: {},
+  limit: 100,
+})) {
+  console.log(row.data, row.progress);
+}
+
+// Paginate including deleted
+for await (const row of rowsWithDeleted({
+  repository: userRepo,
+  where: {},
+  includeDeleted: true,
+})) {
+  console.log(row.data);
+}
+
+// Paginate only deleted
+for await (const row of rowsOnlyDeleted({
+  repository: userRepo,
+  where: {},
+})) {
+  console.log('Deleted:', row.data);
+}
+```
+
+### Optional Repository Wrapper
+
+For those who prefer method-based API:
+
+```typescript
+import { withSoftDelete, SoftDeleteRepository } from '@nest-toolbox/typeorm-soft-delete';
+
+const userRepo: SoftDeleteRepository<User> = withSoftDelete(userRepository);
+
+// All soft delete methods
+await userRepo.softDelete(123);
+await userRepo.restore(123);
+await userRepo.forceDelete(123);
+const deleted = await userRepo.findOnlyDeleted();
+const all = await userRepo.findWithDeleted();
+const isDeleted = await userRepo.isSoftDeleted(123);
+
+// Standard repository methods still work
+const users = await userRepo.find({ where: { active: true } });
+const user = await userRepo.findOne({ where: { id: 1 } });
+await userRepo.save(newUser);
+```
+
+## Database Setup
+
+Ensure your database table has a `deletedAt` column:
+
+```sql
+CREATE TABLE users (
+  id SERIAL PRIMARY KEY,
+  name VARCHAR(255) NOT NULL,
+  email VARCHAR(255) NOT NULL,
+  deleted_at TIMESTAMP NULL, -- NULL = active, NOT NULL = deleted
+  created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+  updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+);
+
+-- Recommended: Index for performance
+CREATE INDEX idx_users_deleted_at ON users(deleted_at);
+```
+
+TypeORM will automatically handle the column when you use `@DeleteDateColumn()`:
+
+```typescript
+@Entity()
+export class User {
+  @PrimaryGeneratedColumn()
+  id: number;
+
+  @Column()
+  name: string;
+
+  @DeleteDateColumn() // Creates nullable timestamp column
+  deletedAt?: Date;
+}
+```
+
+## Best Practices
+
+### 1. Always Use @DeleteDateColumn
+
+The package requires entities to have `@DeleteDateColumn()` decorator:
+
+```typescript
+@Entity()
+export class User {
+  @DeleteDateColumn()
+  deletedAt?: Date; // Required for soft delete functionality
+}
+```
+
+### 2. Add Database Index
+
+Index the `deletedAt` column for better query performance:
+
+```sql
+CREATE INDEX idx_table_deleted_at ON your_table(deleted_at);
+```
+
+### 3. Use forceDelete() Carefully
+
+Permanent deletion cannot be undone. The package only allows force deletion of already soft-deleted records as a safety measure:
+
+```typescript
+// Safe: Only permanently deletes records that are already soft-deleted
+await forceDelete(repo, id);
+```
+
+### 4. Consider Cascading
+
+Soft delete related entities to maintain referential integrity:
+
+```typescript
+async deleteUserWithPosts(userId: number) {
+  // Soft delete user
+  await softDelete(userRepo, userId);
+
+  // Soft delete user's posts
+  await softDelete(postRepo, { userId });
+}
+```
+
+### 5. Regular Cleanup
+
+Schedule jobs to permanently delete old soft-deleted records:
+
+```typescript
+@Cron('0 0 * * *') // Daily at midnight
+async cleanupOldDeleted() {
+  const thirtyDaysAgo = new Date();
+  thirtyDaysAgo.setDate(thirtyDaysAgo.getDate() - 30);
+
+  const oldDeleted = await findOnlyDeleted(userRepo, {
+    where: { deletedAt: LessThan(thirtyDaysAgo) },
+  });
+
+  for (const user of oldDeleted) {
+    await forceDelete(userRepo, user.id);
+  }
+}
+```
+
+## Migration from TypeORM Built-in
+
+TypeORM has basic soft delete support via `repository.softDelete()`. This package provides enhanced functionality:
+
+**TypeORM Built-in:**
+- ✅ Basic soft delete with `softDelete(id)`
+- ❌ No restore functionality
+- ❌ No query utilities for deleted records
+- ❌ No pagination integration
+- ❌ Limited type safety
+
+**This Package:**
+- ✅ Enhanced soft delete operations
+- ✅ Restore functionality
+- ✅ Query utilities (`findOnlyDeleted`, `findWithDeleted`)
+- ✅ Pagination integration
+- ✅ Better type safety and validation
+- ✅ Safety checks (forceDelete only deletes soft-deleted records)
+
+**Before:**
+
+```typescript
+await repository.softDelete(id);
+const deleted = await repository.find({ withDeleted: true });
+```
+
+**After:**
+
+```typescript
+await softDelete(repository, id);
+const deleted = await findOnlyDeleted(repository);
+
+// Or restore them
+await restore(repository, id);
+```
+
+## Advanced Usage
+
+### Batch Operations
+
+Process large numbers of records efficiently:
+
+```typescript
+const userIds = [1, 2, 3, 4, 5, /* ... hundreds more */];
+
+// Soft delete in bulk
+const result = await softDelete(userRepo, userIds);
+console.log(`Deleted ${result.affected} users`);
+```
+
+### Conditional Soft Delete
+
+Use `FindOptionsWhere` for complex conditions:
+
+```typescript
+// Soft delete all inactive users
+await softDelete(userRepo, { active: false });
+
+// Soft delete users by email domain
+await softDelete(userRepo, { email: Like('%@old-domain.com') });
+```
+
+### Validation
+
+Ensure entities exist before deletion:
+
+```typescript
+try {
+  await softDelete(userRepo, 999, { validateExists: true });
+} catch (error) {
+  console.error('User not found or already deleted');
+}
+```
+
+## TypeScript Support
+
+Full TypeScript support with strict typing:
+
+```typescript
+import type {
+  SoftDeleteCriteria,
+  SoftDeleteResult,
+  SoftDeleteOptions,
+  RestoreOptions,
+  CountOptions,
+  PaginatedRow,
+} from '@nest-toolbox/typeorm-soft-delete';
+
+// Type-safe operations
+const result: SoftDeleteResult = await softDelete(repo, 1);
+console.log(`Affected: ${result.affected}`);
+```
+
+## Error Handling
+
+The package provides clear error messages:
+
+```typescript
+// Missing @DeleteDateColumn
+await softDelete(repoWithoutColumn, 1);
+// Error: Entity User does not have @DeleteDateColumn.
+//        Soft delete requires a column decorated with @DeleteDateColumn.
+
+// Entity not found (with validation)
+await restore(repo, 999, { validateExists: true });
+// Error: Entity not found or not soft-deleted
+
+// Check before operations
+if (!supportsSoftDelete(repo)) {
+  console.error('Repository does not support soft delete');
+}
+```
+
+## Testing
+
+Mock repositories in your tests:
+
+```typescript
+import { vi } from 'vitest';
+
+const mockRepo = {
+  metadata: {
+    deleteDateColumn: { databaseName: 'deletedAt' },
+    primaryColumns: [{ propertyName: 'id' }],
+  },
+  createQueryBuilder: vi.fn().mockReturnValue({
+    update: vi.fn().mockReturnThis(),
+    set: vi.fn().mockReturnThis(),
+    where: vi.fn().mockReturnThis(),
+    andWhere: vi.fn().mockReturnThis(),
+    execute: vi.fn().mockResolvedValue({ affected: 1 }),
+  }),
+} as any;
+
+const result = await softDelete(mockRepo, 1);
+expect(result.affected).toBe(1);
+```
+
+## Contributing
+
+Contributions are welcome! Please check out the [main repository](https://github.com/lupu60/nestjs-toolbox) for contributing guidelines.
+
+## License
+
+MIT
+
+## Support
+
+For issues and questions, please visit the [GitHub Issues](https://github.com/lupu60/nestjs-toolbox/issues) page.

package/dist/decorators.d.ts

@@ -0,0 +1,47 @@
+import 'reflect-metadata';
+/**
+ * Configuration options for soft delete behavior
+ */
+export interface SoftDeleteConfig {
+    /**
+     * Name of the delete date column
+     * @default 'deletedAt'
+     */
+    columnName?: string;
+    /**
+     * Whether to allow hard deletion of records
+     * @default false
+     */
+    allowHardDelete?: boolean;
+}
+/**
+ * Marks entity as soft-deletable
+ * Stores metadata for validation and auto-configuration
+ *
+ * @param config - Optional configuration for soft delete behavior
+ *
+ * @example
+ * ```typescript
+ * @Entity()
+ * @SoftDeletable({ columnName: 'deletedAt' })
+ * class User {
+ *   @DeleteDateColumn()
+ *   deletedAt?: Date;
+ * }
+ * ```
+ */
+export declare function SoftDeletable(config?: SoftDeleteConfig): ClassDecorator;
+/**
+ * Get soft delete configuration from entity
+ *
+ * @param entity - Entity class or constructor function
+ * @returns Configuration object if entity is marked as soft-deletable, undefined otherwise
+ */
+export declare function getSoftDeleteConfig(entity: Function): SoftDeleteConfig | undefined;
+/**
+ * Check if entity is marked as soft-deletable
+ *
+ * @param entity - Entity class or constructor function
+ * @returns true if entity has @SoftDeletable decorator, false otherwise
+ */
+export declare function isSoftDeletable(entity: Function): boolean;

package/dist/decorators.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SoftDeletable = SoftDeletable;
+exports.getSoftDeleteConfig = getSoftDeleteConfig;
+exports.isSoftDeletable = isSoftDeletable;
+require("reflect-metadata");
+const SOFT_DELETABLE_KEY = Symbol('softDeletable');
+/**
+ * Marks entity as soft-deletable
+ * Stores metadata for validation and auto-configuration
+ *
+ * @param config - Optional configuration for soft delete behavior
+ *
+ * @example
+ * ```typescript
+ * @Entity()
+ * @SoftDeletable({ columnName: 'deletedAt' })
+ * class User {
+ *   @DeleteDateColumn()
+ *   deletedAt?: Date;
+ * }
+ * ```
+ */
+function SoftDeletable(config) {
+    // biome-ignore lint/complexity/noBannedTypes: ClassDecorator requires Function type
+    return (target) => {
+        var _a, _b;
+        const finalConfig = {
+            columnName: (_a = config === null || config === void 0 ? void 0 : config.columnName) !== null && _a !== void 0 ? _a : 'deletedAt',
+            allowHardDelete: (_b = config === null || config === void 0 ? void 0 : config.allowHardDelete) !== null && _b !== void 0 ? _b : false,
+        };
+        Reflect.defineMetadata(SOFT_DELETABLE_KEY, finalConfig, target);
+    };
+}
+/**
+ * Get soft delete configuration from entity
+ *
+ * @param entity - Entity class or constructor function
+ * @returns Configuration object if entity is marked as soft-deletable, undefined otherwise
+ */
+// biome-ignore lint/complexity/noBannedTypes: Reflect.getMetadata requires Function type
+function getSoftDeleteConfig(entity) {
+    return Reflect.getMetadata(SOFT_DELETABLE_KEY, entity);
+}
+/**
+ * Check if entity is marked as soft-deletable
+ *
+ * @param entity - Entity class or constructor function
+ * @returns true if entity has @SoftDeletable decorator, false otherwise
+ */
+// biome-ignore lint/complexity/noBannedTypes: Reflect.hasMetadata requires Function type
+function isSoftDeletable(entity) {
+    return Reflect.hasMetadata(SOFT_DELETABLE_KEY, entity);
+}
+//# sourceMappingURL=decorators.js.map

package/dist/decorators.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"decorators.js","sourceRoot":"","sources":["../src/decorators.ts"],"names":[],"mappings":";;AAqCA,sCASC;AASD,kDAEC;AASD,0CAEC;AApED,4BAA0B;AAE1B,MAAM,kBAAkB,GAAG,MAAM,CAAC,eAAe,CAAC,CAAC;AAmBnD;;;;;;;;;;;;;;;GAeG;AACH,SAAgB,aAAa,CAAC,MAAyB;IACrD,oFAAoF;IACpF,OAAO,CAAC,MAAgB,EAAE,EAAE;;QAC1B,MAAM,WAAW,GAA+B;YAC9C,UAAU,EAAE,MAAA,MAAM,aAAN,MAAM,uBAAN,MAAM,CAAE,UAAU,mCAAI,WAAW;YAC7C,eAAe,EAAE,MAAA,MAAM,aAAN,MAAM,uBAAN,MAAM,CAAE,eAAe,mCAAI,KAAK;SAClD,CAAC;QACF,OAAO,CAAC,cAAc,CAAC,kBAAkB,EAAE,WAAW,EAAE,MAAM,CAAC,CAAC;IAClE,CAAC,CAAC;AACJ,CAAC;AAED;;;;;GAKG;AACH,yFAAyF;AACzF,SAAgB,mBAAmB,CAAC,MAAgB;IAClD,OAAO,OAAO,CAAC,WAAW,CAAC,kBAAkB,EAAE,MAAM,CAAC,CAAC;AACzD,CAAC;AAED;;;;;GAKG;AACH,yFAAyF;AACzF,SAAgB,eAAe,CAAC,MAAgB;IAC9C,OAAO,OAAO,CAAC,WAAW,CAAC,kBAAkB,EAAE,MAAM,CAAC,CAAC;AACzD,CAAC"}

package/dist/index.d.ts

@@ -0,0 +1,6 @@
+export { getSoftDeleteConfig, isSoftDeletable, SoftDeletable, type SoftDeleteConfig } from './decorators';
+export { count, findOnlyDeleted, findWithDeleted, forceDelete, isSoftDeleted, restore, softDelete, } from './soft-delete-operations';
+export { type PaginatedRow, type PaginationWithDeletedOptions, rowsOnlyDeleted, rowsWithDeleted, } from './soft-delete-paginate';
+export { SoftDeleteRepository, withSoftDelete } from './soft-delete-repository';
+export type { CountOptions, FindDeletedOptions, RestoreOptions, SoftDeleteCriteria, SoftDeleteOptions, SoftDeleteResult, } from './types';
+export { getDeleteDateColumnName, supportsSoftDelete, validateSoftDeleteSupport } from './utils';

package/dist/index.js

@@ -0,0 +1,31 @@
+"use strict";
+// Core functions (Primary API)
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateSoftDeleteSupport = exports.supportsSoftDelete = exports.getDeleteDateColumnName = exports.withSoftDelete = exports.SoftDeleteRepository = exports.rowsWithDeleted = exports.rowsOnlyDeleted = exports.softDelete = exports.restore = exports.isSoftDeleted = exports.forceDelete = exports.findWithDeleted = exports.findOnlyDeleted = exports.count = exports.SoftDeletable = exports.isSoftDeletable = exports.getSoftDeleteConfig = void 0;
+// Decorators
+var decorators_1 = require("./decorators");
+Object.defineProperty(exports, "getSoftDeleteConfig", { enumerable: true, get: function () { return decorators_1.getSoftDeleteConfig; } });
+Object.defineProperty(exports, "isSoftDeletable", { enumerable: true, get: function () { return decorators_1.isSoftDeletable; } });
+Object.defineProperty(exports, "SoftDeletable", { enumerable: true, get: function () { return decorators_1.SoftDeletable; } });
+var soft_delete_operations_1 = require("./soft-delete-operations");
+Object.defineProperty(exports, "count", { enumerable: true, get: function () { return soft_delete_operations_1.count; } });
+Object.defineProperty(exports, "findOnlyDeleted", { enumerable: true, get: function () { return soft_delete_operations_1.findOnlyDeleted; } });
+Object.defineProperty(exports, "findWithDeleted", { enumerable: true, get: function () { return soft_delete_operations_1.findWithDeleted; } });
+Object.defineProperty(exports, "forceDelete", { enumerable: true, get: function () { return soft_delete_operations_1.forceDelete; } });
+Object.defineProperty(exports, "isSoftDeleted", { enumerable: true, get: function () { return soft_delete_operations_1.isSoftDeleted; } });
+Object.defineProperty(exports, "restore", { enumerable: true, get: function () { return soft_delete_operations_1.restore; } });
+Object.defineProperty(exports, "softDelete", { enumerable: true, get: function () { return soft_delete_operations_1.softDelete; } });
+// Pagination integration
+var soft_delete_paginate_1 = require("./soft-delete-paginate");
+Object.defineProperty(exports, "rowsOnlyDeleted", { enumerable: true, get: function () { return soft_delete_paginate_1.rowsOnlyDeleted; } });
+Object.defineProperty(exports, "rowsWithDeleted", { enumerable: true, get: function () { return soft_delete_paginate_1.rowsWithDeleted; } });
+// Optional wrapper (for method-based API)
+var soft_delete_repository_1 = require("./soft-delete-repository");
+Object.defineProperty(exports, "SoftDeleteRepository", { enumerable: true, get: function () { return soft_delete_repository_1.SoftDeleteRepository; } });
+Object.defineProperty(exports, "withSoftDelete", { enumerable: true, get: function () { return soft_delete_repository_1.withSoftDelete; } });
+// Utilities
+var utils_1 = require("./utils");
+Object.defineProperty(exports, "getDeleteDateColumnName", { enumerable: true, get: function () { return utils_1.getDeleteDateColumnName; } });
+Object.defineProperty(exports, "supportsSoftDelete", { enumerable: true, get: function () { return utils_1.supportsSoftDelete; } });
+Object.defineProperty(exports, "validateSoftDeleteSupport", { enumerable: true, get: function () { return utils_1.validateSoftDeleteSupport; } });
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";AAAA,+BAA+B;;;AAE/B,aAAa;AACb,2CAA0G;AAAjG,iHAAA,mBAAmB,OAAA;AAAE,6GAAA,eAAe,OAAA;AAAE,2GAAA,aAAa,OAAA;AAC5D,mEAQkC;AAPhC,+GAAA,KAAK,OAAA;AACL,yHAAA,eAAe,OAAA;AACf,yHAAA,eAAe,OAAA;AACf,qHAAA,WAAW,OAAA;AACX,uHAAA,aAAa,OAAA;AACb,iHAAA,OAAO,OAAA;AACP,oHAAA,UAAU,OAAA;AAEZ,yBAAyB;AACzB,+DAKgC;AAF9B,uHAAA,eAAe,OAAA;AACf,uHAAA,eAAe,OAAA;AAEjB,0CAA0C;AAC1C,mEAAgF;AAAvE,8HAAA,oBAAoB,OAAA;AAAE,wHAAA,cAAc,OAAA;AAU7C,YAAY;AACZ,iCAAiG;AAAxF,gHAAA,uBAAuB,OAAA;AAAE,2GAAA,kBAAkB,OAAA;AAAE,kHAAA,yBAAyB,OAAA"}