fhir-runtime 0.2.0

package/dist/lib/context/loaders/file-loader.d.ts

@@ -0,0 +1,47 @@
+/**
+ * fhir-context — FileSystemLoader
+ *
+ * Loads StructureDefinitions from local JSON files on disk.
+ * Uses the fhir-parser module to parse raw JSON into typed models.
+ *
+ * URL-to-path mapping strategy:
+ * - Extract the resource name from the canonical URL tail
+ *   (e.g., `http://hl7.org/fhir/StructureDefinition/Patient` → `Patient`)
+ * - Look for `{basePath}/{name}.json`
+ *
+ * @module fhir-context
+ */
+import type { StructureDefinition } from '../../model/index.js';
+import type { StructureDefinitionLoader } from '../types.js';
+/**
+ * Extract the resource name from a canonical URL.
+ *
+ * @param url - e.g. `"http://hl7.org/fhir/StructureDefinition/Patient"`
+ * @returns The last path segment, e.g. `"Patient"`
+ */
+export declare function extractResourceName(url: string): string;
+/**
+ * A loader that resolves StructureDefinitions from local JSON files.
+ *
+ * @example
+ * ```typescript
+ * const loader = new FileSystemLoader('/path/to/definitions');
+ * const sd = await loader.load('http://hl7.org/fhir/StructureDefinition/Patient');
+ * // Reads /path/to/definitions/Patient.json
+ * ```
+ */
+export declare class FileSystemLoader implements StructureDefinitionLoader {
+    private readonly _basePath;
+    /**
+     * @param basePath - Directory containing `{ResourceName}.json` files
+     */
+    constructor(basePath: string);
+    load(url: string): Promise<StructureDefinition | null>;
+    canLoad(url: string): boolean;
+    getSourceType(): string;
+    /**
+     * The base directory this loader reads from.
+     */
+    get basePath(): string;
+}
+//# sourceMappingURL=file-loader.d.ts.map

package/dist/lib/context/loaders/file-loader.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"file-loader.d.ts","sourceRoot":"","sources":["../../../../src/context/loaders/file-loader.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAMH,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,sBAAsB,CAAC;AAChE,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,aAAa,CAAC;AAI7D;;;;;GAKG;AACH,wBAAgB,mBAAmB,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAGvD;AAED;;;;;;;;;GASG;AACH,qBAAa,gBAAiB,YAAW,yBAAyB;IAChE,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAS;IAEnC;;OAEG;gBACS,QAAQ,EAAE,MAAM;IAItB,IAAI,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,mBAAmB,GAAG,IAAI,CAAC;IAiC5D,OAAO,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO;IAM7B,aAAa,IAAI,MAAM;IAIvB;;OAEG;IACH,IAAI,QAAQ,IAAI,MAAM,CAErB;CACF"}

package/dist/lib/context/loaders/index.d.ts

@@ -0,0 +1,11 @@
+/**
+ * fhir-context — Loader Barrel Exports
+ *
+ * Re-exports all concrete {@link StructureDefinitionLoader} implementations.
+ *
+ * @module fhir-context
+ */
+export { MemoryLoader } from './memory-loader.js';
+export { FileSystemLoader, extractResourceName } from './file-loader.js';
+export { CompositeLoader } from './composite-loader.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/lib/context/loaders/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/context/loaders/index.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAClD,OAAO,EAAE,gBAAgB,EAAE,mBAAmB,EAAE,MAAM,kBAAkB,CAAC;AACzE,OAAO,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAC"}

package/dist/lib/context/loaders/memory-loader.d.ts

@@ -0,0 +1,42 @@
+/**
+ * fhir-context — MemoryLoader
+ *
+ * Loads StructureDefinitions from an in-memory Map.
+ * Primary use cases:
+ * - Unit testing (inject known definitions)
+ * - Preloaded core FHIR R4 definitions
+ *
+ * @module fhir-context
+ */
+import type { StructureDefinition } from '../../model/index.js';
+import type { StructureDefinitionLoader } from '../types.js';
+/**
+ * A loader that resolves StructureDefinitions from an in-memory Map.
+ *
+ * The map is keyed by canonical URL. Lookups are synchronous but the
+ * interface returns a Promise for consistency with other loaders.
+ *
+ * @example
+ * ```typescript
+ * const definitions = new Map<string, StructureDefinition>();
+ * definitions.set('http://hl7.org/fhir/StructureDefinition/Patient', patientSD);
+ * const loader = new MemoryLoader(definitions);
+ * ```
+ */
+export declare class MemoryLoader implements StructureDefinitionLoader {
+    private readonly _definitions;
+    /**
+     * @param definitions - Map of canonical URL → StructureDefinition.
+     *                      The map is **not** copied; mutations to the
+     *                      original map are visible to the loader.
+     */
+    constructor(definitions: Map<string, StructureDefinition>);
+    load(url: string): Promise<StructureDefinition | null>;
+    canLoad(url: string): boolean;
+    getSourceType(): string;
+    /**
+     * Number of definitions currently held in the map.
+     */
+    get size(): number;
+}
+//# sourceMappingURL=memory-loader.d.ts.map

