@fluojs/cron 1.0.0-beta.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 fluo contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.ko.md

@@ -0,0 +1,183 @@
+# @fluojs/cron
+
+<p><a href="./README.md"><kbd>English</kbd></a> <strong><kbd>한국어</kbd></strong></p>
+
+fluo 애플리케이션을 위한 데코레이터 기반 스케줄링 패키지입니다. 앱 라이프사이클에 맞춰 시작/종료를 관리하고, Redis 기반 분산 락(Distributed Locking) 기능을 제공합니다.
+
+## 목차
+
+- [설치](#설치)
+- [사용 시점](#사용-시점)
+- [빠른 시작](#빠른-시작)
+- [공통 패턴](#공통-패턴)
+  - [분산 락 사용하기](#분산-락-사용하기)
+  - [동적 스케줄링](#동적-스케줄링)
+  - [제한된 종료](#제한된-종료)
+- [공개 API 개요](#공개-api-개요)
+- [관련 패키지](#관련-패키지)
+- [예제 소스](#예제-소스)
+
+## 설치
+
+```bash
+npm install @fluojs/cron croner
+```
+
+## 사용 시점
+
+- 정기적인 백그라운드 작업(예: 데이터베이스 정리, 리포트 생성)이 필요할 때 사용합니다.
+- 표준 Cron 표현식을 사용하여 작업을 예약하고 싶을 때 적합합니다.
+- 다중 인스턴스 환경에서 특정 작업이 한 번에 하나의 인스턴스에서만 실행되도록 보장해야 할 때(분산 락) 사용합니다.
+- 일회성 지연 작업(Timeout)이나 고정된 주기의 반복 작업(Interval)이 필요할 때 사용합니다.
+
+## 빠른 시작
+
+`CronModule`을 등록하고 데코레이터를 사용하여 메서드를 스케줄링합니다.
+
+애플리케이션 모듈의 스케줄링 등록은 `CronModule.forRoot(...)`로 구성합니다.
+
+```typescript
+import { Module } from '@fluojs/core';
+import { CronModule, Cron, CronExpression, Interval, Timeout } from '@fluojs/cron';
+
+class BillingService {
+  @Cron(CronExpression.EVERY_MINUTE, { name: 'billing.reconcile' })
+  async reconcilePendingInvoices() {
+    console.log('송장 정리 중...');
+  }
+
+  @Interval(15_000) // 15초마다
+  async pollStatus() {
+    console.log('상태 폴링 중...');
+  }
+
+  @Timeout(5_000) // 시작 5초 후 1회 실행
+  async initialSync() {
+    console.log('초기 동기화 실행 중...');
+  }
+}
+
+@Module({
+  imports: [CronModule.forRoot()],
+  providers: [BillingService],
+})
+class AppModule {}
+```
+
+## 공통 패턴
+
+### 분산 락 사용하기
+
+여러 서버 인스턴스에서 스케줄링된 작업이 동시에 실행되는 것을 방지하려면 분산 모드를 활성화하세요. 이 기능은 `@fluojs/redis`가 필요합니다.
+
+```typescript
+import { Module } from '@fluojs/core';
+import { CronModule } from '@fluojs/cron';
+import { RedisModule } from '@fluojs/redis';
+
+@Module({
+  imports: [
+    RedisModule.forRoot({ host: 'localhost', port: 6379 }),
+    CronModule.forRoot({
+      distributed: {
+        enabled: true,
+        keyPrefix: 'fluo:cron:lock',
+        lockTtlMs: 30_000,
+      },
+    }),
+  ],
+})
+class AppModule {}
+```
+
+`distributed.clientName`을 생략하면 위의 기본 Redis 등록을 계속 사용합니다. 분산 락에 기본 Redis가 아닌 다른 연결을 쓰려면 `RedisModule.forRootNamed(...)`로 등록한 이름을 `distributed.clientName`에 지정하세요.
+
+`distributed.lockTtlMs`는 `1_000ms` 이상이어야 합니다. fluo는 최소 지원 경계인 `1_000ms`를 포함해 TTL이 만료되기 전에 Redis 락을 갱신합니다.
+
+```typescript
+@Module({
+  imports: [
+    RedisModule.forRoot({ host: 'localhost', port: 6379 }),
+    RedisModule.forRootNamed('locks', { host: 'localhost', port: 6380 }),
+    CronModule.forRoot({
+      distributed: {
+        clientName: 'locks',
+        enabled: true,
+        keyPrefix: 'fluo:cron:lock',
+        lockTtlMs: 30_000,
+      },
+    }),
+  ],
+})
+class MultiRedisCronModule {}
+```
+
+### 동적 스케줄링
+
+`SCHEDULING_REGISTRY`를 사용하여 런타임에 작업을 관리할 수 있습니다.
+
+```typescript
+import { Inject } from '@fluojs/core';
+import { SCHEDULING_REGISTRY, type SchedulingRegistry } from '@fluojs/cron';
+
+class TaskManager {
+  constructor(
+    @Inject(SCHEDULING_REGISTRY) private readonly registry: SchedulingRegistry
+  ) {}
+
+  addNewTask() {
+    this.registry.addCron('dynamic-job', '0 * * * *', () => {
+      console.log('동적 작업 실행 중!');
+    });
+  }
+
+  stopTask() {
+    this.registry.remove('dynamic-job');
+  }
+}
+```
+
+### 제한된 종료
+
+`CronModule`은 애플리케이션 종료 시 실행 중인 작업을 drain하지만, 이제는 제한된 타임아웃 안에서만 기다립니다. 따라서 하나의 hung task 때문에 프로세스 종료가 영원히 막히지 않습니다.
+
+기본적으로 shutdown drain은 최대 `10_000ms` 동안 기다립니다. 이 시간이 지나면 스케줄러는 경고 로그를 남기고 hung task가 끝나기를 더 기다리지 않은 채 종료를 계속합니다.
+
+```typescript
+@Module({
+  imports: [
+    CronModule.forRoot({
+      shutdown: {
+        timeoutMs: 5_000,
+      },
+    }),
+  ],
+})
+class AppModule {}
+```
+
+## 공개 API 개요
+
+### 모듈
+- `CronModule.forRoot(options)`: 스케줄러를 설정하고 필요한 경우 분산 락을 활성화합니다.
+
+### 데코레이터
+- `@Cron(expression, options?)`: Cron 표현식을 사용하여 메서드를 예약합니다.
+- `@Interval(ms, options?)`: 고정된 주기로 메서드를 실행합니다.
+- `@Timeout(ms, options?)`: 일정 시간 지연 후 메서드를 한 번 실행합니다.
+
+### 상수 및 토큰
+- `CronExpression`: 공통 Cron 패턴(예: `EVERY_HOUR`, `EVERY_DAY_AT_MIDNIGHT`)을 담은 객체입니다.
+- `SCHEDULING_REGISTRY`: `SchedulingRegistry` 서비스를 위한 주입 토큰입니다.
+
+
+## 관련 패키지
+
+- `@fluojs/redis`: 분산 락 기능을 위해 필요합니다.
+- `@fluojs/core`: DI 및 모듈 관리를 위해 필요합니다.
+- `croner`: 내부 스케줄링 엔진입니다.
+
+## 예제 소스
+
+- `packages/cron/src/module.test.ts`: 데코레이터 및 모듈 라이프사이클에 대한 종합 테스트.
+- `packages/cron/src/scheduler.ts`: 코어 스케줄링 로직의 구현 상세.

package/README.md

@@ -0,0 +1,183 @@
+# @fluojs/cron
+
+<p><strong><kbd>English</kbd></strong> <a href="./README.ko.md"><kbd>한국어</kbd></a></p>
+
+Decorator-based scheduling for fluo applications with lifecycle-managed startup/shutdown and optional Redis distributed locking.
+
+## Table of Contents
+
+- [Installation](#installation)
+- [When to Use](#when-to-use)
+- [Quick Start](#quick-start)
+- [Common Patterns](#common-patterns)
+  - [Distributed Locking](#distributed-locking)
+  - [Dynamic Scheduling](#dynamic-scheduling)
+  - [Bounded Shutdown](#bounded-shutdown)
+- [Public API Overview](#public-api-overview)
+- [Related Packages](#related-packages)
+- [Example Sources](#example-sources)
+
+## Installation
+
+```bash
+npm install @fluojs/cron croner
+```
+
+## When to Use
+
+- When you need to run periodic background tasks (e.g., database cleanup, report generation).
+- When you want to schedule tasks using standard Cron expressions.
+- When running in a multi-instance environment and you need to ensure a task runs only on one instance at a time (Distributed Locking).
+- When you need simple one-off delayed tasks (Timeout) or fixed-rate intervals.
+
+## Quick Start
+
+Register the `CronModule` and use decorators to schedule your methods.
+
+Use `CronModule.forRoot(...)` to register scheduling for an application module.
+
+```typescript
+import { Module } from '@fluojs/core';
+import { CronModule, Cron, CronExpression, Interval, Timeout } from '@fluojs/cron';
+
+class BillingService {
+  @Cron(CronExpression.EVERY_MINUTE, { name: 'billing.reconcile' })
+  async reconcilePendingInvoices() {
+    console.log('Reconciling invoices...');
+  }
+
+  @Interval(15_000) // 15 seconds
+  async pollStatus() {
+    console.log('Polling status...');
+  }
+
+  @Timeout(5_000) // 5 seconds after startup
+  async initialSync() {
+    console.log('Running initial sync...');
+  }
+}
+
+@Module({
+  imports: [CronModule.forRoot()],
+  providers: [BillingService],
+})
+class AppModule {}
+```
+
+## Common Patterns
+
+### Distributed Locking
+
+To prevent scheduled tasks from running concurrently across multiple server instances, enable distributed mode. This requires `@fluojs/redis`.
+
+```typescript
+import { Module } from '@fluojs/core';
+import { CronModule } from '@fluojs/cron';
+import { RedisModule } from '@fluojs/redis';
+
+@Module({
+  imports: [
+    RedisModule.forRoot({ host: 'localhost', port: 6379 }),
+    CronModule.forRoot({
+      distributed: {
+        enabled: true,
+        keyPrefix: 'fluo:cron:lock',
+        lockTtlMs: 30_000,
+      },
+    }),
+  ],
+})
+class AppModule {}
+```
+
+Leave `distributed.clientName` unset to keep using the default Redis registration above. To use a non-default Redis connection for distributed locks, set `distributed.clientName` to the name registered through `RedisModule.forRootNamed(...)`.
+
+`distributed.lockTtlMs` must stay at or above `1_000ms`. fluo renews the Redis lock before that TTL expires, including the minimum supported `1_000ms` boundary.
+
+```typescript
+@Module({
+  imports: [
+    RedisModule.forRoot({ host: 'localhost', port: 6379 }),
+    RedisModule.forRootNamed('locks', { host: 'localhost', port: 6380 }),
+    CronModule.forRoot({
+      distributed: {
+        clientName: 'locks',
+        enabled: true,
+        keyPrefix: 'fluo:cron:lock',
+        lockTtlMs: 30_000,
+      },
+    }),
+  ],
+})
+class MultiRedisCronModule {}
+```
+
+### Dynamic Scheduling
+
+You can manage tasks at runtime using the `SCHEDULING_REGISTRY`.
+
+```typescript
+import { Inject } from '@fluojs/core';
+import { SCHEDULING_REGISTRY, type SchedulingRegistry } from '@fluojs/cron';
+
+class TaskManager {
+  constructor(
+    @Inject(SCHEDULING_REGISTRY) private readonly registry: SchedulingRegistry
+  ) {}
+
+  addNewTask() {
+    this.registry.addCron('dynamic-job', '0 * * * *', () => {
+      console.log('Dynamic job running!');
+    });
+  }
+
+  stopTask() {
+    this.registry.remove('dynamic-job');
+  }
+}
+```
+
+### Bounded Shutdown
+
+`CronModule` drains active task executions during application shutdown, but it now does so with a bounded timeout so one hung task cannot block process termination forever.
+
+By default the shutdown drain waits up to `10_000ms`. If that timeout expires, the scheduler logs a warning and continues shutdown without waiting for the hung task to settle.
+
+```typescript
+@Module({
+  imports: [
+    CronModule.forRoot({
+      shutdown: {
+        timeoutMs: 5_000,
+      },
+    }),
+  ],
+})
+class AppModule {}
+```
+
+## Public API Overview
+
+### Modules
+- `CronModule.forRoot(options)`: Configures the scheduler and enables distributed locking if requested.
+
+### Decorators
+- `@Cron(expression, options?)`: Schedules a method using a cron expression.
+- `@Interval(ms, options?)`: Schedules a method to run at a fixed interval.
+- `@Timeout(ms, options?)`: Schedules a method to run once after a delay.
+
+### Constants & Tokens
+- `CronExpression`: Enum-like object with common cron patterns (e.g., `EVERY_HOUR`, `EVERY_DAY_AT_MIDNIGHT`).
+- `SCHEDULING_REGISTRY`: Injection token for the `SchedulingRegistry` service.
+
+
+## Related Packages
+
+- `@fluojs/redis`: Required for distributed locking functionality.
+- `@fluojs/core`: Required for DI and Module management.
+- `croner`: The underlying scheduling engine.
+
+## Example Sources
+
+- `packages/cron/src/module.test.ts`: Comprehensive tests for decorators and module lifecycle.
+- `packages/cron/src/scheduler.ts`: Implementation details of the core scheduling logic.

package/dist/decorators.d.ts

@@ -0,0 +1,41 @@
+import type { CronTaskOptions, IntervalTaskOptions, TimeoutTaskOptions } from './types.js';
+type StandardMethodDecoratorFn = (value: Function, context: ClassMethodDecoratorContext) => void;
+type MethodDecoratorLike = StandardMethodDecoratorFn;
+/**
+ * Schedules a public instance method using a cron expression.
+ *
+ * @param expression Cron expression validated during decorator evaluation.
+ * @param options Optional task name, lock settings, hooks, and timezone.
+ * @returns A method decorator that stores cron metadata for bootstrap discovery.
+ *
+ * @example
+ * ```ts
+ * import { Cron, CronExpression } from '@fluojs/cron';
+ *
+ * class BillingService {
+ *   @Cron(CronExpression.EVERY_MINUTE, { name: 'billing.reconcile' })
+ *   async reconcilePendingInvoices() {
+ *     await reconcileInvoices();
+ *   }
+ * }
+ * ```
+ */
+export declare function Cron(expression: string, options?: CronTaskOptions): MethodDecoratorLike;
+/**
+ * Schedules a public instance method to run repeatedly after a fixed delay.
+ *
+ * @param ms Positive interval in milliseconds.
+ * @param options Optional task name, lock settings, and lifecycle hooks.
+ * @returns A method decorator that stores interval metadata for bootstrap discovery.
+ */
+export declare function Interval(ms: number, options?: IntervalTaskOptions): MethodDecoratorLike;
+/**
+ * Schedules a public instance method to run once after application startup.
+ *
+ * @param ms Positive delay in milliseconds before the task runs.
+ * @param options Optional task name, lock settings, and lifecycle hooks.
+ * @returns A method decorator that stores timeout metadata for bootstrap discovery.
+ */
+export declare function Timeout(ms: number, options?: TimeoutTaskOptions): MethodDecoratorLike;
+export {};
+//# sourceMappingURL=decorators.d.ts.map

package/dist/decorators.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"decorators.d.ts","sourceRoot":"","sources":["../src/decorators.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAEV,eAAe,EAEf,mBAAmB,EAEnB,kBAAkB,EACnB,MAAM,YAAY,CAAC;AAGpB,KAAK,yBAAyB,GAAG,CAAC,KAAK,EAAE,QAAQ,EAAE,OAAO,EAAE,2BAA2B,KAAK,IAAI,CAAC;AACjG,KAAK,mBAAmB,GAAG,yBAAyB,CAAC;AAoCrD;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,IAAI,CAAC,UAAU,EAAE,MAAM,EAAE,OAAO,GAAE,eAAoB,GAAG,mBAAmB,CAoB3F;AAED;;;;;;GAMG;AACH,wBAAgB,QAAQ,CAAC,EAAE,EAAE,MAAM,EAAE,OAAO,GAAE,mBAAwB,GAAG,mBAAmB,CAgB3F;AAED;;;;;;GAMG;AACH,wBAAgB,OAAO,CAAC,EAAE,EAAE,MAAM,EAAE,OAAO,GAAE,kBAAuB,GAAG,mBAAmB,CAgBzF"}

package/dist/decorators.js

@@ -0,0 +1,116 @@
+import { metadataSymbol } from '@fluojs/core/internal';
+import { Cron as CronValidator } from 'croner';
+import { schedulingMetadataSymbol } from './metadata.js';
+function getStandardMetadataBag(metadata) {
+  void metadataSymbol;
+  return metadata;
+}
+function defineStandardSchedulingMetadata(metadata, propertyKey, taskMetadata) {
+  const bag = getStandardMetadataBag(metadata);
+  const current = bag[schedulingMetadataSymbol];
+  const map = current ?? new Map();
+  map.set(propertyKey, {
+    ...taskMetadata,
+    options: {
+      ...taskMetadata.options
+    }
+  });
+  bag[schedulingMetadataSymbol] = map;
+}
+function assertValidIntervalMs(ms, decoratorName) {
+  if (!Number.isFinite(ms) || !Number.isInteger(ms) || ms <= 0) {
+    throw new Error(`${decoratorName}(): ms must be a positive integer.`);
+  }
+}
+function assertMethodIsPublic(context, decoratorName) {
+  if (context.private) {
+    throw new Error(`${decoratorName}() cannot be used on private methods.`);
+  }
+}
+
+/**
+ * Schedules a public instance method using a cron expression.
+ *
+ * @param expression Cron expression validated during decorator evaluation.
+ * @param options Optional task name, lock settings, hooks, and timezone.
+ * @returns A method decorator that stores cron metadata for bootstrap discovery.
+ *
+ * @example
+ * ```ts
+ * import { Cron, CronExpression } from '@fluojs/cron';
+ *
+ * class BillingService {
+ *   @Cron(CronExpression.EVERY_MINUTE, { name: 'billing.reconcile' })
+ *   async reconcilePendingInvoices() {
+ *     await reconcileInvoices();
+ *   }
+ * }
+ * ```
+ */
+export function Cron(expression, options = {}) {
+  try {
+    new CronValidator(expression, {
+      maxRuns: 0
+    });
+  } catch {
+    throw new Error(`@Cron(): invalid cron expression "${expression}".`);
+  }
+  const decorator = (_value, context) => {
+    assertMethodIsPublic(context, '@Cron');
+    const metadata = {
+      expression,
+      kind: 'cron',
+      options: {
+        ...options
+      }
+    };
+    defineStandardSchedulingMetadata(context.metadata, context.name, metadata);
+  };
+  return decorator;
+}
+
+/**
+ * Schedules a public instance method to run repeatedly after a fixed delay.
+ *
+ * @param ms Positive interval in milliseconds.
+ * @param options Optional task name, lock settings, and lifecycle hooks.
+ * @returns A method decorator that stores interval metadata for bootstrap discovery.
+ */
+export function Interval(ms, options = {}) {
+  assertValidIntervalMs(ms, '@Interval');
+  const decorator = (_value, context) => {
+    assertMethodIsPublic(context, '@Interval');
+    const metadata = {
+      kind: 'interval',
+      ms,
+      options: {
+        ...options
+      }
+    };
+    defineStandardSchedulingMetadata(context.metadata, context.name, metadata);
+  };
+  return decorator;
+}
+
+/**
+ * Schedules a public instance method to run once after application startup.
+ *
+ * @param ms Positive delay in milliseconds before the task runs.
+ * @param options Optional task name, lock settings, and lifecycle hooks.
+ * @returns A method decorator that stores timeout metadata for bootstrap discovery.
+ */
+export function Timeout(ms, options = {}) {
+  assertValidIntervalMs(ms, '@Timeout');
+  const decorator = (_value, context) => {
+    assertMethodIsPublic(context, '@Timeout');
+    const metadata = {
+      kind: 'timeout',
+      ms,
+      options: {
+        ...options
+      }
+    };
+    defineStandardSchedulingMetadata(context.metadata, context.name, metadata);
+  };
+  return decorator;
+}

package/dist/distributed-lock-manager.d.ts

@@ -0,0 +1,38 @@
+import type { Container } from '@fluojs/di';
+import type { ApplicationLogger } from '@fluojs/runtime';
+import type { CronTaskDescriptor, NormalizedCronModuleOptions } from './types.js';
+export interface RedisLockClient {
+    eval(script: string, keysLength: number, ...keysAndArgs: string[]): Promise<unknown>;
+    set(key: string, value: string, mode: 'PX', ttl: number, existence: 'NX'): Promise<'OK' | null | undefined>;
+}
+export interface LockRenewalMonitor {
+    getPostRunError(): Promise<Error | undefined>;
+    stop(): void;
+}
+export declare class CronDistributedLockManager {
+    private readonly options;
+    private readonly runtimeContainer;
+    private readonly logger;
+    private readonly ownedLockKeys;
+    private redisClient;
+    private lockOwnershipLosses;
+    private lockRenewalFailures;
+    constructor(options: NormalizedCronModuleOptions, runtimeContainer: Container, logger: ApplicationLogger);
+    get resolvedClient(): RedisLockClient | undefined;
+    get ownedLocks(): number;
+    get ownershipLosses(): number;
+    get renewalFailures(): number;
+    resolveClient(): Promise<void>;
+    reset(): void;
+    tryAcquireLock(descriptor: CronTaskDescriptor): Promise<boolean>;
+    startLockRenewalMonitor(descriptor: CronTaskDescriptor): LockRenewalMonitor;
+    releaseLock(descriptor: CronTaskDescriptor): Promise<void>;
+    releaseOwnedLocks(): Promise<void>;
+    private createLockRenewalState;
+    private queueDueLockRenewalAttempts;
+    private runLockRenewalAttempt;
+    private toLockPostRunError;
+    private renewLock;
+    private releaseLockKey;
+}
+//# sourceMappingURL=distributed-lock-manager.d.ts.map

package/dist/distributed-lock-manager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"distributed-lock-manager.d.ts","sourceRoot":"","sources":["../src/distributed-lock-manager.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,YAAY,CAAC;AAC5C,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,iBAAiB,CAAC;AAEzD,OAAO,KAAK,EAAE,kBAAkB,EAAE,2BAA2B,EAAE,MAAM,YAAY,CAAC;AAElF,MAAM,WAAW,eAAe;IAC9B,IAAI,CAAC,MAAM,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,EAAE,GAAG,WAAW,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;IACrF,GAAG,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,IAAI,EAAE,GAAG,EAAE,MAAM,EAAE,SAAS,EAAE,IAAI,GAAG,OAAO,CAAC,IAAI,GAAG,IAAI,GAAG,SAAS,CAAC,CAAC;CAC7G;AAED,MAAM,WAAW,kBAAkB;IACjC,eAAe,IAAI,OAAO,CAAC,KAAK,GAAG,SAAS,CAAC,CAAC;IAC9C,IAAI,IAAI,IAAI,CAAC;CACd;AAiBD,qBAAa,0BAA0B;IAOnC,OAAO,CAAC,QAAQ,CAAC,OAAO;IACxB,OAAO,CAAC,QAAQ,CAAC,gBAAgB;IACjC,OAAO,CAAC,QAAQ,CAAC,MAAM;IARzB,OAAO,CAAC,QAAQ,CAAC,aAAa,CAAqB;IACnD,OAAO,CAAC,WAAW,CAA8B;IACjD,OAAO,CAAC,mBAAmB,CAAK;IAChC,OAAO,CAAC,mBAAmB,CAAK;gBAGb,OAAO,EAAE,2BAA2B,EACpC,gBAAgB,EAAE,SAAS,EAC3B,MAAM,EAAE,iBAAiB;IAG5C,IAAI,cAAc,IAAI,eAAe,GAAG,SAAS,CAEhD;IAED,IAAI,UAAU,IAAI,MAAM,CAEvB;IAED,IAAI,eAAe,IAAI,MAAM,CAE5B;IAED,IAAI,eAAe,IAAI,MAAM,CAE5B;IAEK,aAAa,IAAI,OAAO,CAAC,IAAI,CAAC;IAoBpC,KAAK,IAAI,IAAI;IAIP,cAAc,CAAC,UAAU,EAAE,kBAAkB,GAAG,OAAO,CAAC,OAAO,CAAC;IA+BtE,uBAAuB,CAAC,UAAU,EAAE,kBAAkB,GAAG,kBAAkB;IA8BrE,WAAW,CAAC,UAAU,EAAE,kBAAkB,GAAG,OAAO,CAAC,IAAI,CAAC;IAI1D,iBAAiB,IAAI,OAAO,CAAC,IAAI,CAAC;IAcxC,OAAO,CAAC,sBAAsB;IAY9B,OAAO,CAAC,2BAA2B;YAcrB,qBAAqB;IAqBnC,OAAO,CAAC,kBAAkB;YAYZ,SAAS;YAwCT,cAAc;CAgC7B"}