stratal 0.0.26 → 0.1.0

package/dist/guards/index.d.mts

@@ -1,7 +1,23 @@
-import { $ as Container, st as RouterContext } from "../index-uybm0bhQ.mjs";
+import { $ as Container, l as HttpException, st as RouterContext } from "../index-B2WtEagR.mjs";
 import { r as LoggerService } from "../index-BUt92sAE.mjs";
 import { t as Constructor } from "../types-CmV_9xBD.mjs";
-
+//#region src/guards/errors.d.ts
+/**
+ * Thrown when a guard's `canActivate` returns `false`.
+ *
+ * HTTP Status: 403 Forbidden
+ *
+ * A guard denies by returning `false` or by throwing its own error; this class is what the
+ * former becomes, so both paths surface as an exception the {@link ExceptionHandler} can render
+ * and an application can match with `instanceof` or replace via `renderable()`. A guard that
+ * needs a different status (401 for unauthenticated, 429 for a budget) should throw its own
+ * `HttpException` instead — that is passed through untouched.
+ */
+export declare class GuardRejectedError extends HttpException {
+  readonly guard: string;
+  constructor(guard: string);
+}
+//#endregion
 //#region src/guards/types.d.ts
 /**
  * Interface for guards that control access to routes
@@ -21,28 +37,30 @@ import { t as Constructor } from "../types-CmV_9xBD.mjs";
  * }
  * ```
  */
