@forinda/kickjs 5.16.0 → 5.18.0-alpha.0

package/dist/index-frSEHiL_.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index-frSEHiL_.d.mts","names":[],"sources":["../src/core/define-plugin.ts","../src/core/define-module.ts","../src/core/define-modules.ts","../src/core/kick-error.ts","../src/core/metadata.ts","../src/core/circuit-breaker.ts","../src/core/context-errors.ts","../src/core/contributor-pipeline.ts","../src/core/contributor-runner.ts","../src/core/mount-sort.ts","../src/core/define-adapter.ts","../src/core/asset-keys.ts"],"mappings":";;;;;;;;;;;;UAOiB,mBAAA;;EAEf,IAAA;;EAGA,OAAA;;;AALF;;EAWE,QAAA;IAAa,MAAA;EAAA;EAMC;EAHd,QAAA,GAAW,OAAA,CAAQ,OAAA;EAG6B;EAAhD,KAAA,CAAM,MAAA,EAAQ,OAAA,EAAS,GAAA,EAAK,YAAA,GAAe,IAAA,CAAK,UAAA;AAAA;;;;;;;UASjC,YAAA;EACf,IAAA;EACA,MAAM;AAAA;;;;;;;;AAXoD;AAS5D;UAciB,kBAAA;EACf,MAAA,GAAS,aAAA;EACT,UAAA,IAAc,IAAA,UAAc,OAAA,GAAU,OAAA,CAAQ,OAAA;AAAA;AAFhD;;;;;AAAA,UAUiB,aAAA;EAAA,CACd,MAAA,GAAS,OAAA,CAAQ,OAAA,IAAW,UAAA;EAC7B,MAAA,CAAO,SAAA,UAAmB,MAAA,GAAS,OAAA,CAAQ,OAAA,IAAW,UAAA;EACtD,KAAA,CAAM,IAAA,EAAM,kBAAA,CAAmB,OAAA,IAAW,UAAA;EAbR;EAAA,SAezB,UAAA,EAAY,QAAA,CAAS,mBAAA,CAAoB,OAAA;AAAA;;;;;;;AAbG;AAQvD;;;;;;;;;;;;;;iBAoCgB,YAAA,WAAuB,MAAA,mBACrC,OAAA,EAAS,mBAAA,CAAoB,OAAA,IAC5B,aAAA,CAAc,OAAA;;;;;;;;;;;;;UClFA,mBAAA;EDNmB;;;;;;ECalC,IAAA;EDI2C;ECF3C,OAAA;EDE+C;;;;;ECI/C,QAAA;IAAa,MAAA;EAAA;EDPM;;;;ECYnB,QAAA,GAAW,OAAA,CAAQ,OAAA;EDTI;;;;AAAmC;AAS5D;;;;AAEQ;AAYR;ECFE,KAAA,CAAM,MAAA,EAAQ,OAAA,EAAS,GAAA,EAAK,YAAA,GAAe,SAAA,GAAY,MAAA;AAAA;;;;;;;;;;;;;UAexC,aAAA;EAAA,CACd,MAAA,GAAS,OAAA,CAAQ,OAAA,IAAW,SAAA,GAAY,MAAA;EACzC,MAAA,CAAO,SAAA,UAAmB,MAAA,GAAS,OAAA,CAAQ,OAAA,IAAW,SAAA,GAAY,MAAA;EAAA,SACzD,UAAA,EAAY,QAAA,CAAS,mBAAA,CAAoB,OAAA,EAAS,MAAA;AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;ADDF;AA+B3D;;;;iBCsBgB,YAAA,WAAuB,MAAA,qCACrC,OAAA,EAAS,mBAAA,CAAoB,OAAA,EAAS,MAAA,IACrC,aAAA,CAAc,OAAA,EAAS,MAAA;;;;;;;;;;;;;;AD9G1B;;;;;;;;;;;;;;cEoBa,UAAA,SAAmB,KAAA,CAAM,cAAA;EFTvB;;;;;;;;EEkBb,KAAA,CAAM,MAAA,EAAQ,cAAA;AAAA;;;AFZ4C;AAS5D;;;;AAEQ;AAYR;;;;;;;;;;;;;;;;;;AAEuD;AAQvD;iBEagB,aAAA,IAAiB,OAAA,EAAS,cAAA,KAAmB,UAAU;;;;;;;;;;;;;;;AF/DvE;;;;;UGUiB,aAAA;EHOa;EGL5B,IAAA;EHK2C;EGH3C,OAAA;EHG+C;EGD/C,KAAA;EHdA;EGgBA,GAAA;EHPA;EGSA,OAAA;EHNA;EGQA,OAAA,GAAU,MAAM;AAAA;AAAA,cAGL,SAAA,SAAkB,KAAA;EAAA,SACb,IAAA;EAAA,SACA,OAAA;EAAA,SACA,KAAA;EAAA,SACA,GAAA;EAAA,SACA,OAAA;EAAA,SACA,OAAA,GAAU,MAAA;EAE1B,WAAA,CAAY,IAAA,EAAM,aAAA;AAAA;AAAA,UAiDH,sBAAA;EHxDY;;;AAErB;AAYR;EGgDE,KAAK;AAAA;;;;;;iBAQS,eAAA,CACd,GAAA,EAAK,aAAA,GAAgB,SAAA,EACrB,OAAA,GAAS,sBAAA;;;;;;;;;;;;;AHlGX;KIQK,OAAA,qBAA4B,cAAc;;iBAK/B,YAAA,IAAgB,GAAA,EAAK,OAAA,EAAS,KAAA,EAAO,CAAC,EAAE,MAAA;;iBAKxC,aAAA,IAAiB,GAAA,EAAK,OAAA,EAAS,KAAA,EAAO,CAAC,EAAE,MAAA,UAAgB,MAAA;;iBAOzD,YAAA,IAAgB,GAAA,EAAK,OAAA,EAAS,MAAA,UAAgB,QAAA,EAAU,CAAA,GAAI,CAAA;;iBAK5D,aAAA,IAAiB,GAAA,EAAK,OAAA,EAAS,MAAA,UAAgB,MAAA,UAAgB,QAAA,EAAU,CAAA,GAAI,CAAA;;iBAK7E,YAAA,CAAa,GAAA,EAAK,OAAO,EAAE,MAAA;;iBAK3B,uBAAA,IAA2B,GAAA,EAAK,OAAA,EAAS,MAAA,WAAiB,CAAC;;iBAK3D,wBAAA,IACd,GAAA,EAAK,OAAA,EACL,MAAA,UACA,MAAA,WACC,CAAC;;iBAOY,aAAA,IAAiB,GAAA,EAAK,OAAA,EAAS,MAAA,aAAmB,KAAA,EAAO,CAAC;;iBAM1D,cAAA,IACd,GAAA,EAAK,OAAA,EACL,MAAA,UACA,MAAA,aACG,KAAA,EAAO,CAAC;;iBASG,YAAA,OAAmB,GAAA,EAAK,OAAA,EAAS,MAAA,UAAgB,MAAA,EAAQ,CAAA,EAAG,QAAA,EAAU,CAAA;;iBAQtE,UAAA,OAAiB,GAAA,EAAK,OAAA,EAAS,MAAA,WAAiB,GAAA,CAAI,CAAA,EAAG,CAAA;;iBAOvD,eAAA,IACd,GAAA,EAAK,OAAA,EACL,MAAA,UACA,MAAA,mBACA,QAAA,EAAU,CAAC;;iBASG,aAAA,IAAiB,GAAA,EAAK,OAAA,EAAS,MAAA,WAAiB,MAAA,kBAAwB,CAAA;;;;;;;;;;;;;;;AJvGxF;;;;;KKWY,mBAAA;AAAA,UAEK,qBAAA;ELIiC;EKFhD,gBAAA;ELE+C;EKA/C,YAAA;ELjBmC;EKmBnC,WAAA;AAAA;AAAA,UAGe,mBAAA;EACf,QAAA;EACA,SAAA;EACA,KAAA,EAAO,mBAAA;EACP,WAAA,GAAc,IAAI;AAAA;;;;cAMP,gBAAA,SAAyB,KAAK;EAAA,SACb,WAAA;EAA5B,WAAA,CAA4B,WAAA;AAAA;AAAA,cAMjB,cAAA;EAAA,SAaO,IAAA;EAAA,QAZV,KAAA;EAAA,QACA,QAAA;EAAA,QACA,SAAA;EAAA,QACA,gBAAA;EAAA,QACA,WAAA;EAAA,QACA,QAAA;EAAA,iBAES,gBAAA;EAAA,iBACA,YAAA;EAAA,iBACA,WAAA;EAEjB,WAAA,CACkB,IAAA,UAChB,OAAA,EAAS,qBAAA;ELX2B;;;;EKsBhC,OAAA,IAAW,EAAA,QAAU,OAAA,CAAQ,CAAA,IAAK,OAAA,CAAQ,CAAA;ELvBvC;EKiDT,QAAA,IAAY,mBAAA;ELhDE;EKsDd,QAAA,IAAY,mBAAA;ELtD0B;EKiEtC,KAAA;EAAA,QASQ,SAAA;EAAA,QAWA,SAAA;EAAA,QAeA,yBAAA;AAAA;;;;;;;;;;;;;;;AL9IV;;;;;;;cMaa,uBAAA,SAAgC,KAAK;EAAA,SACvC,GAAA;EAAA,SACA,SAAA;EAAA,SACA,KAAA;EAAA,SACA,kBAAA;EAET,WAAA,CAAY,GAAA,UAAa,SAAA,UAAmB,KAAA,WAAgB,kBAAA;AAAA;;;;;;;;;;;cA2CjD,qBAAA,SAA8B,KAAK;EAAA,SACrC,KAAA;EAAA,SACA,KAAA;EAET,WAAA,CAAY,KAAA,qBAA0B,KAAA;AAAA;;;;ANtChC;AAYR;;;;;;;;;;;;;cMoDa,yBAAA,SAAkC,KAAK;EAAA,SACzC,GAAA;EAAA,SACA,OAAA;EAET,WAAA,CAAY,GAAA,UAAa,OAAA;AAAA;;;;;;;;;;;;;;ANhG3B;KOYY,iBAAA;;;;;;;;;;;;;;UAwBK,mBAAA;EACf,YAAA,EAAc,0BAAA;EACd,MAAA,EAAQ,iBAAiB;EPxBN;EO0BnB,KAAA;AAAA;;;;;;;APvB0D;AAS5D;UOyBiB,mBAAA;EAAA,SACN,YAAA,WAAuB,0BAAA;EAAA,SACvB,IAAA,EAAM,WAAW;AAAA;AAAA,UAGX,oBAAA;EPhBkB;EOkBjC,KAAK;AAAA;;;;;;;;;;;;;;;APhBgD;AAQvD;;;;;iBO+BgB,aAAA,CACd,OAAA,WAAkB,mBAAA,IAClB,OAAA,GAAS,oBAAA,GACR,mBAAA;;;UCtFc,sBAAA;;EAEf,QAAA,EAAU,mBAAA;;EAEV,GAAA,EAAK,gBAAA;;EAEL,SAAA,EAAW,SAAA;AAAA;;ARJb;;;;;;;;;;;;;;;;;;;;;;;iBQ+BsB,eAAA,CAAgB,OAAA,EAAS,sBAAA,GAAyB,OAAO;;;;;;;;;;;;;;;AR/B/E;;;;;AAAA,USWiB,aAAA;ETMa;ESJ5B,IAAA;ETI2C;;;;;ESE3C,SAAS;AAAA;;KAIC,SAAA;;;;;cAMC,uBAAA,SAAgC,KAAA;EAAA,SAClC,IAAA,EAAM,SAAA;EAAA,SACN,SAAA;EAET,WAAA,CAAY,IAAA,EAAM,SAAA,EAAW,SAAA;AAAA;;AThB6B;AAS5D;;;;cSqBa,oBAAA,SAA6B,KAAA;EAAA,SAC/B,IAAA,EAAM,SAAA;EAAA,SACN,OAAA;EAAA,SACA,SAAA;EAET,WAAA,CAAY,IAAA,EAAM,SAAA,EAAW,OAAA,UAAiB,SAAA;AAAA;;;;;;cAiBnC,eAAA,SAAwB,KAAA;EAAA,SAC1B,IAAA,EAAM,SAAA;EAAA,SACN,KAAA;EAET,WAAA,CAAY,IAAA,EAAM,SAAA,EAAW,KAAA;AAAA;;;;AT/BwB;AAQvD;;;;;;;;;;iBS6CgB,SAAA,WAAoB,aAAA,EAAe,KAAA,WAAgB,CAAA,IAAK,IAAA,EAAM,SAAA,GAAY,CAAA;;;;;;;;;;;;;AT/F1F;UUOiB,oBAAA;EVPmB;;;;;EUalC,IAAA;EACA,OAAA;EACA,QAAA;IAAa,MAAA;EAAA;EACb,QAAA,GAAW,OAAA,CAAQ,OAAA;EACnB,KAAA,CAAM,MAAA,EAAQ,OAAA,EAAS,GAAA,EAAK,YAAA,GAAe,IAAA,CAAK,UAAA,YAAsB,MAAA;AAAA;;;;;;;;UAUvD,mBAAA;EACf,MAAA,GAAS,aAAA;EACT,UAAA,IAAc,IAAA,UAAc,OAAA,GAAU,OAAA,CAAQ,OAAA;AAAA;;AVZY;AAS5D;;;;AAEQ;UUWS,cAAA;EAAA,CACd,MAAA,GAAS,OAAA,CAAQ,OAAA,IAAW,UAAA,GAAa,MAAA;EAC1C,MAAA,CAAO,SAAA,UAAmB,MAAA,GAAS,OAAA,CAAQ,OAAA,IAAW,UAAA,GAAa,MAAA;EACnE,KAAA,CAAM,IAAA,EAAM,mBAAA,CAAoB,OAAA,IAAW,UAAA;EAAA,SAClC,UAAA,EAAY,QAAA,CAAS,oBAAA,CAAqB,OAAA,EAAS,MAAA;AAAA;;;;;;;;;;;;;AVDP;AAQvD;;;;;;;;;;;;iBU4BgB,aAAA,WAAwB,MAAA,qCACtC,OAAA,EAAS,oBAAA,CAAqB,OAAA,EAAS,MAAA,IACtC,cAAA,CAAe,OAAA,EAAS,MAAA;;;KChEf,gBAAA;AAAA,UAEK,YAAA;;EAEf,GAAA;;EAEA,GAAG;AAAA;AAAA,UAGY,qBAAA;;;;;AXzBjB;;;EWiCE,QAAA,GAAW,gBAAgB;AAAA;AAAA,UAGZ,oBAAA;EACf,KAAA,EAAO,YAAY;EXpB6B;;;;;;;EW4BhD,uBAAA;AAAA;;;;;;;;;;;iBAac,cAAA,CACd,SAAA,UACA,KAAA,qBACA,IAAA,GAAM,qBAAA,GACL,oBAAoB;AX7CqC;AAAA,iBWwG5C,QAAA,CAAS,IAAY"}