package/dist/lib/context/loaders/memory-loader.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"memory-loader.d.ts","sourceRoot":"","sources":["../../../../src/context/loaders/memory-loader.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,sBAAsB,CAAC;AAChE,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,aAAa,CAAC;AAE7D;;;;;;;;;;;;GAYG;AACH,qBAAa,YAAa,YAAW,yBAAyB;IAC5D,OAAO,CAAC,QAAQ,CAAC,YAAY,CAAmC;IAEhE;;;;OAIG;gBACS,WAAW,EAAE,GAAG,CAAC,MAAM,EAAE,mBAAmB,CAAC;IAInD,IAAI,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,mBAAmB,GAAG,IAAI,CAAC;IAI5D,OAAO,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO;IAI7B,aAAa,IAAI,MAAM;IAIvB;;OAEG;IACH,IAAI,IAAI,IAAI,MAAM,CAEjB;CACF"}

package/dist/lib/context/registry.d.ts

@@ -0,0 +1,116 @@
+/**
+ * fhir-context — StructureDefinition Registry
+ *
+ * In-memory registry for storing and querying StructureDefinitions.
+ * Keyed by canonical URL with optional `|version` support.
+ *
+ * This is an internal component used by {@link FhirContextImpl}.
+ * It is not exported from the public API.
+ *
+ * @module fhir-context
+ */
+import type { StructureDefinition } from '../model/index.js';
+/**
+ * Parse a canonical URL that may contain a `|version` suffix.
+ *
+ * @param urlWithVersion - e.g. `"http://hl7.org/fhir/StructureDefinition/Patient|4.0.1"`
+ * @returns `{ url, version }` where `version` is `undefined` if absent
+ */
+export declare function parseVersionedUrl(urlWithVersion: string): {
+    url: string;
+    version: string | undefined;
+};
+/**
+ * Build a versioned registry key from URL and version.
+ *
+ * @param url - Canonical URL (without version)
+ * @param version - Semantic version string, or `undefined`
+ * @returns `"url|version"` if version is present, otherwise just `"url"`
+ */
+export declare function buildVersionedKey(url: string, version: string | undefined): string;
+/**
+ * In-memory registry for StructureDefinitions.
+ *
+ * Storage strategy:
+ * - **Primary map**: keyed by `url|version` (exact match)
+ * - **Latest map**: keyed by bare `url` → points to the most recently
+ *   registered version (for unversioned lookups)
+ *
+ * When a lookup uses a bare URL (no `|version`), the latest map is consulted.
+ * When a lookup uses `url|version`, the primary map is used for exact match.
+ */
+export declare class StructureDefinitionRegistry {
+    /** Primary storage: `url|version` → StructureDefinition */
+    private readonly _entries;
+    /** Latest-version index: bare `url` → `url|version` key in _entries */
+    private readonly _latestIndex;
+    /** Statistics counters */
+    private _queryCount;
+    private _hitCount;
+    /**
+     * Register a StructureDefinition.
+     *
+     * Validates that the definition has a `url` field. If a definition with
+     * the same URL (and version) already exists, it is silently replaced.
+     *
+     * @param sd - The StructureDefinition to register
+     * @throws {@link InvalidStructureDefinitionError} if `sd.url` is missing
+     */
+    register(sd: StructureDefinition): void;
+    /**
+     * Remove a StructureDefinition by canonical URL.
+     *
+     * @param urlWithVersion - Canonical URL (with optional `|version`)
+     * @returns `true` if a definition was removed, `false` if not found
+     */
+    delete(urlWithVersion: string): boolean;
+    /**
+     * Remove all entries and reset statistics.
+     */
+    clear(): void;
+    /**
+     * Retrieve a StructureDefinition by canonical URL.
+     *
+     * - If `urlWithVersion` contains `|version`, performs exact match.
+     * - If no version, returns the latest registered version.
+     *
+     * @param urlWithVersion - Canonical URL (with optional `|version`)
+     * @returns The StructureDefinition, or `undefined` if not found
+     */
+    get(urlWithVersion: string): StructureDefinition | undefined;
+    /**
+     * Check whether a StructureDefinition is registered.
+     *
+     * @param urlWithVersion - Canonical URL (with optional `|version`)
+     */
+    has(urlWithVersion: string): boolean;
+    /**
+     * Total number of registered StructureDefinitions.
+     */
+    get size(): number;
+    /**
+     * Return all registered canonical URLs (including version suffixes).
+     */
+    getAllKeys(): string[];
+    /**
+     * Return all registered bare URLs (without version suffixes).
+     */
+    getAllUrls(): string[];
+    /**
+     * Total number of `get()` calls.
+     */
+    get queryCount(): number;
+    /**
+     * Number of `get()` calls that returned a result (cache hits).
+     */
+    get hitCount(): number;
+    /**
+     * Number of `get()` calls that returned `undefined` (cache misses).
+     */
+    get missCount(): number;
+    /**
+     * Cache hit ratio (0–1). Returns 0 if no queries have been made.
+     */
+    get hitRate(): number;
+}
+//# sourceMappingURL=registry.d.ts.map

