@fluojs/core 1.0.0-beta.1

package/dist/metadata/class-di.d.ts

@@ -0,0 +1,30 @@
+import type { ClassDiMetadata } from './types.js';
+/**
+ * Defines class-level DI metadata while preserving previously written fields for split decorator passes.
+ *
+ * @param target Class receiving DI metadata.
+ * @param metadata Partial or complete DI metadata payload.
+ */
+export declare function defineClassDiMetadata(target: Function, metadata: ClassDiMetadata): void;
+/**
+ * Reads only the DI metadata defined directly on a class.
+ *
+ * @param target Class being inspected.
+ * @returns A defensive clone of the class's own DI metadata, or `undefined` when absent.
+ */
+export declare function getOwnClassDiMetadata(target: Function): ClassDiMetadata | undefined;
+/**
+ * Resolves inherited DI metadata by walking the constructor lineage from base to leaf.
+ *
+ * @param target Class being inspected.
+ * @returns The effective inherited DI metadata, or `undefined` when no lineage metadata exists.
+ */
+export declare function getInheritedClassDiMetadata(target: Function): ClassDiMetadata | undefined;
+/**
+ * Reads the effective DI metadata visible to a class, including inherited fallback values.
+ *
+ * @param target Class being inspected.
+ * @returns The effective DI metadata for the class, or `undefined` when none exists.
+ */
+export declare function getClassDiMetadata(target: Function): ClassDiMetadata | undefined;
+//# sourceMappingURL=class-di.d.ts.map

package/dist/metadata/class-di.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"class-di.d.ts","sourceRoot":"","sources":["../../src/metadata/class-di.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,YAAY,CAAC;AAyBlD;;;;;GAKG;AACH,wBAAgB,qBAAqB,CAAC,MAAM,EAAE,QAAQ,EAAE,QAAQ,EAAE,eAAe,GAAG,IAAI,CAKvF;AAED;;;;;GAKG;AACH,wBAAgB,qBAAqB,CAAC,MAAM,EAAE,QAAQ,GAAG,eAAe,GAAG,SAAS,CAEnF;AAED;;;;;GAKG;AACH,wBAAgB,2BAA2B,CAAC,MAAM,EAAE,QAAQ,GAAG,eAAe,GAAG,SAAS,CAiBzF;AAED;;;;;GAKG;AACH,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,QAAQ,GAAG,eAAe,GAAG,SAAS,CAEhF"}

package/dist/metadata/class-di.js

@@ -0,0 +1,72 @@
+import { createClonedWeakMapStore } from './store.js';
+const classDiMetadataStore = createClonedWeakMapStore(cloneClassDiMetadata);
+function cloneClassDiMetadata(metadata) {
+  return {
+    inject: metadata.inject ? [...metadata.inject] : undefined,
+    scope: metadata.scope
+  };
+}
+function getClassMetadataLineage(target) {
+  const lineage = [];
+  let current = target;
+  while (typeof current === 'function' && current !== Function.prototype) {
+    lineage.push(current);
+    current = Object.getPrototypeOf(current);
+  }
+  lineage.reverse();
+  return lineage;
+}
+
+/**
+ * Defines class-level DI metadata while preserving previously written fields for split decorator passes.
+ *
+ * @param target Class receiving DI metadata.
+ * @param metadata Partial or complete DI metadata payload.
+ */
+export function defineClassDiMetadata(target, metadata) {
+  classDiMetadataStore.update(target, existing => ({
+    inject: metadata.inject !== undefined ? metadata.inject : existing?.inject,
+    scope: metadata.scope ?? existing?.scope
+  }));
+}
+
+/**
+ * Reads only the DI metadata defined directly on a class.
+ *
+ * @param target Class being inspected.
+ * @returns A defensive clone of the class's own DI metadata, or `undefined` when absent.
+ */
+export function getOwnClassDiMetadata(target) {
+  return classDiMetadataStore.read(target);
+}
+
+/**
+ * Resolves inherited DI metadata by walking the constructor lineage from base to leaf.
+ *
+ * @param target Class being inspected.
+ * @returns The effective inherited DI metadata, or `undefined` when no lineage metadata exists.
+ */
+export function getInheritedClassDiMetadata(target) {
+  let effective;
+  for (const constructor of getClassMetadataLineage(target)) {
+    const metadata = classDiMetadataStore.read(constructor);
+    if (!metadata) {
+      continue;
+    }
+    effective = {
+      inject: metadata.inject ?? effective?.inject,
+      scope: metadata.scope ?? effective?.scope
+    };
+  }
+  return effective ? cloneClassDiMetadata(effective) : undefined;
+}
+
+/**
+ * Reads the effective DI metadata visible to a class, including inherited fallback values.
+ *
+ * @param target Class being inspected.
+ * @returns The effective DI metadata for the class, or `undefined` when none exists.
+ */
+export function getClassDiMetadata(target) {
+  return getInheritedClassDiMetadata(target);
+}