package/dist/plugin-BQCn6zyj.d.mts

@@ -1,260 +0,0 @@
-
-import { t as Container } from "./container-TWOUyR_0.mjs";
-import { s as ContributorRegistrations } from "./context-decorator-DDZ30BIW.mjs";
-import { c as KickJsPluginName, p as IntrospectionSnapshot, r as AppAdapter } from "./adapter-CkpcZwzZ.mjs";
-import { r as AppModuleEntry } from "./app-module-BTzb-Vd6.mjs";
-
-//#region src/core/module-registry.d.ts
-/**
- * Imperative receiver passed to {@link KickPlugin.setup} and the
- * top-level `bootstrap({ setup })` callback so adopters can register
- * modules conditionally — based on env flags, runtime config,
- * tenant lists, etc. — instead of being limited to the static
- * `modules: [...]` array.
- *
- * @example
- * ```ts
- * bootstrap({
- *   modules: [HelloModule()],          // static — always mounted
- *   setup(registry) {
- *     if (env.ENABLE_ADMIN) registry.mount(AdminModule())
- *     for (const tenant of env.TENANTS) {
- *       registry.mount(TenantModule.scoped(tenant.id, { id: tenant.id }))
- *     }
- *   },
- * })
- * ```
- *
- * **Currently exposes only `.mount(module)` — the HTTP-feature path.**
- * A future `.use(module)` for non-HTTP modules (queues, cron, workers,
- * DI-only seeds) is planned but not yet implemented; existing non-HTTP
- * modules continue returning `null` from `routes()` and registering
- * via `.mount()`.
- *
- * Same dispatch rules as the static `modules: [...]` array — class
- * entries get `new`-ed at boot, `defineModule` factory output is used
- * directly. The registry doesn't validate the entry shape itself; the
- * Application loader does the typeof discrimination at mount time.
- */
-interface ModuleRegistry {
-  /**
-   * Register a module for the full HTTP lifecycle: `register()` runs,
-   * `import.meta.glob` decorator side-effects fire, `routes()` is
-   * called and its result mounted, `contributors()` are merged at
-   * `'module'` precedence and applied to the mounted routes.
-   *
-   * Modules are mounted in registration order (first call → first
-   * mount). Order across sources is: plugin static modules → plugin
-   * `setup()` calls → user static modules → user `setup()` callback.
-   */
-  mount(module: AppModuleEntry): void;
-}
-/**
- * Internal collector implementing {@link ModuleRegistry}. Application
- * passes one of these to every `setup()` callback during bootstrap;
- * the collected `entries` array is then run through the same
- * class-vs-instance dispatch as the static `modules: [...]` array.
- *
- * Not exported from the public surface — adopters interact only
- * through the {@link ModuleRegistry} interface.
- */
-declare class MutableModuleRegistry implements ModuleRegistry {
-  readonly entries: AppModuleEntry[];
-  mount(module: AppModuleEntry): void;
-}
-//#endregion
-//#region src/core/plugin.d.ts
-/**
- * Plugin interface for extending KickJS applications.
- *
- * Plugins bundle modules, adapters, middleware, and DI bindings into a single
- * reusable unit. They run before the application bootstraps, so they can
- * register services and configure the app before any module loads.
- *
- * @example
- * ```ts
- * import type { KickPlugin } from '@forinda/kickjs'
- *
- * export class CorsPlugin implements KickPlugin {
- *   name = 'CorsPlugin'
- *
- *   middleware() {
- *     return [cors({ origin: '*' })]
- *   }
- * }
- *
- * // Usage:
- * bootstrap({
- *   modules,
- *   plugins: [new CorsPlugin()],
- * })
- * ```
- *
- * @example
- * ```ts
- * // A more complex plugin that bundles modules and adapters
- * export class AuthPlugin implements KickPlugin {
- *   name = 'AuthPlugin'
- *
- *   constructor(private config: AuthConfig) {}
- *
- *   register(container: Container) {
- *     container.registerFactory(AUTH_SERVICE, () => new JwtAuthService(this.config))
- *   }
- *
- *   modules() {
- *     return [AuthModule]
- *   }
- *
- *   adapters() {
- *     return [new AuthGuardAdapter(this.config)]
- *   }
- *
- *   middleware() {
- *     return [passport.initialize()]
- *   }
- * }
- * ```
- */
-interface KickPlugin {
-  /** Human-readable name for logging, debugging, and `dependsOn` resolution. */
-  name: string;
-  /**
-   * Other plugin names that must mount before this one. The framework
-   * topologically sorts plugins at boot — cycles or unknown names throw
-   * via {@link MountCycleError} / {@link MissingMountDepError} so bad
-   * configurations fail boot rather than corrupt live traffic.
-   *
-   * Plugins with no `dependsOn` retain their declaration order, so
-   * existing apps that don't use this field see no behaviour change.
-   *
-   * @example
-   * ```ts
-   * class MonitoringPlugin implements KickPlugin {
-   *   name = 'MonitoringPlugin'
-   *   // OTel must initialize traces before request logger reads them
-   *   dependsOn = ['OtelPlugin']
-   * }
-   * ```
-   */
-  dependsOn?: readonly KickJsPluginName[];
-  /**
-   * Register DI bindings before modules load.
-   * Use this to provide services that modules depend on.
-   */
-  register?(container: Container): void;
-  /**
-   * Return modules to be loaded alongside user modules. Plugin
-   * modules are loaded before user modules.
-   *
-   * Accepts both class form (`SomeModule extends AppModule`) and
-   * instance form (output of {@link defineModule}'s factory call,
-   * e.g. `TasksModule({ scope: 'admin' })`) — the bootstrap loader
-   * discriminates and either `new`-s the class or uses the instance
-   * directly.
-   *
-   * Static path — for conditional / dynamic registration, use
-   * {@link KickPlugin.setup} instead.
-   */
-  modules?(): AppModuleEntry[];
-  /**
-   * Imperative module registration hook. Receives a {@link ModuleRegistry}
-   * the plugin can call `.mount(module)` on to register modules
-   * conditionally — e.g. based on injected config, env flags, or a
-   * tenant list resolved at boot.
-   *
-   * Runs after the static {@link KickPlugin.modules} array is collected
-   * but before user modules and the user-level `setup()` callback. The
-   * plugin sees the same dispatch rules as everything else: class
-   * entries get `new`-ed, factory output is used directly.
-   *
-   * @example
-   * ```ts
-   * definePlugin<{ tenants: string[] }>({
-   *   name: 'MultiTenantPlugin',
-   *   build: (config) => ({
-   *     setup(registry) {
-   *       for (const tenant of config.tenants) {
-   *         registry.mount(TenantModule.scoped(tenant, { id: tenant }))
-   *       }
-   *     },
-   *   }),
-   * })
-   * ```
-   */
-  setup?(registry: ModuleRegistry): void;
-  /**
-   * Return adapter instances to be added to the application.
-   * Plugin adapters are added before user adapters.
-   */
-  adapters?(): AppAdapter[];
-  /**
-   * Return Express middleware to be added to the global pipeline.
-   * Plugin middleware runs before user-defined middleware.
-   */
-  middleware?(): any[];
-  /**
-   * Return Context Contributors (#107) the plugin ships. Contributors
-   * returned here merge into the per-route pipeline at the **`'adapter'`
-   * precedence level** — same as those returned by adapters the plugin
-   * ships via {@link KickPlugin.adapters}, and for the same reason: a
-   * plugin is a cross-cutting bundle, narrower than the global default
-   * but broader than a per-module hook.
-   *
-   * Use when a plugin wants to ship a typed contributor without standing
-   * up an accompanying adapter. For full coverage of the precedence
-   * matrix (method > class > module > adapter > global) see
-   * `docs/guide/context-decorators.md`.
-   *
-   * @example
-   * ```ts
-   * import { defineContextDecorator, type KickPlugin } from '@forinda/kickjs'
-   *
-   * const LoadFlags = defineContextDecorator({
-   *   key: 'flags',
-   *   resolve: (ctx) => fetchFlags(ctx.requestId!),
-   * })
-   *
-   * export class FlagsPlugin implements KickPlugin {
-   *   name = 'FlagsPlugin'
-   *   contributors() {
-   *     return [LoadFlags.registration]
-   *   }
-   * }
-   * ```
-   */
-  contributors?(): ContributorRegistrations;
-  /**
-   * Called after the application has fully bootstrapped.
-   * Use for post-startup logic like logging, health registration, etc.
-   */
-  onReady?(container: Container): void | Promise<void>;
-  /**
-   * Called during application shutdown.
-   * Clean up plugin resources (connections, intervals, etc.).
-   */
-  shutdown?(): void | Promise<void>;
-  /**
-   * Optional DevTools introspection hook (architecture.md §23). Returns
-   * a snapshot describing this plugin's current state, metrics, and DI
-   * tokens. DevTools awaits the result, so async work is fine — but keep
-   * the implementation cheap (counters + flags, no DB round trips) since
-   * the topology endpoint polls on a short interval.
-   *
-   * The return type lives in `@forinda/kickjs` itself
-   * ({@link IntrospectionSnapshot}) so adopters can author `introspect()`
-   * without importing the kit just to satisfy the contract. The kit's
-   * own `IntrospectionSnapshot` type stays structurally identical;
-   * either import works.
-   */
-  introspect?(): IntrospectionSnapshot | Promise<IntrospectionSnapshot>;
-  /**
-   * Optional DevTools tabs this plugin contributes (architecture.md §23).
-   * Same shape as {@link AppAdapter.devtoolsTabs}; the kit's
-   * `DevtoolsTabDescriptor` types it for plugin authors.
-   */
-  devtoolsTabs?(): readonly unknown[];
-}
-//#endregion
-export { ModuleRegistry as n, MutableModuleRegistry as r, KickPlugin as t };
-//# sourceMappingURL=plugin-BQCn6zyj.d.mts.map