-interface CanActivate {
+export interface CanActivate {
   /**
    * Determine if the request should be allowed
    *
    * @param context - Router context with request/response helpers
-   * @returns true to allow, false to deny (throws 403)
+   * @returns true to allow, false to deny — a `false` is turned into a `GuardRejectedError`
+   * (HTTP 403) and thrown, so the handler never runs. To deny with a different status, throw your
+   * own `HttpException` instead; it is passed through untouched.
    */
   canActivate(context: RouterContext): boolean | Promise<boolean>;
 }
 /**
  * Type for guard class constructors
  */
-type GuardClass = Constructor<CanActivate>;
+export type GuardClass = Constructor<CanActivate>;
 /**
  * Guard can be a class constructor or an instance
  * Instances are used for factory-created guards with configuration
  */
-type Guard = GuardClass | CanActivate;
+export type Guard = GuardClass | CanActivate;
 /**
  * Options for AuthGuard factory
  */
-interface AuthGuardOptions {
+export interface AuthGuardOptions {
   /**
    * Required permissions for authorization as `"resource:action"` strings.
    * If provided, permission check is performed after authentication.
@@ -62,13 +80,13 @@ interface AuthGuardOptions {
 /**
  * Metadata stored by `@UseGuards` decorator
  */
-interface GuardMetadata {
+export interface GuardMetadata {
   guards: Guard[];
 }
 /**
  * Metadata key for guard storage
  */
-declare const GUARD_METADATA_KEY: unique symbol;
+export declare const GUARD_METADATA_KEY: unique symbol;
 //#endregion
 //#region src/guards/use-guards.decorator.d.ts
 /**
@@ -90,7 +108,7 @@ declare const GUARD_METADATA_KEY: unique symbol;
  *
  * @example Authentication only
  * ```typescript
- * @Controller('/api/v1/profile')
+ * @Controller('/profile', { version: '1' })
  * @UseGuards(AuthGuard())
  * export class ProfileController {
  *   show() { } // Requires authentication
@@ -99,8 +117,8 @@ declare const GUARD_METADATA_KEY: unique symbol;
  *
  * @example Authentication with permissions
  * ```typescript
- * @Controller('/api/v1/students')
- * @UseGuards(AuthGuard({ scopes: ['students:read'] }))
+ * @Controller('/students', { version: '1' })
+ * @UseGuards(AuthGuard({ permissions: ['students:read'] }))
  * export class StudentsController {
  *   index() { } // Requires 'students:read' permission
  * }
@@ -108,12 +126,12 @@ declare const GUARD_METADATA_KEY: unique symbol;
  *
  * @example Method-level guards
  * ```typescript
- * @Controller('/api/v1/students')
+ * @Controller('/students', { version: '1' })
  * @UseGuards(AuthGuard()) // Controller-level: auth only
  * export class StudentsController {
  *   index() { } // Auth only (inherited)
  *
- *   @UseGuards(AuthGuard({ scopes: ['students:create'] }))
+ *   @UseGuards(AuthGuard({ permissions: ['students:create'] }))
  *   create() { } // Auth + 'students:create' permission
  * }
  * ```
@@ -126,14 +144,14 @@ declare const GUARD_METADATA_KEY: unique symbol;
  * }
  * ```
  */
-declare function UseGuards(...guards: Guard[]): ClassDecorator & MethodDecorator;
+export declare function UseGuards(...guards: Guard[]): ClassDecorator & MethodDecorator;
 /**
  * Get controller-level guard metadata
  *
  * @param target - Controller class
  * @returns Guard metadata or undefined if not decorated
  */
-declare function getControllerGuards(target: object): GuardMetadata | undefined;
+export declare function getControllerGuards(target: object): GuardMetadata | undefined;
 /**
  * Get method-level guard metadata
  *
@@ -141,7 +159,7 @@ declare function getControllerGuards(target: object): GuardMetadata | undefined;
  * @param propertyKey - Method name
  * @returns Guard metadata or undefined if not decorated
  */
-declare function getMethodGuards(target: object, propertyKey: string | symbol): GuardMetadata | undefined;
+export declare function getMethodGuards(target: object, propertyKey: string | symbol): GuardMetadata | undefined;
 //#endregion
 //#region src/guards/guard-execution.service.d.ts
 /**
@@ -150,7 +168,7 @@ declare function getMethodGuards(target: object, propertyKey: string | symbol):
  * Executes guards for a route and determines if the request should proceed.
  * Guards are executed in order; all must pass for the request to proceed.
  */
-declare class GuardExecutionService {
+export declare class GuardExecutionService {
   private readonly logger;
   constructor(logger: LoggerService);
   /**
@@ -160,7 +178,8 @@ declare class GuardExecutionService {
    * @param context - Router context
    * @param container - Request-scoped DI container
    * @returns true if all guards pass
-   * @throws Error from first failing guard
+   * @throws {@link GuardRejectedError} if a guard's `canActivate` returns `false`, or the guard's
+   * own thrown error if it rejects by throwing instead
    */
   executeGuards(guards: Guard[], context: RouterContext, container: Container): Promise<boolean>;
   /**
@@ -177,5 +196,4 @@ declare class GuardExecutionService {
   private isGuardInstance;
 }
 //#endregion
-export { AuthGuardOptions, CanActivate, GUARD_METADATA_KEY, Guard, GuardClass, GuardExecutionService, GuardMetadata, UseGuards, getControllerGuards, getMethodGuards };
 //# sourceMappingURL=index.d.mts.map

package/dist/guards/index.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.mts","names":[],"sources":["../../src/guards/types.ts","../../src/guards/use-guards.decorator.ts","../../src/guards/guard-execution.service.ts"],"mappings":";;;;;;;;AAqBA;;;;;;;;;AAOwD;AAMxD;;;;AAAgD;UAb/B,WAAA;EAmBA;;;AAA2B;AAK5C;;EAjBE,WAAA,CAAY,OAAA,EAAS,aAAA,aAA0B,OAAO;AAAA;AAgC3C;AAMb;;AANa,KA1BD,UAAA,GAAa,WAAW,CAAC,WAAA;;AAiCtB;AAMf;;KAjCY,KAAA,GAAQ,UAAA,GAAa,WAAW;;AAiCkB;;UA5B7C,gBAAA;;ACajB;;;;;;;;;;;;;EDEE,WAAW;AAAA;;;;UAMI,aAAA;EACf,MAAA,EAAQ,KAAK;AAAA;;;;cAMF,kBAAA;;;;;;;AApDb;;;;;;;;;AAOwD;AAMxD;;;;AAAgD;AAMhD;;;;AAA4C;AAK5C;;;;AAea;AAMb;;;;AACe;AAMf;;;;AAA8D;;;;ACf9D;;;;;;;;;;;;;iBAAgB,SAAA,IAAa,MAAA,EAAQ,KAAA,KAAU,cAAA,GAAiB,eAAA;AAoBhE;;;;AAAkE;AAWlE;AAXA,iBAAgB,mBAAA,CAAoB,MAAA,WAAiB,aAAa;;;;;;;AAW0B;iBAA5E,eAAA,CAAgB,MAAA,UAAgB,WAAA,oBAA+B,aAAa;;;;ADpE5F;;;;;cEVa,qBAAA;EAAA,iBACkB,MAAA;cAAA,MAAA,EAAQ,aAAA;EFgBiB;AAAA;AAMxD;;;;AAAgD;AAMhD;;EEjBQ,aAAA,CACJ,MAAA,EAAQ,KAAA,IACR,OAAA,EAAS,aAAA,EACT,SAAA,EAAW,SAAA,GACV,OAAA;EFae;AAAwB;AAK5C;;;;AAea;EApBO,QE2BV,YAAA;EFDoB;;;EAAA,QEcpB,eAAA;AAAA"}
+{"version":3,"file":"index.d.mts","names":[],"sources":["../../src/guards/errors.ts","../../src/guards/types.ts","../../src/guards/use-guards.decorator.ts","../../src/guards/guard-execution.service.ts"],"mappings":";;;;;;;;;;;;;;;qBAaa,2BAA2B;WACV;EAA5B,YAA4B;;;;;;;;;;;;;;;;;;;;;;iBCOb;;;;;;;;;EASf,YAAY,SAAS,0BAA0B;;;;;YAMrC,aAAa,YAAY;;;;;YAMzB,QAAQ,aAAa;;;;iBAKhB;;;;;;;;;;;;;;;EAef;;;;;iBAMe;EACf,QAAQ;;;;;qBAMG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wBCjBG,aAAa,QAAQ,UAAU,iBAAiB;;;;;;;wBAoBhD,oBAAoB,iBAAiB;;;;;;;;wBAWrC,gBAAgB,gBAAgB,+BAA+B;;;;;;;;;qBC7ElE;mBACkB;EAA7B,YAA6B,QAAQ;;;;;;;;;;;EAY/B,cACJ,QAAQ,SACR,SAAS,eACT,WAAW,YACV;;;;;;;;UA6CK;;;;UAaA"}

package/dist/guards/index.mjs

@@ -1,2 +1,2 @@
-import { a as GUARD_METADATA_KEY, i as getMethodGuards, n as UseGuards, r as getControllerGuards, t as GuardExecutionService } from "../guards-DALPXy3_.mjs";
-export { GUARD_METADATA_KEY, GuardExecutionService, UseGuards, getControllerGuards, getMethodGuards };
+import { a as GUARD_METADATA_KEY, i as getMethodGuards, n as UseGuards, o as GuardRejectedError, r as getControllerGuards, t as GuardExecutionService } from "../guards-DOGly9IF.mjs";
+export { GUARD_METADATA_KEY, GuardExecutionService, GuardRejectedError, UseGuards, getControllerGuards, getMethodGuards };

package/dist/{guards-DALPXy3_.mjs → guards-DOGly9IF.mjs}

@@ -1,4 +1,25 @@
-import { n as getMetadata, t as defineMetadata } from "./metadata-DzzprcID.mjs";
+import { _ as defineMetadata, v as getMetadata } from "./di-DQ3xbjgf.mjs";
+import { d as HttpException } from "./errors-CrOXI_y5.mjs";
+//#region src/guards/errors.ts
+/**
+* Thrown when a guard's `canActivate` returns `false`.
+*
+* HTTP Status: 403 Forbidden
+*
+* A guard denies by returning `false` or by throwing its own error; this class is what the
+* former becomes, so both paths surface as an exception the {@link ExceptionHandler} can render
+* and an application can match with `instanceof` or replace via `renderable()`. A guard that
+* needs a different status (401 for unauthenticated, 429 for a budget) should throw its own
+* `HttpException` instead — that is passed through untouched.
+*/
+var GuardRejectedError = class extends HttpException {
+	guard;
+	constructor(guard) {
+		super(403, "Forbidden");
+		this.guard = guard;
+	}
+};
+//#endregion
 //#region src/guards/types.ts
 /**
 * Metadata key for guard storage
@@ -25,7 +46,7 @@ const GUARD_METADATA_KEY = Symbol.for("stratal:guards");
 *
 * @example Authentication only
 * ```typescript
-* @Controller('/api/v1/profile')
+* @Controller('/profile', { version: '1' })
 * @UseGuards(AuthGuard())
 * export class ProfileController {
 *   show() { } // Requires authentication
@@ -34,8 +55,8 @@ const GUARD_METADATA_KEY = Symbol.for("stratal:guards");
 *
 * @example Authentication with permissions
 * ```typescript
-* @Controller('/api/v1/students')
-* @UseGuards(AuthGuard({ scopes: ['students:read'] }))
+* @Controller('/students', { version: '1' })
+* @UseGuards(AuthGuard({ permissions: ['students:read'] }))
 * export class StudentsController {
 *   index() { } // Requires 'students:read' permission
 * }
@@ -43,12 +64,12 @@ const GUARD_METADATA_KEY = Symbol.for("stratal:guards");
 *
 * @example Method-level guards
 * ```typescript
-* @Controller('/api/v1/students')
+* @Controller('/students', { version: '1' })
 * @UseGuards(AuthGuard()) // Controller-level: auth only
 * export class StudentsController {
 *   index() { } // Auth only (inherited)
 *
-*   @UseGuards(AuthGuard({ scopes: ['students:create'] }))
+*   @UseGuards(AuthGuard({ permissions: ['students:create'] }))
 *   create() { } // Auth + 'students:create' permission
 * }
 * ```
@@ -107,7 +128,8 @@ var GuardExecutionService = class {
 	* @param context - Router context
 	* @param container - Request-scoped DI container
 	* @returns true if all guards pass
-	* @throws Error from first failing guard
+	* @throws {@link GuardRejectedError} if a guard's `canActivate` returns `false`, or the guard's
+	* own thrown error if it rejects by throwing instead
 	*/
 	async executeGuards(guards, context, container) {
 		if (guards.length === 0) return true;
@@ -117,11 +139,12 @@ var GuardExecutionService = class {
 			method: context.c.req.method
 		});
 		for (const guard of guards) if (!await this.resolveGuard(guard, container).canActivate(context)) {
+			const guardName = guard.constructor?.name || "AnonymousGuard";
 			this.logger.debug("Guard denied access", {
-				guard: guard.constructor?.name || "AnonymousGuard",
+				guard: guardName,
 				path: context.c.req.path
 			});
-			return false;
+			throw new GuardRejectedError(guardName);
 		}
 		this.logger.debug("All guards passed", {
 			guardCount: guards.length,
@@ -148,6 +171,6 @@ var GuardExecutionService = class {
 	}
 };
 //#endregion
-export { GUARD_METADATA_KEY as a, getMethodGuards as i, UseGuards as n, getControllerGuards as r, GuardExecutionService as t };
+export { GUARD_METADATA_KEY as a, getMethodGuards as i, UseGuards as n, GuardRejectedError as o, getControllerGuards as r, GuardExecutionService as t };
 
-//# sourceMappingURL=guards-DALPXy3_.mjs.map
+//# sourceMappingURL=guards-DOGly9IF.mjs.map

package/dist/guards-DOGly9IF.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"guards-DOGly9IF.mjs","names":[],"sources":["../src/guards/errors.ts","../src/guards/types.ts","../src/guards/use-guards.decorator.ts","../src/guards/guard-execution.service.ts"],"sourcesContent":["import { HttpException } from '../errors'\n\n/**\n * Thrown when a guard's `canActivate` returns `false`.\n *\n * HTTP Status: 403 Forbidden\n *\n * A guard denies by returning `false` or by throwing its own error; this class is what the\n * former becomes, so both paths surface as an exception the {@link ExceptionHandler} can render\n * and an application can match with `instanceof` or replace via `renderable()`. A guard that\n * needs a different status (401 for unauthenticated, 429 for a budget) should throw its own\n * `HttpException` instead — that is passed through untouched.\n */\nexport class GuardRejectedError extends HttpException {\n  constructor(public readonly guard: string) {\n    super(403, 'Forbidden')\n  }\n}\n","import type { RouterContext } from '../router'\nimport type { Constructor } from '../types'\n\n/**\n * Interface for guards that control access to routes\n *\n * Guards are executed after middlewares but before route handlers.\n * They determine if a request should be allowed to proceed.\n *\n * @example\n * ```typescript\n * class RoleGuard implements CanActivate {\n *   constructor(private readonly role: string) {}\n *\n *   async canActivate(context: RouterContext): Promise<boolean> {\n *     const user = context.getUser()\n *     return user?.roles.includes(this.role) ?? false\n *   }\n * }\n * ```\n */\nexport interface CanActivate {\n  /**\n   * Determine if the request should be allowed\n   *\n   * @param context - Router context with request/response helpers\n   * @returns true to allow, false to deny — a `false` is turned into a `GuardRejectedError`\n   * (HTTP 403) and thrown, so the handler never runs. To deny with a different status, throw your\n   * own `HttpException` instead; it is passed through untouched.\n   */\n  canActivate(context: RouterContext): boolean | Promise<boolean>\n}\n\n/**\n * Type for guard class constructors\n */\nexport type GuardClass = Constructor<CanActivate>\n\n/**\n * Guard can be a class constructor or an instance\n * Instances are used for factory-created guards with configuration\n */\nexport type Guard = GuardClass | CanActivate\n\n/**\n * Options for AuthGuard factory\n */\nexport interface AuthGuardOptions {\n  /**\n   * Required permissions for authorization as `\"resource:action\"` strings.\n   * If provided, permission check is performed after authentication.\n   * If omitted, only authentication is required.\n   *\n   * Multiple permissions are combined with AND logic (all must be satisfied).\n   *\n   * @example\n   * ```typescript\n   * @UseGuards(AuthGuard({ permissions: 'posts:update' }))\n   * @UseGuards(AuthGuard({ permissions: ['posts:update', 'posts:delete'] }))\n   * @UseGuards(AuthGuard({ permissions: 'admin:access' }))\n   * ```\n   */\n  permissions?: string | string[]\n}\n\n/**\n * Metadata stored by `@UseGuards` decorator\n */\nexport interface GuardMetadata {\n  guards: Guard[]\n}\n\n/**\n * Metadata key for guard storage\n */\nexport const GUARD_METADATA_KEY = Symbol.for('stratal:guards')\n","import { defineMetadata, getMetadata } from '../di/metadata'\nimport { GUARD_METADATA_KEY, type Guard, type GuardMetadata } from './types'\n\n/**\n * UseGuards Decorator\n *\n * Applies one or more guards to a controller or method.\n * Guards are executed in order and all must pass for the request to proceed.\n *\n * **Execution Order:**\n * 1. Request → Global Middlewares → Route Middlewares\n * 2. **Guards (controller-level, then method-level)**\n * 3. Route Handler\n *\n * **Guard Resolution:**\n * - Guard classes are resolved from the request-scoped DI container\n * - Guard instances (from factory functions) are used directly\n *\n * @param guards - Guard classes or instances to apply\n *\n * @example Authentication only\n * ```typescript\n * @Controller('/profile', { version: '1' })\n * @UseGuards(AuthGuard())\n * export class ProfileController {\n *   show() { } // Requires authentication\n * }\n * ```\n *\n * @example Authentication with permissions\n * ```typescript\n * @Controller('/students', { version: '1' })\n * @UseGuards(AuthGuard({ permissions: ['students:read'] }))\n * export class StudentsController {\n *   index() { } // Requires 'students:read' permission\n * }\n * ```\n *\n * @example Method-level guards\n * ```typescript\n * @Controller('/students', { version: '1' })\n * @UseGuards(AuthGuard()) // Controller-level: auth only\n * export class StudentsController {\n *   index() { } // Auth only (inherited)\n *\n *   @UseGuards(AuthGuard({ permissions: ['students:create'] }))\n *   create() { } // Auth + 'students:create' permission\n * }\n * ```\n *\n * @example Multiple guards\n * ```typescript\n * @UseGuards(AuthGuard(), RateLimitGuard(), CustomGuard())\n * export class SecureController {\n *   // All guards must pass\n * }\n * ```\n */\nexport function UseGuards(...guards: Guard[]): ClassDecorator & MethodDecorator {\n  return (target: object, propertyKey?: string | symbol) => {\n    const metadata: GuardMetadata = { guards }\n\n    if (propertyKey !== undefined) {\n      // Method decorator - store on method\n      defineMetadata(GUARD_METADATA_KEY, metadata, target, propertyKey)\n    } else {\n      // Class decorator - store on class\n      defineMetadata(GUARD_METADATA_KEY, metadata, target)\n    }\n  }\n}\n\n/**\n * Get controller-level guard metadata\n *\n * @param target - Controller class\n * @returns Guard metadata or undefined if not decorated\n */\nexport function getControllerGuards(target: object): GuardMetadata | undefined {\n  return getMetadata<GuardMetadata>(GUARD_METADATA_KEY, target)\n}\n\n/**\n * Get method-level guard metadata\n *\n * @param target - Controller prototype\n * @param propertyKey - Method name\n * @returns Guard metadata or undefined if not decorated\n */\nexport function getMethodGuards(target: object, propertyKey: string | symbol): GuardMetadata | undefined {\n  return getMetadata<GuardMetadata>(GUARD_METADATA_KEY, target, propertyKey)\n}\n","import type { Container } from '../di'\nimport type { LoggerService } from '../logger'\nimport type { RouterContext } from '../router'\nimport { GuardRejectedError } from './errors'\nimport type { CanActivate, Guard } from './types'\n\n/**\n * Guard Execution Service\n *\n * Executes guards for a route and determines if the request should proceed.\n * Guards are executed in order; all must pass for the request to proceed.\n */\nexport class GuardExecutionService {\n  constructor(private readonly logger: LoggerService) { }\n\n  /**\n   * Execute all guards for a route\n   *\n   * @param guards - Array of guards (classes or instances)\n   * @param context - Router context\n   * @param container - Request-scoped DI container\n   * @returns true if all guards pass\n   * @throws {@link GuardRejectedError} if a guard's `canActivate` returns `false`, or the guard's\n   * own thrown error if it rejects by throwing instead\n   */\n  async executeGuards(\n    guards: Guard[],\n    context: RouterContext,\n    container: Container\n  ): Promise<boolean> {\n    if (guards.length === 0) {\n      return true\n    }\n\n    this.logger.debug('Executing guards', {\n      guardCount: guards.length,\n      path: context.c.req.path,\n      method: context.c.req.method,\n    })\n\n    for (const guard of guards) {\n      const guardInstance = this.resolveGuard(guard, container)\n      const canActivate = await guardInstance.canActivate(context)\n\n      if (!canActivate) {\n        // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition -- guard.constructor may be null at runtime\n        const guardName = guard.constructor?.name || 'AnonymousGuard'\n\n        this.logger.debug('Guard denied access', {\n          guard: guardName,\n          path: context.c.req.path,\n        })\n        // Denial is an exception, not a return value: every caller awaits this without\n        // branching, so a `false` that merely returned would let the handler run and the guard\n        // would silently protect nothing.\n        throw new GuardRejectedError(guardName)\n      }\n    }\n\n    this.logger.debug('All guards passed', {\n      guardCount: guards.length,\n      path: context.c.req.path,\n    })\n\n    return true\n  }\n\n  /**\n   * Resolve a guard to an instance\n   *\n   * @param guard - Guard class or instance\n   * @param container - Request-scoped DI container\n   * @returns Guard instance\n   */\n  private resolveGuard(guard: Guard, container: Container): CanActivate {\n    // If already an instance (has canActivate method), use directly\n    if (this.isGuardInstance(guard)) {\n      return guard\n    }\n\n    // Otherwise, resolve from container\n    return container.resolve<CanActivate>(guard)\n  }\n\n  /**\n   * Type guard to check if value is a guard instance\n   */\n  private isGuardInstance(guard: Guard): guard is CanActivate {\n    return (\n      typeof guard === 'object' &&\n      // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition -- typeof null === 'object', null check is required\n      guard !== null &&\n      'canActivate' in guard &&\n      typeof guard.canActivate === 'function'\n    )\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;AAaA,IAAa,qBAAb,cAAwC,cAAc;CACxB;CAA5B,YAAY,OAA+B;EACzC,MAAM,KAAK,WAAW;EADI,KAAA,QAAA;CAE5B;AACF;;;;;;AC0DA,MAAa,qBAAqB,OAAO,IAAI,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;ACjB7D,SAAgB,UAAU,GAAG,QAAmD;CAC9E,QAAQ,QAAgB,gBAAkC;EACxD,MAAM,WAA0B,EAAE,OAAO;EAEzC,IAAI,gBAAgB,KAAA,GAElB,eAAe,oBAAoB,UAAU,QAAQ,WAAW;OAGhE,eAAe,oBAAoB,UAAU,MAAM;CAEvD;AACF;;;;;;;AAQA,SAAgB,oBAAoB,QAA2C;CAC7E,OAAO,YAA2B,oBAAoB,MAAM;AAC9D;;;;;;;;AASA,SAAgB,gBAAgB,QAAgB,aAAyD;CACvG,OAAO,YAA2B,oBAAoB,QAAQ,WAAW;AAC3E;;;;;;;;;AC/EA,IAAa,wBAAb,MAAmC;CACJ;CAA7B,YAAY,QAAwC;EAAvB,KAAA,SAAA;CAAyB;;;;;;;;;;;CAYtD,MAAM,cACJ,QACA,SACA,WACkB;EAClB,IAAI,OAAO,WAAW,GACpB,OAAO;EAGT,KAAK,OAAO,MAAM,oBAAoB;GACpC,YAAY,OAAO;GACnB,MAAM,QAAQ,EAAE,IAAI;GACpB,QAAQ,QAAQ,EAAE,IAAI;EACxB,CAAC;EAED,KAAK,MAAM,SAAS,QAIlB,IAAI,CAAC,MAHiB,KAAK,aAAa,OAAO,SACT,CAAC,CAAC,YAAY,OAAO,GAEzC;GAEhB,MAAM,YAAY,MAAM,aAAa,QAAQ;GAE7C,KAAK,OAAO,MAAM,uBAAuB;IACvC,OAAO;IACP,MAAM,QAAQ,EAAE,IAAI;GACtB,CAAC;GAID,MAAM,IAAI,mBAAmB,SAAS;EACxC;EAGF,KAAK,OAAO,MAAM,qBAAqB;GACrC,YAAY,OAAO;GACnB,MAAM,QAAQ,EAAE,IAAI;EACtB,CAAC;EAED,OAAO;CACT;;;;;;;;CASA,aAAqB,OAAc,WAAmC;EAEpE,IAAI,KAAK,gBAAgB,KAAK,GAC5B,OAAO;EAIT,OAAO,UAAU,QAAqB,KAAK;CAC7C;;;;CAKA,gBAAwB,OAAoC;EAC1D,OACE,OAAO,UAAU,YAEjB,UAAU,QACV,iBAAiB,SACjB,OAAO,MAAM,gBAAgB;CAEjC;AACF"}