package/dist/metadata/controller-route.d.ts

@@ -0,0 +1,7 @@
+import type { ControllerMetadata, RouteMetadata } from './types.js';
+import type { MetadataPropertyKey } from '../types.js';
+export declare function defineControllerMetadata(target: Function, metadata: ControllerMetadata): void;
+export declare function getControllerMetadata(target: Function): ControllerMetadata | undefined;
+export declare function defineRouteMetadata(target: object, propertyKey: MetadataPropertyKey, metadata: RouteMetadata): void;
+export declare function getRouteMetadata(target: object, propertyKey: MetadataPropertyKey): RouteMetadata | undefined;
+//# sourceMappingURL=controller-route.d.ts.map

package/dist/metadata/controller-route.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"controller-route.d.ts","sourceRoot":"","sources":["../../src/metadata/controller-route.ts"],"names":[],"mappings":"AAUA,OAAO,KAAK,EAAE,kBAAkB,EAAE,aAAa,EAA+B,MAAM,YAAY,CAAC;AACjG,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,aAAa,CAAC;AA8DvD,wBAAgB,wBAAwB,CAAC,MAAM,EAAE,QAAQ,EAAE,QAAQ,EAAE,kBAAkB,GAAG,IAAI,CAE7F;AAED,wBAAgB,qBAAqB,CAAC,MAAM,EAAE,QAAQ,GAAG,kBAAkB,GAAG,SAAS,CActF;AAED,wBAAgB,mBAAmB,CACjC,MAAM,EAAE,MAAM,EACd,WAAW,EAAE,mBAAmB,EAChC,QAAQ,EAAE,aAAa,GACtB,IAAI,CAEN;AAsCD,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,MAAM,EAAE,WAAW,EAAE,mBAAmB,GAAG,aAAa,GAAG,SAAS,CAW5G"}

package/dist/metadata/controller-route.js