package/dist/plugin-BQCn6zyj.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"plugin-BQCn6zyj.d.mts","names":[],"sources":["../src/core/module-registry.ts","../src/core/plugin.ts"],"mappings":";;;;;;;;;;;;AAiCA;;;;;;;;AAW8B;AAY9B;;;;;;;;;;;;;;;AAG8B;;UA1Bb,cAAA;;AC2BjB;;;;;;;;;EDhBE,KAAA,CAAM,MAAA,EAAQ,cAAc;AAAA;;;;;;;;;;cAYjB,qBAAA,YAAiC,cAAA;EAAA,SACnC,OAAA,EAAS,cAAA;EAElB,KAAA,CAAM,MAAA,EAAQ,cAAA;AAAA;;;;;;;;;;AAfc;AAY9B;;;;;;;;;;;;;;;AAG8B;;;;ACC9B;;;;;;;;;;;;;;;;;;;;;;;;;UAAiB,UAAA;EAsEE;EApEjB,IAAA;EA0EA;;;;;;;;;;;;;;;;;AAwEY;EA9HZ,SAAA,YAAqB,gBAAA;;;;;EAMrB,QAAA,EAAU,SAAA,EAAW,SAAA;;;;;;;;;;;;;;EAerB,OAAA,KAAY,cAAA;;;;;;;;;;;;;;;;;;;;;;;;;;EA2BZ,KAAA,EAAO,QAAA,EAAU,cAAA;;;;;EAMjB,QAAA,KAAa,UAAA;;;;;EAMb,UAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAgCA,YAAA,KAAiB,wBAAA;;;;;EAMjB,OAAA,EAAS,SAAA,EAAW,SAAA,UAAmB,OAAA;;;;;EAMvC,QAAA,YAAoB,OAAA;;;;;;;;;;;;;;EAepB,UAAA,KAAe,qBAAA,GAAwB,OAAA,CAAQ,qBAAA;;;;;;EAO/C,YAAA;AAAA"}