package/dist/lib/context/registry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"registry.d.ts","sourceRoot":"","sources":["../../../src/context/registry.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,mBAAmB,CAAC;AAO7D;;;;;GAKG;AACH,wBAAgB,iBAAiB,CAAC,cAAc,EAAE,MAAM,GAAG;IACzD,GAAG,EAAE,MAAM,CAAC;IACZ,OAAO,EAAE,MAAM,GAAG,SAAS,CAAC;CAC7B,CASA;AAED;;;;;;GAMG;AACH,wBAAgB,iBAAiB,CAC/B,GAAG,EAAE,MAAM,EACX,OAAO,EAAE,MAAM,GAAG,SAAS,GAC1B,MAAM,CAER;AAMD;;;;;;;;;;GAUG;AACH,qBAAa,2BAA2B;IACtC,2DAA2D;IAC3D,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAA0C;IAEnE,uEAAuE;IACvE,OAAO,CAAC,QAAQ,CAAC,YAAY,CAA6B;IAE1D,0BAA0B;IAC1B,OAAO,CAAC,WAAW,CAAK;IACxB,OAAO,CAAC,SAAS,CAAK;IAMtB;;;;;;;;OAQG;IACH,QAAQ,CAAC,EAAE,EAAE,mBAAmB,GAAG,IAAI;IAqBvC;;;;;OAKG;IACH,MAAM,CAAC,cAAc,EAAE,MAAM,GAAG,OAAO;IAyBvC;;OAEG;IACH,KAAK,IAAI,IAAI;IAWb;;;;;;;;OAQG;IACH,GAAG,CAAC,cAAc,EAAE,MAAM,GAAG,mBAAmB,GAAG,SAAS;IAuB5D;;;;OAIG;IACH,GAAG,CAAC,cAAc,EAAE,MAAM,GAAG,OAAO;IAUpC;;OAEG;IACH,IAAI,IAAI,IAAI,MAAM,CAEjB;IAED;;OAEG;IACH,UAAU,IAAI,MAAM,EAAE;IAItB;;OAEG;IACH,UAAU,IAAI,MAAM,EAAE;IAQtB;;OAEG;IACH,IAAI,UAAU,IAAI,MAAM,CAEvB;IAED;;OAEG;IACH,IAAI,QAAQ,IAAI,MAAM,CAErB;IAED;;OAEG;IACH,IAAI,SAAS,IAAI,MAAM,CAEtB;IAED;;OAEG;IACH,IAAI,OAAO,IAAI,MAAM,CAEpB;CACF"}

package/dist/lib/context/types.d.ts