@@ -0,0 +1,109 @@
+import { cloneMutableValue, cloneCollection, getOrCreatePropertyMap, getStandardConstructorMetadataMap, getStandardMetadataBag, mergeUnique, standardMetadataKeys } from './shared.js';
+import { createClonedWeakMapStore } from './store.js';
+const controllerMetadataStore = createClonedWeakMapStore(cloneControllerMetadata);
+const routeMetadataStore = new WeakMap();
+function cloneRouteHeaders(headers) {
+  return headers?.map(header => ({
+    ...header
+  }));
+}
+function cloneRouteRedirect(redirect) {
+  return redirect ? {
+    ...redirect
+  } : undefined;
+}
+function cloneControllerMetadata(metadata) {
+  return {
+    ...metadata,
+    guards: cloneCollection(metadata.guards),
+    interceptors: cloneCollection(metadata.interceptors)
+  };
+}
+function cloneRouteMetadata(metadata) {
+  return {
+    ...metadata,
+    headers: cloneRouteHeaders(metadata.headers),
+    redirect: cloneRouteRedirect(metadata.redirect),
+    guards: cloneCollection(metadata.guards),
+    interceptors: cloneCollection(metadata.interceptors)
+  };
+}
+function getStandardControllerMetadata(target) {
+  const metadata = getStandardMetadataBag(target)?.[standardMetadataKeys.controller];
+  if (!metadata) {
+    return undefined;
+  }
+  return cloneControllerMetadata(metadata);
+}
+function getStandardRouteMetadata(target, propertyKey) {
+  const routeMap = getStandardConstructorMetadataMap(target, standardMetadataKeys.route);
+  const metadata = routeMap?.get(propertyKey);
+  if (!metadata?.method || metadata.path === undefined) {
+    return undefined;
+  }
+  return cloneRouteMetadata({
+    guards: metadata.guards,
+    headers: metadata.headers,
+    interceptors: metadata.interceptors,
+    method: metadata.method,
+    path: metadata.path,
+    redirect: metadata.redirect,
+    request: metadata.request,
+    successStatus: metadata.successStatus,
+    version: metadata.version
+  });
+}
+export function defineControllerMetadata(target, metadata) {
+  controllerMetadataStore.write(target, metadata);
+}
+export function getControllerMetadata(target) {
+  const stored = controllerMetadataStore.read(target);
+  const standard = getStandardControllerMetadata(target);
+  if (!stored && !standard) {
+    return undefined;
+  }
+  return {
+    basePath: stored?.basePath ?? standard?.basePath ?? '',
+    guards: mergeUnique(stored?.guards, standard?.guards),
+    interceptors: mergeUnique(stored?.interceptors, standard?.interceptors),
+    version: stored?.version ?? standard?.version
+  };
+}
+export function defineRouteMetadata(target, propertyKey, metadata) {
+  getOrCreatePropertyMap(routeMetadataStore, target).set(propertyKey, cloneRouteMetadata(metadata));
+}
+function resolveRequiredRouteFields(stored, standard, propertyKey) {
+  const method = stored?.method ?? standard?.method;
+  const path = stored?.path ?? standard?.path;
+  if (method === undefined || path === undefined) {
+    throw new Error(`Route metadata for property key "${String(propertyKey)}" is missing required "method" or "path".`);
+  }
+  return {
+    method,
+    path
+  };
+}
+function mergeRouteMetadata(stored, standard, required) {
+  const mergedHeaders = stored?.headers ?? standard?.headers;
+  const mergedRedirect = stored?.redirect ?? standard?.redirect;
+  return {
+    guards: mergeUnique(stored?.guards, standard?.guards),
+    headers: cloneMutableValue(mergedHeaders),
+    interceptors: mergeUnique(stored?.interceptors, standard?.interceptors),
+    method: required.method,
+    path: required.path,
+    redirect: cloneMutableValue(mergedRedirect),
+    request: stored?.request ?? standard?.request,
+    successStatus: stored?.successStatus ?? standard?.successStatus,
+    version: stored?.version ?? standard?.version
+  };
+}
+export function getRouteMetadata(target, propertyKey) {
+  const stored = routeMetadataStore.get(target)?.get(propertyKey);
+  const standard = getStandardRouteMetadata(target, propertyKey);
+  if (!stored && !standard) {
+    return undefined;
+  }
+  const required = resolveRequiredRouteFields(stored, standard, propertyKey);
+  return mergeRouteMetadata(stored, standard, required);
+}

package/dist/metadata/injection.d.ts

@@ -0,0 +1,5 @@
+import type { InjectionMetadata, InjectionSchemaEntry } from './types.js';
+import type { MetadataPropertyKey } from '../types.js';
+export declare function defineInjectionMetadata(target: object, propertyKey: MetadataPropertyKey, metadata: InjectionMetadata): void;
+export declare function getInjectionSchema(target: object): InjectionSchemaEntry[];
+//# sourceMappingURL=injection.d.ts.map