package/dist/query-D-FiLfmd.mjs

@@ -1,12 +0,0 @@
-/**
- * @forinda/kickjs v5.16.0
- *
- * Copyright (c) Felix Orinda
- *
- * This source code is licensed under the MIT license found in the
- * LICENSE file in the root directory of this source tree.
- *
- * @license MIT
- */
-const FILTER_OPERATORS=new Set([`eq`,`neq`,`gt`,`gte`,`lt`,`lte`,`between`,`in`,`contains`,`starts`,`ends`]);function parseFilters(filterParam,allowedFields){if(!filterParam)return[];let items=Array.isArray(filterParam)?filterParam:[filterParam],results=[],allowed=allowedFields?new Set(allowedFields):null;for(let item of items){let firstColon=item.indexOf(`:`);if(firstColon===-1)continue;let secondColon=item.indexOf(`:`,firstColon+1);if(secondColon===-1)continue;let field=item.slice(0,firstColon),operator=item.slice(firstColon+1,secondColon),value=item.slice(secondColon+1);!field||!value||FILTER_OPERATORS.has(operator)&&(allowed&&!allowed.has(field)||results.push({field,operator,value}))}return results}function parseSort(sortParam,allowedFields){if(!sortParam)return[];let items=Array.isArray(sortParam)?sortParam:[sortParam],results=[],allowed=allowedFields?new Set(allowedFields):null;for(let item of items){let lastColon=item.lastIndexOf(`:`);if(lastColon===-1)continue;let field=item.slice(0,lastColon),dir=item.slice(lastColon+1).toLowerCase();field&&(dir!==`asc`&&dir!==`desc`||allowed&&!allowed.has(field)||results.push({field,direction:dir}))}return results}function parsePagination(params){let page=typeof params.page==`string`?Number.parseInt(params.page,10):params.page??1,limit=typeof params.limit==`string`?Number.parseInt(params.limit,10):params.limit??20;return(Number.isNaN(page)||page<1)&&(page=1),(Number.isNaN(limit)||limit<1)&&(limit=20),limit>100&&(limit=100),{page,limit,offset:(page-1)*limit}}function parseSearchQuery(q){return q?q.trim().slice(0,200):``}function normalizeFieldConfig(config){if(config)return`columns`in config&&config.columns&&typeof config.columns==`object`?{filterable:Object.keys(config.columns),sortable:config.sortable?Object.keys(config.sortable):void 0,searchable:void 0}:config}function parseQuery(query,fieldConfig){let normalized=normalizeFieldConfig(fieldConfig);return{filters:parseFilters(query.filter,normalized?.filterable),sort:parseSort(query.sort,normalized?.sortable),pagination:parsePagination({page:query.page,limit:query.limit}),search:parseSearchQuery(query.q)}}function buildQueryParams(parsed){let params={};return parsed.filters?.length&&(params.filter=parsed.filters.map(f=>`${f.field}:${f.operator}:${f.value}`)),parsed.sort?.length&&(params.sort=parsed.sort.map(s=>`${s.field}:${s.direction}`)),parsed.pagination&&(params.page=parsed.pagination.page,params.limit=parsed.pagination.limit),parsed.search&&(params.q=parsed.search),params}export{parseSearchQuery as a,parseQuery as i,parseFilters as n,parseSort as o,parsePagination as r,FILTER_OPERATORS as s,buildQueryParams as t};
-//# sourceMappingURL=query-D-FiLfmd.mjs.map