@@ -0,0 +1,266 @@
+/**
+ * fhir-context — Public Interfaces & Types
+ *
+ * Defines the core abstractions for the FHIR context module:
+ * - {@link FhirContext} — central registry and lifecycle manager
+ * - {@link StructureDefinitionLoader} — pluggable loading strategy
+ * - {@link LoaderOptions} — loader configuration
+ * - {@link ContextStatistics} — runtime metrics
+ *
+ * This module is conceptually equivalent to HAPI's `FhirContext` +
+ * `IValidationSupport` interface, adapted for TypeScript/async patterns.
+ *
+ * @see https://hapifhir.io/hapi-fhir/docs/
+ * @module fhir-context
+ */
+import type { StructureDefinition, CanonicalProfile } from '../model/index.js';
+/**
+ * Central registry and lifecycle manager for FHIR StructureDefinitions.
+ *
+ * `FhirContext` is the primary entry point for accessing FHIR definitions
+ * at runtime. It manages loading, caching, and resolution of
+ * StructureDefinitions from one or more sources.
+ *
+ * Conceptual mapping:
+ * - HAPI `FhirContext` → registry + lifecycle
+ * - HAPI `IValidationSupport` → loader delegation
+ *
+ * Phase 4 (`fhir-profile`) will use this interface to load base definitions
+ * during snapshot generation.
+ *
+ * @example
+ * ```typescript
+ * const context = new FhirContextImpl({ loaders: [memoryLoader, fileLoader] });
+ * await context.preloadCoreDefinitions();
+ *
+ * const patient = await context.loadStructureDefinition(
+ *   'http://hl7.org/fhir/StructureDefinition/Patient'
+ * );
+ * const chain = await context.resolveInheritanceChain(patient.url!);
+ * // → ['http://hl7.org/fhir/StructureDefinition/Patient',
+ * //    'http://hl7.org/fhir/StructureDefinition/DomainResource',
+ * //    'http://hl7.org/fhir/StructureDefinition/Resource']
+ * ```
+ */
+export interface FhirContext {
+    /**
+     * Load a StructureDefinition by canonical URL.
+     *
+     * Resolution order:
+     * 1. Check internal registry (cache hit)
+     * 2. Delegate to configured loaders (cache miss)
+     * 3. Parse, validate, and register the result
+     *
+     * Supports versioned URLs in `url|version` format
+     * (e.g., `"http://example.org/Profile|1.0.0"`).
+     *
+     * @param url - Canonical URL, optionally with `|version` suffix
+     * @returns Resolved StructureDefinition
+     * @throws {@link ResourceNotFoundError} if no loader can resolve the URL
+     * @throws {@link LoaderError} if a loader fails during loading
+     * @throws {@link InvalidStructureDefinitionError} if the loaded resource is malformed
+     */
+    loadStructureDefinition(url: string): Promise<StructureDefinition>;
+    /**
+     * Synchronously retrieve a StructureDefinition from the registry.
+     *
+     * Does **not** trigger any loader — only checks the in-memory registry.
+     * Use {@link loadStructureDefinition} if you need on-demand loading.
+     *
+     * @param url - Canonical URL (with optional `|version`)
+     * @returns The cached StructureDefinition, or `undefined` if not loaded
+     */
+    getStructureDefinition(url: string): StructureDefinition | undefined;
+    /**
+     * Check whether a StructureDefinition is present in the registry.
+     *
+     * @param url - Canonical URL (with optional `|version`)
+     */
+    hasStructureDefinition(url: string): boolean;
+    /**
+     * Resolve the full inheritance chain for a profile.
+     *
+     * Walks the `baseDefinition` links from the given URL up to the root
+     * resource type (e.g., `Resource`). Each base is loaded on demand if
+     * not already in the registry.
+     *
+     * @param url - Canonical URL of the starting profile
+     * @returns Array of canonical URLs from child to root
+     *          (e.g., `[ChinesePatient, Patient, DomainResource, Resource]`)
+     * @throws {@link CircularDependencyError} if a cycle is detected
+     * @throws {@link ResourceNotFoundError} if a base definition cannot be found
+     */
+    resolveInheritanceChain(url: string): Promise<string[]>;
+    /**
+     * Register a StructureDefinition in the registry.
+     *
+     * This is used for:
+     * - Manually adding definitions (e.g., custom profiles)
+     * - Phase 4: caching generated snapshots back into the context
+     *
+     * If a definition with the same URL (and version) already exists,
+     * it will be replaced and any cached inheritance chains invalidated.
+     *
+     * @param sd - The StructureDefinition to register
+     * @throws {@link InvalidStructureDefinitionError} if `sd.url` is missing
+     */
+    registerStructureDefinition(sd: StructureDefinition): void;
+    /**
+     * Preload FHIR R4 core StructureDefinitions.
+     *
+     * Loads base resource types (Resource, DomainResource, Patient,
+     * Observation, etc.) into the registry so they are available
+     * synchronously via {@link getStructureDefinition}.
+     *
+     * Should be called once during application initialization.
+     */
+    preloadCoreDefinitions(): Promise<void>;
+    /**
+     * Return runtime statistics for monitoring and diagnostics.
+     */
+    getStatistics(): ContextStatistics;
+    /**
+     * Register a CanonicalProfile and its extracted InnerTypes.
+     *
+     * This is the primary method for making InnerTypes available for
+     * downstream consumption (UI forms, recursive validation, etc.).
+     * Typically called after snapshot generation + `extractInnerTypes()`.
+     *
+     * @param profile - The CanonicalProfile (with innerTypes populated)
+     */
+    registerCanonicalProfile(profile: CanonicalProfile): void;
+    /**
+     * Retrieve an InnerType schema by its generated type name.
+     *
+     * @param typeName - Generated type name (e.g., `'PatientContact'`)
+     * @returns The InnerType CanonicalProfile, or `undefined` if not registered
+     */
+    getInnerType(typeName: string): CanonicalProfile | undefined;
+    /**
+     * Check whether an InnerType is registered.
+     *
+     * @param typeName - Generated type name (e.g., `'PatientContact'`)
+     */
+    hasInnerType(typeName: string): boolean;
+    /**
+     * Release all cached data and reset internal state.
+     *
+     * After calling `dispose()`, the context must be re-initialized
+     * (e.g., by calling {@link preloadCoreDefinitions} again).
+     */
+    dispose(): void;
+}
+/**
+ * Pluggable strategy for loading StructureDefinitions from an external source.
+ *
+ * Implementations include:
+ * - `MemoryLoader` — loads from an in-memory map (for testing / preloaded data)
+ * - `FileSystemLoader` — loads from local JSON files
+ * - `CompositeLoader` — chains multiple loaders (fallback pattern)
+ *
+ * Conceptually equivalent to HAPI's `IValidationSupport` implementations.
+ */
+export interface StructureDefinitionLoader {
+    /**
+     * Attempt to load a StructureDefinition by canonical URL.
+     *
+     * @param url - Canonical URL (without `|version` — version is stripped
+     *              by the caller before delegation)
+     * @returns The loaded StructureDefinition, or `null` if this loader
+     *          cannot resolve the URL (allows fallback to next loader)
+     * @throws {@link LoaderError} on I/O or parse failures
+     */
+    load(url: string): Promise<StructureDefinition | null>;
+    /**
+     * Quick check whether this loader is likely able to resolve the URL.
+     *
+     * This is a hint — returning `true` does not guarantee `load()` will
+     * succeed. Returning `false` allows the composite loader to skip this
+     * source entirely.
+     *
+     * @param url - Canonical URL to check
+     */
+    canLoad(url: string): boolean;
+    /**
+     * Human-readable identifier for the loader source.
+     *
+     * Used in error messages and diagnostics.
+     *
+     * @returns Source type label (e.g., `'memory'`, `'filesystem'`, `'http'`)
+     */
+    getSourceType(): string;
+}
+/**
+ * Configuration options for creating a {@link FhirContext}.
+ */
+export interface FhirContextOptions {
+    /**
+     * One or more loaders to use for resolving StructureDefinitions.
+     *
+     * When multiple loaders are provided, they are tried in order
+     * (first match wins — chain of responsibility pattern).
+     */
+    loaders: StructureDefinitionLoader[];
+    /**
+     * Whether to automatically call {@link FhirContext.preloadCoreDefinitions}
+     * during initialization.
+     *
+     * @defaultValue `true`
+     */
+    preloadCore?: boolean;
+    /**
+     * Path to the FHIR R4 specification directory.
+     *
+     * Used by the core definition preloader to locate `profiles-resources.json`
+     * and `profiles-types.json`.
+     *
+     * @defaultValue `undefined` (uses bundled definitions)
+     */
+    specDirectory?: string;
+}
+/**
+ * Options for individual loader instances.
+ */
+export interface LoaderOptions {
+    /**
+     * Base directory or URL prefix for resolving relative paths.
+     */
+    basePath?: string;
+    /**
+     * Request timeout in milliseconds (for future HTTP loaders).
+     *
+     * @defaultValue `30000`
+     */
+    timeout?: number;
+    /**
+     * Number of retry attempts on transient failures.
+     *
+     * @defaultValue `0`
+     */
+    retryCount?: number;
+}
+/**
+ * Runtime metrics for the {@link FhirContext}.
+ *
+ * Useful for monitoring cache effectiveness and diagnosing
+ * performance issues.
+ */
+export interface ContextStatistics {
+    /** Total number of StructureDefinitions in the registry */
+    totalLoaded: number;
+    /** Number of `loadStructureDefinition` calls resolved from cache */
+    cacheHits: number;
+    /** Number of `loadStructureDefinition` calls that required loader delegation */
+    cacheMisses: number;
+    /** Total number of loader invocations across all loaders */
+    loaderCalls: number;
+    /** Number of inheritance chains resolved */
+    chainsResolved: number;
+    /** Number of `registerStructureDefinition` calls */
+    registrations: number;
+}
+/**
+ * Create a fresh statistics object with all counters at zero.
+ */
+export declare function createEmptyStatistics(): ContextStatistics;
+//# sourceMappingURL=types.d.ts.map