package/dist/metadata/injection.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"injection.d.ts","sourceRoot":"","sources":["../../src/metadata/injection.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,iBAAiB,EAAE,oBAAoB,EAA2B,MAAM,YAAY,CAAC;AACnG,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,aAAa,CAAC;AAQvD,wBAAgB,uBAAuB,CACrC,MAAM,EAAE,MAAM,EACd,WAAW,EAAE,mBAAmB,EAChC,QAAQ,EAAE,iBAAiB,GAC1B,IAAI,CAEN;AAED,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,MAAM,GAAG,oBAAoB,EAAE,CAwBzE"}

package/dist/metadata/injection.js

@@ -0,0 +1,31 @@
+import { getOrCreatePropertyMap, getStandardConstructorMetadataMap, mergeMetadataPropertyKeys, standardMetadataKeys } from './shared.js';
+const injectionMetadataStore = new WeakMap();
+function getStandardInjectionMap(target) {
+  return getStandardConstructorMetadataMap(target, standardMetadataKeys.injection);
+}
+export function defineInjectionMetadata(target, propertyKey, metadata) {
+  getOrCreatePropertyMap(injectionMetadataStore, target).set(propertyKey, {
+    ...metadata
+  });
+}
+export function getInjectionSchema(target) {
+  const stored = injectionMetadataStore.get(target) ?? new Map();
+  const standard = getStandardInjectionMap(target) ?? new Map();
+  const keys = mergeMetadataPropertyKeys(stored, standard);
+  const schema = [];
+  for (const propertyKey of keys) {
+    const metadata = stored.get(propertyKey);
+    const standardMetadata = standard.get(propertyKey);
+    if (!metadata && standardMetadata?.token == null) {
+      continue;
+    }
+    schema.push({
+      propertyKey,
+      metadata: {
+        optional: metadata?.optional ?? standardMetadata?.optional,
+        token: metadata?.token ?? standardMetadata?.token
+      }
+    });
+  }
+  return schema;
+}

package/dist/metadata/module.d.ts

@@ -0,0 +1,16 @@
+import type { ModuleMetadata } from './types.js';
+/**
+ * Defines module metadata while preserving previously written fields for partial decorator passes.
+ *
+ * @param target Module class receiving metadata.
+ * @param metadata Partial or complete module metadata payload.
+ */
+export declare function defineModuleMetadata(target: Function, metadata: ModuleMetadata): void;
+/**
+ * Reads cloned module metadata for the provided module class.
+ *
+ * @param target Module class being inspected.
+ * @returns A defensive clone of module metadata, or `undefined` when none was defined.
+ */
+export declare function getModuleMetadata(target: Function): ModuleMetadata | undefined;
+//# sourceMappingURL=module.d.ts.map

package/dist/metadata/module.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"module.d.ts","sourceRoot":"","sources":["../../src/metadata/module.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,YAAY,CAAC;AAkCjD;;;;;GAKG;AACH,wBAAgB,oBAAoB,CAAC,MAAM,EAAE,QAAQ,EAAE,QAAQ,EAAE,cAAc,GAAG,IAAI,CASrF;AAED;;;;;GAKG;AACH,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,QAAQ,GAAG,cAAc,GAAG,SAAS,CAE9E"}

package/dist/metadata/module.js