package/dist/query-D-FiLfmd.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"query-D-FiLfmd.mjs","names":[],"sources":["../src/http/query/types.ts","../src/http/query/parse-query.ts"],"sourcesContent":["/** Supported filter operators for query string parsing */\nexport type FilterOperator =\n  | 'eq'\n  | 'neq'\n  | 'gt'\n  | 'gte'\n  | 'lt'\n  | 'lte'\n  | 'between'\n  | 'in'\n  | 'contains'\n  | 'starts'\n  | 'ends'\n\nexport const FILTER_OPERATORS = new Set<string>([\n  'eq',\n  'neq',\n  'gt',\n  'gte',\n  'lt',\n  'lte',\n  'between',\n  'in',\n  'contains',\n  'starts',\n  'ends',\n])\n\nexport interface FilterItem {\n  field: string\n  operator: FilterOperator\n  value: string\n}\n\nexport interface SortItem {\n  field: string\n  direction: 'asc' | 'desc'\n}\n\nexport interface PaginationParams {\n  page: number\n  limit: number\n  offset: number\n}\n\n/**\n * The result of parsing a query string. ORM-agnostic — pass this to\n * a query builder adapter (Drizzle, Prisma, Sequelize, etc.) to produce\n * database-specific query objects.\n */\nexport interface ParsedQuery {\n  filters: FilterItem[]\n  sort: SortItem[]\n  pagination: PaginationParams\n  search: string\n}\n\n/**\n * Helper that extracts the literal field union from a `QueryFieldConfig`\n * key. When the user passes `{ filterable: ['status', 'category'] } as const`,\n * `FieldsOf<typeof config, 'filterable'>` resolves to `'status' | 'category'`.\n *\n * Without `as const`, the arrays widen to `string[]` and the union falls\n * back to `string`. This is the documented escape hatch.\n */\nexport type FieldsOf<\n  TConfig extends QueryFieldConfig | undefined,\n  K extends 'filterable' | 'sortable' | 'searchable',\n> = TConfig extends { readonly [P in K]: readonly (infer F)[] }\n  ? F extends string\n    ? F\n    : string\n  : TConfig extends { columns: infer C }\n    ? K extends 'filterable'\n      ? keyof C & string\n      : string\n    : string\n\n/**\n * Narrowed `ParsedQuery` whose `filters[].field` and `sort[].field`\n * unions are constrained to the literal whitelist passed to\n * `ctx.qs()` / `parseQuery()`. Extends `ParsedQuery`, so any function\n * accepting `ParsedQuery` accepts a `TypedParsedQuery<X>` automatically\n * (subtype assignment, no codegen, backward compatible).\n *\n * @example\n * ```ts\n * const parsed = ctx.qs({\n *   filterable: ['status', 'priority'],\n *   sortable: ['createdAt'],\n * } as const)\n * parsed.filters[0]?.field // 'status' | 'priority'\n * parsed.sort[0]?.field    // 'createdAt'\n * ```\n */\nexport interface TypedParsedQuery<\n  TConfig extends QueryFieldConfig | undefined,\n> extends ParsedQuery {\n  filters: Array<FilterItem & { field: FieldsOf<TConfig, 'filterable'> }>\n  sort: Array<SortItem & { field: FieldsOf<TConfig, 'sortable'> }>\n}\n\n/**\n * Restrict which fields can be filtered, sorted, or searched.\n * Fields not in the allow-list are silently ignored.\n *\n * Accepts two forms:\n * 1. **String arrays** (standard): `{ filterable: ['name', 'status'], sortable: ['createdAt'] }`\n * 2. **Column-object maps** (Drizzle-style): `{ columns: { name: col, status: col }, sortable: { createdAt: col } }`\n *\n * When column-object maps are provided, `Object.keys()` is used to derive the field names.\n */\nexport type QueryFieldConfig = StringQueryFieldConfig | ColumnQueryFieldConfig\n\nexport interface StringQueryFieldConfig {\n  filterable?: string[]\n  sortable?: string[]\n  searchable?: string[]\n}\n\n/**\n * Column-object-based field config (e.g., from DrizzleQueryParamsConfig).\n * Keys are the field names used in query strings; values are ORM column references.\n */\nexport interface ColumnQueryFieldConfig {\n  columns: Record<string, any>\n  sortable?: Record<string, any>\n  searchColumns?: any[]\n  [key: string]: any\n}\n\n/** Standardized paginated response shape */\nexport interface PaginatedResponse<T = any> {\n  data: T[]\n  meta: {\n    page: number\n    limit: number\n    total: number\n    totalPages: number\n    hasNext: boolean\n    hasPrev: boolean\n  }\n}\n\n/**\n * Interface for ORM-specific query builder adapters.\n * Implement this to translate a `ParsedQuery` into your ORM's query format.\n *\n * @example\n * ```ts\n * // Drizzle adapter\n * class DrizzleQueryAdapter implements QueryBuilderAdapter<DrizzleQueryResult> {\n *   build(parsed: ParsedQuery, config: DrizzleConfig): DrizzleQueryResult {\n *     // Convert filters → Drizzle SQL conditions\n *     // Convert sort → Drizzle orderBy\n *     return { where, orderBy, limit, offset }\n *   }\n * }\n *\n * // Prisma adapter\n * class PrismaQueryAdapter implements QueryBuilderAdapter<PrismaQueryResult> {\n *   build(parsed: ParsedQuery, config: PrismaConfig): PrismaQueryResult {\n *     return { where, orderBy, skip, take }\n *   }\n * }\n * ```\n */\nexport interface QueryBuilderAdapter<TResult = any, TConfig = any> {\n  /** Human-readable name for debugging */\n  readonly name: string\n\n  /**\n   * Convert a ParsedQuery into an ORM-specific query object.\n   * @param parsed - The ORM-agnostic parsed query\n   * @param config - ORM-specific configuration (column maps, search columns, etc.)\n   */\n  build(parsed: ParsedQuery, config: TConfig): TResult\n}\n","import {\n  FILTER_OPERATORS,\n  type FilterItem,\n  type FilterOperator,\n  type SortItem,\n  type PaginationParams,\n  type ParsedQuery,\n  type QueryFieldConfig,\n  type StringQueryFieldConfig,\n  type TypedParsedQuery,\n} from './types'\n\nconst MAX_SEARCH_LENGTH = 200\nconst DEFAULT_PAGE = 1\nconst DEFAULT_LIMIT = 20\nconst MAX_LIMIT = 100\n\n// ── Individual parsers ──────────────────────────────────────────────────\n\n/** Parse filter strings like \"status:eq:active\" into structured objects */\nexport function parseFilters(\n  filterParam: string | string[] | undefined,\n  allowedFields?: string[],\n): FilterItem[] {\n  if (!filterParam) return []\n\n  const items = Array.isArray(filterParam) ? filterParam : [filterParam]\n  const results: FilterItem[] = []\n  const allowed = allowedFields ? new Set(allowedFields) : null\n\n  for (const item of items) {\n    // Split on first two colons only — value may contain colons (e.g. timestamps)\n    const firstColon = item.indexOf(':')\n    if (firstColon === -1) continue\n\n    const secondColon = item.indexOf(':', firstColon + 1)\n    if (secondColon === -1) continue\n\n    const field = item.slice(0, firstColon)\n    const operator = item.slice(firstColon + 1, secondColon)\n    const value = item.slice(secondColon + 1)\n\n    if (!field || !value) continue\n    if (!FILTER_OPERATORS.has(operator)) continue\n    if (allowed && !allowed.has(field)) continue\n\n    results.push({ field, operator: operator as FilterOperator, value })\n  }\n\n  return results\n}\n\n/** Parse sort strings like \"firstName:asc\" into structured objects */\nexport function parseSort(\n  sortParam: string | string[] | undefined,\n  allowedFields?: string[],\n): SortItem[] {\n  if (!sortParam) return []\n\n  const items = Array.isArray(sortParam) ? sortParam : [sortParam]\n  const results: SortItem[] = []\n  const allowed = allowedFields ? new Set(allowedFields) : null\n\n  for (const item of items) {\n    // Split on last colon so field names with colons work\n    const lastColon = item.lastIndexOf(':')\n    if (lastColon === -1) continue\n\n    const field = item.slice(0, lastColon)\n    const dir = item.slice(lastColon + 1).toLowerCase()\n\n    if (!field) continue\n    if (dir !== 'asc' && dir !== 'desc') continue\n    if (allowed && !allowed.has(field)) continue\n\n    results.push({ field, direction: dir })\n  }\n\n  return results\n}\n\n/** Parse page/limit into pagination with computed offset */\nexport function parsePagination(params: {\n  page?: string | number\n  limit?: string | number\n}): PaginationParams {\n  let page =\n    typeof params.page === 'string'\n      ? Number.parseInt(params.page, 10)\n      : (params.page ?? DEFAULT_PAGE)\n  let limit =\n    typeof params.limit === 'string'\n      ? Number.parseInt(params.limit, 10)\n      : (params.limit ?? DEFAULT_LIMIT)\n\n  if (Number.isNaN(page) || page < 1) page = DEFAULT_PAGE\n  if (Number.isNaN(limit) || limit < 1) limit = DEFAULT_LIMIT\n  if (limit > MAX_LIMIT) limit = MAX_LIMIT\n\n  return { page, limit, offset: (page - 1) * limit }\n}\n\n/** Sanitize and truncate search query */\nexport function parseSearchQuery(q: string | undefined): string {\n  if (!q) return ''\n  return q.trim().slice(0, MAX_SEARCH_LENGTH)\n}\n\n// ── Config normalizer ───────────────────────────────────────────────────\n\n/**\n * Normalize a QueryFieldConfig into the string-based form.\n * Detects column-object-based configs (DrizzleQueryParamsConfig) by checking\n * for a `columns` property and extracts `Object.keys()`.\n */\nfunction normalizeFieldConfig(config?: QueryFieldConfig): StringQueryFieldConfig | undefined {\n  if (!config) return undefined\n\n  // Column-object-based config (e.g., DrizzleQueryParamsConfig)\n  if ('columns' in config && config.columns && typeof config.columns === 'object') {\n    return {\n      filterable: Object.keys(config.columns),\n      sortable: config.sortable ? Object.keys(config.sortable) : undefined,\n      searchable: undefined, // searchColumns are Column objects, not used for string filtering\n    }\n  }\n\n  // Already string-based\n  return config as StringQueryFieldConfig\n}\n\n// ── Combined parser ─────────────────────────────────────────────────────\n\n/**\n * Parse a raw Express query object into a structured, ORM-agnostic ParsedQuery.\n *\n * @param query - Raw query string object from `req.query` or Zod-validated object\n * @param fieldConfig - Optional field restrictions (whitelist filterable/sortable/searchable).\n *   Accepts both string-based configs (`{ filterable, sortable, searchable }`) and\n *   column-object configs (`{ columns, sortable, searchColumns }`).\n *\n * @example\n * ```ts\n * // String-based config\n * const parsed = parseQuery(ctx.query, {\n *   filterable: ['status', 'priority'],\n *   sortable: ['createdAt', 'title'],\n * })\n *\n * // Column-object config (DrizzleQueryParamsConfig)\n * const parsed = parseQuery(ctx.query, TASK_QUERY_CONFIG)\n * ```\n *\n * Query string format:\n * - Filters: `?filter=field:operator:value` (repeatable)\n * - Sort: `?sort=field:asc|desc` (repeatable)\n * - Pagination: `?page=1&limit=20`\n * - Search: `?q=search+term`\n *\n * Filter operators: eq, neq, gt, gte, lt, lte, between, in, contains, starts, ends\n */\nexport function parseQuery<TConfig extends QueryFieldConfig | undefined = undefined>(\n  query: Record<string, any>,\n  fieldConfig?: TConfig,\n): TypedParsedQuery<TConfig> {\n  const normalized = normalizeFieldConfig(fieldConfig)\n  return {\n    filters: parseFilters(query.filter, normalized?.filterable),\n    sort: parseSort(query.sort, normalized?.sortable),\n    pagination: parsePagination({ page: query.page, limit: query.limit }),\n    search: parseSearchQuery(query.q),\n  } as TypedParsedQuery<TConfig>\n}\n\n// ── Query URL builder (for client-side or testing) ──────────────────────\n\n/** Convert ParsedQuery back into query string parameters */\nexport function buildQueryParams(\n  parsed: Partial<ParsedQuery>,\n): Record<string, string | string[] | number> {\n  const params: Record<string, string | string[] | number> = {}\n\n  if (parsed.filters?.length) {\n    params.filter = parsed.filters.map((f) => `${f.field}:${f.operator}:${f.value}`)\n  }\n\n  if (parsed.sort?.length) {\n    params.sort = parsed.sort.map((s) => `${s.field}:${s.direction}`)\n  }\n\n  if (parsed.pagination) {\n    params.page = parsed.pagination.page\n    params.limit = parsed.pagination.limit\n  }\n\n  if (parsed.search) {\n    params.q = parsed.search\n  }\n\n  return params\n}\n"],"mappings":"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"}