package/dist/lib/context/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/context/types.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,OAAO,KAAK,EAAE,mBAAmB,EAAE,gBAAgB,EAAE,MAAM,mBAAmB,CAAC;AAM/E;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,MAAM,WAAW,WAAW;IAC1B;;;;;;;;;;;;;;;;OAgBG;IACH,uBAAuB,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,mBAAmB,CAAC,CAAC;IAEnE;;;;;;;;OAQG;IACH,sBAAsB,CAAC,GAAG,EAAE,MAAM,GAAG,mBAAmB,GAAG,SAAS,CAAC;IAErE;;;;OAIG;IACH,sBAAsB,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC;IAE7C;;;;;;;;;;;;OAYG;IACH,uBAAuB,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC,CAAC;IAExD;;;;;;;;;;;;OAYG;IACH,2BAA2B,CAAC,EAAE,EAAE,mBAAmB,GAAG,IAAI,CAAC;IAE3D;;;;;;;;OAQG;IACH,sBAAsB,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;IAExC;;OAEG;IACH,aAAa,IAAI,iBAAiB,CAAC;IAEnC;;;;;;;;OAQG;IACH,wBAAwB,CAAC,OAAO,EAAE,gBAAgB,GAAG,IAAI,CAAC;IAE1D;;;;;OAKG;IACH,YAAY,CAAC,QAAQ,EAAE,MAAM,GAAG,gBAAgB,GAAG,SAAS,CAAC;IAE7D;;;;OAIG;IACH,YAAY,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC;IAExC;;;;;OAKG;IACH,OAAO,IAAI,IAAI,CAAC;CACjB;AAMD;;;;;;;;;GASG;AACH,MAAM,WAAW,yBAAyB;IACxC;;;;;;;;OAQG;IACH,IAAI,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,mBAAmB,GAAG,IAAI,CAAC,CAAC;IAEvD;;;;;;;;OAQG;IACH,OAAO,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC;IAE9B;;;;;;OAMG;IACH,aAAa,IAAI,MAAM,CAAC;CACzB;AAMD;;GAEG;AACH,MAAM,WAAW,kBAAkB;IACjC;;;;;OAKG;IACH,OAAO,EAAE,yBAAyB,EAAE,CAAC;IAErC;;;;;OAKG;IACH,WAAW,CAAC,EAAE,OAAO,CAAC;IAEtB;;;;;;;OAOG;IACH,aAAa,CAAC,EAAE,MAAM,CAAC;CACxB;AAED;;GAEG;AACH,MAAM,WAAW,aAAa;IAC5B;;OAEG;IACH,QAAQ,CAAC,EAAE,MAAM,CAAC;IAElB;;;;OAIG;IACH,OAAO,CAAC,EAAE,MAAM,CAAC;IAEjB;;;;OAIG;IACH,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;AAMD;;;;;GAKG;AACH,MAAM,WAAW,iBAAiB;IAChC,2DAA2D;IAC3D,WAAW,EAAE,MAAM,CAAC;IAEpB,oEAAoE;IACpE,SAAS,EAAE,MAAM,CAAC;IAElB,gFAAgF;IAChF,WAAW,EAAE,MAAM,CAAC;IAEpB,4DAA4D;IAC5D,WAAW,EAAE,MAAM,CAAC;IAEpB,4CAA4C;IAC5C,cAAc,EAAE,MAAM,CAAC;IAEvB,oDAAoD;IACpD,aAAa,EAAE,MAAM,CAAC;CACvB;AAED;;GAEG;AACH,wBAAgB,qBAAqB,IAAI,iBAAiB,CASzD"}