@@ -0,0 +1,57 @@
+import { cloneCollection, cloneMutableValue } from './shared.js';
+import { createClonedWeakMapStore } from './store.js';
+const moduleMetadataStore = createClonedWeakMapStore(cloneModuleMetadata);
+function isValueProvider(provider) {
+  return typeof provider === 'object' && provider !== null && 'useValue' in provider;
+}
+function cloneProvider(provider) {
+  if (isValueProvider(provider)) {
+    // Shallow-copy the provider descriptor but preserve the useValue reference.
+    // Deep-cloning useValue would sever object identity for externally supplied
+    // instances (e.g. transport adapters) that callers hold references to.
+    return {
+      ...provider
+    };
+  }
+  return cloneMutableValue(provider);
+}
+function cloneProviders(providers) {
+  return providers ? providers.map(cloneProvider) : undefined;
+}
+function cloneModuleMetadata(metadata) {
+  return {
+    controllers: cloneCollection(metadata.controllers),
+    exports: cloneCollection(metadata.exports),
+    global: metadata.global,
+    imports: cloneCollection(metadata.imports),
+    middleware: cloneCollection(metadata.middleware),
+    providers: cloneProviders(metadata.providers)
+  };
+}
+
+/**
+ * Defines module metadata while preserving previously written fields for partial decorator passes.
+ *
+ * @param target Module class receiving metadata.
+ * @param metadata Partial or complete module metadata payload.
+ */
+export function defineModuleMetadata(target, metadata) {
+  moduleMetadataStore.update(target, existing => ({
+    controllers: metadata.controllers ?? existing?.controllers,
+    exports: metadata.exports ?? existing?.exports,
+    global: metadata.global !== undefined ? metadata.global : existing?.global,
+    imports: metadata.imports ?? existing?.imports,
+    middleware: metadata.middleware ?? existing?.middleware,
+    providers: metadata.providers ?? existing?.providers
+  }));
+}
+
+/**
+ * Reads cloned module metadata for the provided module class.
+ *
+ * @param target Module class being inspected.
+ * @returns A defensive clone of module metadata, or `undefined` when none was defined.
+ */
+export function getModuleMetadata(target) {
+  return moduleMetadataStore.read(target);
+}

package/dist/metadata/shared.d.ts