package/dist/router-builder-oQpcQMWl.d.mts

@@ -1,31 +0,0 @@
-
-import { S as SourcedRegistration } from "./index-frSEHiL_.mjs";
-import { Router } from "express";
-
-//#region src/http/router-builder.d.ts
-/** @internal — set by Application.setup() before each `mod.routes()` call. */
-declare function _setExternalContributorSources(sources: readonly SourcedRegistration[]): void;
-interface BuildRoutesOptions {
-  /**
-   * Extra contributors to merge into the per-route pipeline at their declared
-   * precedence levels. Pass explicitly when calling buildRoutes outside the
-   * Application route-mount loop (typically in tests). When omitted, falls
-   * back to the slot set by Application.setup().
-   */
-  externalSources?: readonly SourcedRegistration[];
-}
-/**
- * Build an Express Router from a controller class decorated with @Get, @Post, etc.
- * Resolves the controller from the DI container, wraps handlers in RequestContext,
- * and applies class-level and method-level middleware.
- *
- * Routes are registered using only the method-level decorator paths (e.g. @Get('/me') → '/me').
- * The @Controller path is NOT baked into the router — it serves as metadata only
- * (used by Swagger and other adapters for introspection).
- * The module's routes().path is the single source of truth for the mount prefix,
- * which avoids path doubling when both the module and controller specify the same path.
- */
-declare function buildRoutes(controllerClass: any, options?: BuildRoutesOptions): Router;
-//#endregion
-export { _setExternalContributorSources as n, buildRoutes as r, BuildRoutesOptions as t };
-//# sourceMappingURL=router-builder-oQpcQMWl.d.mts.map

package/dist/router-builder-oQpcQMWl.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"router-builder-oQpcQMWl.d.mts","names":[],"sources":["../src/http/router-builder.ts"],"mappings":";;;;;;iBAmCgB,8BAAA,CAA+B,OAAuC,WAArB,mBAAmB;AAAA,UAInE,kBAAA;EAJ6B;;;AAAwC;AAItF;;EAOE,eAAA,YAA2B,mBAAmB;AAAA;AAAA;AAchD;;;;;;;;;AAA2F;AAd3C,iBAchC,WAAA,CAAY,eAAA,OAAsB,OAAA,GAAS,kBAAA,GAA0B,MAAM"}

package/dist/spa-IRFC2eMN.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"spa-IRFC2eMN.d.mts","names":[],"sources":["../src/http/middleware/spa.ts"],"mappings":";;;UAMiB,iBAAA;;;AAAjB;;;;;;;;;;AAiDmB;EAnCjB,SAAA;EAqEsB;;;;;;;;;;EAzDtB,SAAA;EAkEoB;;;;;;;;;EAvDpB,OAAA;EAuDoB;;;;EAjDpB,YAAA;EAoGA;;;;EA9FA,iBAAA;AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAkCW,UAAA,YAAsB,UAAA;EAAA,QASb,OAAA;EARpB,IAAA;EAAA,QACQ,SAAA;EAAA,QACA,WAAA;EAAA,QACA,YAAA;EAAA,QACA,YAAA;EAAA,QACA,iBAAA;EAAA,QACA,SAAA;EAER,WAAA,CAAoB,OAAA,GAAS,iBAAA;EAU7B,WAAA;IAAc;EAAA,GAAO,cAAA;EAyCrB,WAAA;IAAc;EAAA,GAAO,cAAA;AAAA"}