@@ -0,0 +1,128 @@
+import type { MetadataPropertyKey } from '../types.js';
+/**
+ * Generic metadata bag shape used by the TC39 `Symbol.metadata` integration points.
+ */
+export type StandardMetadataBag = Record<PropertyKey, unknown>;
+/**
+ * Active symbol key used to read and write standard metadata bags.
+ */
+export declare let metadataSymbol: symbol;
+/**
+ * Ensures `Symbol.metadata` exists and returns the symbol used by Fluo metadata helpers.
+ *
+ * @returns The resolved metadata symbol.
+ */
+export declare function ensureMetadataSymbol(): symbol;
+/**
+ * Clones mutable metadata payloads before storing or returning them from shared metadata helpers.
+ *
+ * @param value Metadata value to clone defensively.
+ * @returns A detached clone for supported mutable shapes, or the original value for immutable references.
+ */
+export declare function cloneMutableValue<T>(value: T): T;
+/**
+ * Canonical symbol keys for metadata emitted through the standard decorator metadata bag.
+ */
+export declare const standardMetadataKeys: {
+    readonly classValidation: symbol;
+    readonly controller: symbol;
+    readonly dtoFieldBinding: symbol;
+    readonly dtoFieldValidation: symbol;
+    readonly injection: symbol;
+    readonly route: symbol;
+};
+/**
+ * Canonical symbol keys for Fluo-owned metadata stores.
+ */
+export declare const metadataKeys: {
+    readonly module: symbol;
+    readonly controller: symbol;
+    readonly route: symbol;
+    readonly dtoFieldBinding: symbol;
+    readonly dtoFieldValidation: symbol;
+    readonly injection: symbol;
+    readonly classDi: symbol;
+    readonly classValidation: symbol;
+};
+/**
+ * Clones a readonly collection into a mutable array for defensive metadata reads and writes.
+ *
+ * @param collection Collection to clone.
+ * @returns A cloned mutable array, or `undefined` when the collection is absent.
+ */
+export declare function cloneCollection<T>(collection: readonly T[] | undefined): T[] | undefined;
+/**
+ * Looks up or creates a property-keyed metadata map for a target object.
+ *
+ * @param store WeakMap-backed metadata store.
+ * @param target Target object that owns the metadata map.
+ * @returns The existing or newly created metadata map for the target.
+ */
+export declare function getOrCreatePropertyMap<T>(store: WeakMap<object, Map<MetadataPropertyKey, T>>, target: object): Map<MetadataPropertyKey, T>;
+/**
+ * Merges two arrays into a single deduplicated array, preserving insertion order.
+ * Deduplication uses reference equality (===), so two objects with identical shapes
+ * are treated as distinct entries unless they are the exact same reference.
+ * Returns `undefined` when both inputs are empty or absent.
+ *
+ * @param existing Existing values in insertion order.
+ * @param values Additional values to merge.
+ * @returns A deduplicated merged array, or `undefined` when both inputs are empty.
+ */
+export declare function mergeUnique<T>(existing: readonly T[] | undefined, values: readonly T[] | undefined): T[] | undefined;
+/**
+ * Reads the standard metadata bag stored directly on a target.
+ *
+ * @param target Target object that may own standard metadata.
+ * @returns The metadata bag when present, otherwise `undefined`.
+ */
+export declare function getStandardMetadataBag(target: object): StandardMetadataBag | undefined;
+/**
+ * Reads the standard metadata bag stored on a target's constructor.
+ *
+ * @param target Instance or prototype whose constructor metadata should be inspected.
+ * @returns The constructor metadata bag when present, otherwise `undefined`.
+ */
+export declare function getStandardConstructorMetadataBag(target: object): StandardMetadataBag | undefined;
+/**
+ * Reads a constructor-level metadata record from the standard metadata bag.
+ *
+ * @param target Instance or prototype whose constructor metadata should be inspected.
+ * @param key Symbol key of the stored metadata record.
+ * @returns The stored record when present, otherwise `undefined`.
+ */
+export declare function getStandardConstructorMetadataRecord<T>(target: object, key: symbol): T | undefined;
+/**
+ * Reads a constructor-level property map from the standard metadata bag.
+ *
+ * @param target Instance or prototype whose constructor metadata should be inspected.
+ * @param key Symbol key of the stored metadata map.
+ * @returns The stored property map when present, otherwise `undefined`.
+ */
+export declare function getStandardConstructorMetadataMap<T>(target: object, key: symbol): Map<MetadataPropertyKey, T> | undefined;
+/**
+ * Merges stored and standard metadata property keys while preserving first-seen order.
+ *
+ * @param stored Property keys from the explicit Fluo store.
+ * @param standard Property keys from the standard metadata bag.
+ * @returns A deduplicated ordered list of metadata property keys.
+ */
+export declare function mergeMetadataPropertyKeys<TStored, TStandard>(stored: ReadonlyMap<MetadataPropertyKey, TStored> | undefined, standard: ReadonlyMap<MetadataPropertyKey, TStandard> | undefined): MetadataPropertyKey[];
+/**
+ * Appends a value into a property-keyed array store, creating the array on first write.
+ *
+ * @param store WeakMap-backed property store.
+ * @param target Target object that owns the property map.
+ * @param propertyKey Property key associated with the array entry.
+ * @param value Value to append.
+ */
+export declare function appendPropertyMapValue<T>(store: WeakMap<object, Map<MetadataPropertyKey, T[]>>, target: object, propertyKey: MetadataPropertyKey, value: T): void;
+/**
+ * Appends a value into a WeakMap-backed array store, creating the array on first write.
+ *
+ * @param store WeakMap-backed array store.
+ * @param target Target function used as the WeakMap key.
+ * @param value Value to append.
+ */
+export declare function appendWeakMapValue<T>(store: WeakMap<Function, T[]>, target: Function, value: T): void;
+//# sourceMappingURL=shared.d.ts.map