package/dist/upload-D6edAELH.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"upload-D6edAELH.d.mts","names":[],"sources":["../src/http/middleware/upload.ts"],"mappings":";;;;;;;;;AAiGA;;;;AAAgD;AAYhD;;iBAZgB,gBAAA,CAAiB,KAAe;;;;;;UAY/B,aAAA,SAAsB,iBAAiB;EAIlD;EAFJ,OAAA,GAAU,OAAA;EAmEG;EAjEb,IAAA;AAAA;;;;;;AAiE6E;AAAA;;;;;;iBAAtE,MAAA,CAAO,SAAA,UAAmB,OAAA,GAAS,aAAA,GAAqB,cAAc;;;;iBAQtE,KAAA,CAAM,SAAA,UAAmB,QAAA,WAAe,OAAA,GAAS,aAAA,GAAqB,cAAc;AAAA;;;AAAA,iBAQpF,IAAA,CAAK,OAAA,GAAS,aAAA,GAAqB,cAAc;;;;;AAAA;AAmB1D;;;;;;;;;iBAAgB,YAAA,KAAY,GAAA,EACb,OAAA,EAAO,GAAA,EAAO,QAAA,EAAQ,IAAA,EAAQ,YAAA;;;;;;iBA+B7B,qBAAA,CAAsB,MAAA,EAAQ,gBAAA,GAAmB,cAAc;AAA/E;AAAA,cAmBa,MAAA"}

package/dist/views-BCl-mETX.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"views-BCl-mETX.d.mts","names":[],"sources":["../src/http/cluster.ts","../src/http/define-http-context-decorator.ts","../src/http/request-store.ts","../src/http/middleware/request-scope.ts","../src/http/middleware/trace-context.ts","../src/http/middleware/views.ts"],"mappings":";;;;;;;;;UAOiB,cAAA;;EAEf,OAAA;;EAEA,uBAAA;;EAEA,YAAA;;EAEA,WAAA;;EAEA,aAAA;AAAA;;iBAIc,gBAAA;;;;;;;;UCuDC,oCAAA,WAA+C,MAAA;EAAA,6BACjC,MAAA,SAAe,QAAA,IAAY,MAAA,iBACtD,IAAA,EAAM,oBAAA,CAAqB,CAAA,EAAG,CAAA,EAAG,CAAA,EAAG,cAAA,IACnC,gBAAA,CAAiB,CAAA,EAAG,CAAA,EAAG,CAAA,EAAG,cAAA;AAAA;;;;;;UAQd,4BAAA;EAAA,6BAGH,MAAA,SAAe,QAAA,IAAY,MAAA,2BAC3B,MAAA,oBAA0B,MAAA,iBAEpC,IAAA,EAAM,oBAAA,CAAqB,CAAA,EAAG,CAAA,EAAG,CAAA,EAAG,cAAA,IACnC,gBAAA,CAAiB,CAAA,EAAG,CAAA,EAAG,CAAA,EAAG,cAAA;EAfc;AAAA;AAQ7C;;;;;;;;;;;;;EAwBE,UAAA,WAAqB,MAAA,sBAA4B,oCAAA,CAAqC,CAAA;AAAA;AAAA,cAW3E,0BAAA,EAA4B,4BAQR;;;;UC9HhB,YAAA;;EAEf,SAAA;;;;;;EAMA,SAAA,EAAW,GAAA;;;;;;;;;;;;AFLb;;;;;;;;;EE0BE,MAAA,EAAQ,GAAG;AAAA;AFZb;AAAA,cEgBa,YAAA,EAAY,iBAAA,CAAA,YAAA;;;AFhBO;;iBEsBhB,eAAA,IAAmB,YAAY;;ADiC/C;;;;;;;;;;;;;;;;;;;;;;;;;iBCGgB,eAAA,mBAAkC,GAAA,EAAK,CAAA,GAAI,SAAA,CAAU,CAAA;;;;;;;;;;;iBCrDrD,sBAAA,KAAsB,GAAA,EACnB,OAAA,EAAO,IAAA,EAAQ,QAAA,EAAQ,IAAA,EAAQ,YAAA;;;;;;;cCnBrC,kBAAA;AAAA,UAKI,mBAAA;;;;;EAKf,iBAAiB;AAAA;;;;UAMF,YAAA;;EAEf,OAAA;;EAEA,OAAA;;EAEA,YAAA;EJvBe;EIyBf,KAAA;AAAA;;;;;iBAqBc,gBAAA,CAAiB,MAAA,WAAiB,YAAY;;;AJpC/C;AAIf;;;;AAAgC;;;;ACuDhC;;;;;;;;;;iBGmBgB,YAAA,CAAa,OAAA,GAAS,mBAAA,IAAwB,GAAA,EAC/C,OAAA,EAAO,GAAA,EAAO,QAAA,EAAQ,IAAA,EAAQ,YAAA;;;UC3F5B,kBAAA;;;;;;;;;;;;;;;EAef,MAAA;;EAGA,GAAA;;EAGA,QAAA;;EAGA,MAAA;AAAA;ALtBF;;;;;;;;;;AAUe;AAIf;;;;AAAgC;;;;ACuDhC;;;;;;;;;;ADrEA,cKsDa,WAAA,EAAW,cAAA,CAAA,kBAAA"}