package/dist/metadata/shared.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"shared.d.ts","sourceRoot":"","sources":["../../src/metadata/shared.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,aAAa,CAAC;AAGvD;;GAEG;AACH,MAAM,MAAM,mBAAmB,GAAG,MAAM,CAAC,WAAW,EAAE,OAAO,CAAC,CAAC;AAG/D;;GAEG;AACH,eAAO,IAAI,cAAc,QAAoE,CAAC;AAE9F;;;;GAIG;AACH,wBAAgB,oBAAoB,IAAI,MAAM,CAY7C;AAcD;;;;;GAKG;AACH,wBAAgB,iBAAiB,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,GAAG,CAAC,CAMhD;AAED;;GAEG;AACH,eAAO,MAAM,oBAAoB;;;;;;;CAOvB,CAAC;AAEX;;GAEG;AACH,eAAO,MAAM,YAAY;;;;;;;;;CASf,CAAC;AAEX;;;;;GAKG;AACH,wBAAgB,eAAe,CAAC,CAAC,EAAE,UAAU,EAAE,SAAS,CAAC,EAAE,GAAG,SAAS,GAAG,CAAC,EAAE,GAAG,SAAS,CAExF;AAED;;;;;;GAMG;AACH,wBAAgB,sBAAsB,CAAC,CAAC,EACtC,KAAK,EAAE,OAAO,CAAC,MAAM,EAAE,GAAG,CAAC,mBAAmB,EAAE,CAAC,CAAC,CAAC,EACnD,MAAM,EAAE,MAAM,GACb,GAAG,CAAC,mBAAmB,EAAE,CAAC,CAAC,CAS7B;AAED;;;;;;;;;GASG;AACH,wBAAgB,WAAW,CAAC,CAAC,EAAE,QAAQ,EAAE,SAAS,CAAC,EAAE,GAAG,SAAS,EAAE,MAAM,EAAE,SAAS,CAAC,EAAE,GAAG,SAAS,GAAG,CAAC,EAAE,GAAG,SAAS,CAgBpH;AAED;;;;;GAKG;AACH,wBAAgB,sBAAsB,CAAC,MAAM,EAAE,MAAM,GAAG,mBAAmB,GAAG,SAAS,CAQtF;AAED;;;;;GAKG;AACH,wBAAgB,iCAAiC,CAAC,MAAM,EAAE,MAAM,GAAG,mBAAmB,GAAG,SAAS,CAIjG;AAED;;;;;;GAMG;AACH,wBAAgB,oCAAoC,CAAC,CAAC,EAAE,MAAM,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,CAAC,GAAG,SAAS,CAElG;AAED;;;;;;GAMG;AACH,wBAAgB,iCAAiC,CAAC,CAAC,EAAE,MAAM,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,GAAG,CAAC,mBAAmB,EAAE,CAAC,CAAC,GAAG,SAAS,CAEzH;AAED;;;;;;GAMG;AACH,wBAAgB,yBAAyB,CAAC,OAAO,EAAE,SAAS,EAC1D,MAAM,EAAE,WAAW,CAAC,mBAAmB,EAAE,OAAO,CAAC,GAAG,SAAS,EAC7D,QAAQ,EAAE,WAAW,CAAC,mBAAmB,EAAE,SAAS,CAAC,GAAG,SAAS,GAChE,mBAAmB,EAAE,CAkBvB;AAED;;;;;;;GAOG;AACH,wBAAgB,sBAAsB,CAAC,CAAC,EACtC,KAAK,EAAE,OAAO,CAAC,MAAM,EAAE,GAAG,CAAC,mBAAmB,EAAE,CAAC,EAAE,CAAC,CAAC,EACrD,MAAM,EAAE,MAAM,EACd,WAAW,EAAE,mBAAmB,EAChC,KAAK,EAAE,CAAC,GACP,IAAI,CAUN;AAED;;;;;;GAMG;AACH,wBAAgB,kBAAkB,CAAC,CAAC,EAAE,KAAK,EAAE,OAAO,CAAC,QAAQ,EAAE,CAAC,EAAE,CAAC,EAAE,MAAM,EAAE,QAAQ,EAAE,KAAK,EAAE,CAAC,GAAG,IAAI,CASrG"}