@atomic-ehr/codegen 0.0.1-canary.20250821160126.c552195 → 0.0.1-canary.20250822150706.c3b8669

package/dist/typeschema/cache.js

@@ -0,0 +1,285 @@
+/**
+ * TypeSchema Cache System
+ *
+ * Caching system for TypeSchema documents with both in-memory and persistent file-based storage.
+ */
+import { existsSync, mkdirSync } from "node:fs";
+import { readdir, readFile, stat, unlink, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+/**
+ * TypeSchema Cache with optional persistent storage
+ */
+export class TypeSchemaCache {
+    cache = new Map();
+    config;
+    cacheDir;
+    constructor(config) {
+        this.config = {
+            enablePersistence: true,
+            cacheDir: ".typeschema-cache",
+            maxAge: 24 * 60 * 60 * 1000, // 24 hours
+            validateCached: true,
+            ...config,
+        };
+        if (this.config.enablePersistence && this.config.cacheDir) {
+            this.cacheDir = this.config.cacheDir;
+        }
+    }
+    /**
+     * Store a schema in the cache
+     */
+    async set(schema) {
+        const key = this.generateKey(schema.identifier);
+        this.cache.set(key, schema);
+        // Persist to disk if enabled
+        if (this.config.enablePersistence && this.cacheDir) {
+            await this.persistSchema(schema);
+        }
+    }
+    /**
+     * Retrieve a schema by identifier
+     */
+    get(identifier) {
+        const key = this.generateKey(identifier);
+        return this.cache.get(key) || null;
+    }
+    /**
+     * Retrieve a schema by URL
+     */
+    getByUrl(url) {
+        for (const schema of this.cache.values()) {
+            if (schema.identifier.url === url) {
+                return schema;
+            }
+        }
+        return null;
+    }
+    /**
+     * Check if a schema exists in cache
+     */
+    has(identifier) {
+        const key = this.generateKey(identifier);
+        return this.cache.has(key);
+    }
+    /**
+     * Check if a schema exists by URL
+     */
+    hasByUrl(url) {
+        for (const schema of this.cache.values()) {
+            if (schema.identifier.url === url) {
+                return true;
+            }
+        }
+        return false;
+    }
+    /**
+     * Delete a schema from cache
+     */
+    delete(identifier) {
+        const key = this.generateKey(identifier);
+        return this.cache.delete(key);
+    }
+    /**
+     * Delete a schema by URL
+     */
+    deleteByUrl(url) {
+        for (const [key, schema] of this.cache.entries()) {
+            if (schema.identifier.url === url) {
+                return this.cache.delete(key);
+            }
+        }
+        return false;
+    }
+    /**
+     * Get schemas by package
+     */
+    getByPackage(packageName) {
+        const results = [];
+        for (const schema of this.cache.values()) {
+            if (schema.identifier.package === packageName) {
+                results.push(schema);
+            }
+        }
+        return results;
+    }
+    /**
+     * Get schemas by kind
+     */
+    getByKind(kind) {
+        const results = [];
+        for (const schema of this.cache.values()) {
+            if (schema.identifier.kind === kind) {
+                results.push(schema);
+            }
+        }
+        return results;
+    }
+    /**
+     * Store multiple schemas
+     */
+    setMany(schemas) {
+        for (const schema of schemas) {
+            this.set(schema);
+        }
+    }
+    /**
+     * Clear all cached schemas
+     */
+    clear() {
+        this.cache.clear();
+    }
+    /**
+     * Generate cache key for identifier
+     */
+    generateKey(identifier) {
+        return `${identifier.package}:${identifier.version}:${identifier.kind}:${identifier.name}`;
+    }
+    /**
+     * Initialize cache directory if persistence is enabled
+     */
+    async initialize() {
+        if (this.config.enablePersistence && this.cacheDir) {
+            // Ensure cache directory exists
+            if (!existsSync(this.cacheDir)) {
+                mkdirSync(this.cacheDir, { recursive: true });
+            }
+            // Load all cached schemas from disk
+            await this.loadFromDisk();
+        }
+    }
+    /**
+     * Load all cached schemas from disk
+     */
+    async loadFromDisk() {
+        if (!this.cacheDir || !existsSync(this.cacheDir)) {
+            return;
+        }
+        try {
+            const files = await readdir(this.cacheDir);
+            const schemaFiles = files.filter((f) => f.endsWith(".typeschema.json"));
+            for (const file of schemaFiles) {
+                const filePath = join(this.cacheDir, file);
+                const stats = await stat(filePath);
+                // Check if cache is expired
+                if (this.config.maxAge) {
+                    const age = Date.now() - stats.mtimeMs;
+                    if (age > this.config.maxAge) {
+                        // Remove expired cache file
+                        await unlink(filePath);
+                        continue;
+                    }
+                }
+                try {
+                    const content = await readFile(filePath, "utf-8");
+                    const metadata = JSON.parse(content);
+                    // Validate cached schema if configured
+                    if (this.config.validateCached) {
+                        // Basic validation - check required fields
+                        if (!metadata.schema?.identifier) {
+                            continue;
+                        }
+                    }
+                    // Add to in-memory cache
+                    const key = this.generateKey(metadata.schema.identifier);
+                    this.cache.set(key, metadata.schema);
+                }
+                catch (error) {
+                    console.warn(`Failed to load cached schema from ${file}:`, error);
+                }
+            }
+        }
+        catch (error) {
+            console.warn("Failed to load cached schemas from disk:", error);
+        }
+    }
+    /**
+     * Persist a schema to disk
+     */
+    async persistSchema(schema) {
+        if (!this.cacheDir) {
+            return;
+        }
+        // Ensure cache directory exists
+        if (!existsSync(this.cacheDir)) {
+            mkdirSync(this.cacheDir, { recursive: true });
+        }
+        const metadata = {
+            schema,
+            timestamp: Date.now(),
+            version: schema.identifier.version,
+        };
+        // Generate filename from identifier
+        const fileName = `${schema.identifier.package}-${schema.identifier.version}-${schema.identifier.kind}-${schema.identifier.name}.typeschema.json`.replace(/[^a-zA-Z0-9.-]/g, "_");
+        const filePath = join(this.cacheDir, fileName);
+        try {
+            await writeFile(filePath, JSON.stringify(metadata, null, 2), "utf-8");
+        }
+        catch (error) {
+            console.warn(`Failed to persist schema to ${filePath}:`, error);
+        }
+    }
+    /**
+     * Clear cache directory
+     */
+    async clearDisk() {
+        if (!this.cacheDir || !existsSync(this.cacheDir)) {
+            return;
+        }
+        try {
+            const files = await readdir(this.cacheDir);
+            const schemaFiles = files.filter((f) => f.endsWith(".typeschema.json"));
+            for (const file of schemaFiles) {
+                await unlink(join(this.cacheDir, file));
+            }
+        }
+        catch (error) {
+            console.warn("Failed to clear cache directory:", error);
+        }
+    }
+}
+// Global cache instance
+let globalCache = null;
+/**
+ * Get the global cache instance
+ */
+export function getGlobalCache(config) {
+    if (!globalCache) {
+        globalCache = new TypeSchemaCache(config);
+    }
+    return globalCache;
+}
+/**
+ * Initialize global cache with configuration
+ */
+export async function initializeGlobalCache(config) {
+    globalCache = new TypeSchemaCache(config);
+    await globalCache.initialize();
+    return globalCache;
+}
+/**
+ * Clear the global cache
+ */
+export function clearGlobalCache() {
+    if (globalCache) {
+        globalCache.clear();
+    }
+    globalCache = null;
+}
+/**
+ * Cache a schema using global cache
+ */
+export function cacheSchema(schema) {
+    getGlobalCache().set(schema);
+}
+/**
+ * Get cached schema using global cache
+ */
+export function getCachedSchema(identifier) {
+    return getGlobalCache().get(identifier);
+}
+/**
+ * Check if schema is cached using global cache
+ */
+export function isCached(identifier) {
+    return getGlobalCache().has(identifier);
+}

package/dist/typeschema/core/binding.d.ts

@@ -5,7 +5,7 @@
  */
 import type { CanonicalManager } from "@atomic-ehr/fhir-canonical-manager";
 import type { FHIRSchema, FHIRSchemaElement } from "@atomic-ehr/fhirschema";
-import type { PackageInfo, TypeSchemaForBinding } from "../types";
+import type { PackageInfo, TypeSchemaForBinding } from "../types.js";
 /**
  * Extract concepts from a ValueSet
  */

package/dist/typeschema/core/binding.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"binding.d.ts","sourceRoot":"","sources":["../../../src/typeschema/core/binding.ts"],"names":[],"mappings":"AACA;;;;GAIG;AAEH,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,oCAAoC,CAAC;AAC3E,OAAO,KAAK,EAAE,UAAU,EAAE,iBAAiB,EAAE,MAAM,wBAAwB,CAAC;AAC5E,OAAO,KAAK,EAAE,WAAW,EAAE,oBAAoB,EAAE,MAAM,UAAU,CAAC;AAQlE;;GAEG;AACH,wBAAsB,uBAAuB,CAC5C,WAAW,EAAE,MAAM,EACnB,OAAO,EAAE,UAAU,CAAC,OAAO,gBAAgB,CAAC,GAC1C,OAAO,CACT,KAAK,CAAC;IAAE,MAAM,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,OAAO,CAAC,EAAE,MAAM,CAAA;CAAE,CAAC,GAAG,SAAS,CACrE,CA8DA;AAED;;GAEG;AACH,wBAAsB,SAAS,CAC9B,OAAO,EAAE,iBAAiB,EAC1B,OAAO,EAAE,UAAU,CAAC,OAAO,gBAAgB,CAAC,GAC1C,OAAO,CAAC,MAAM,EAAE,GAAG,SAAS,CAAC,CA4C/B;AAED;;GAEG;AACH,wBAAsB,qBAAqB,CAC1C,UAAU,EAAE,UAAU,EACtB,IAAI,EAAE,MAAM,EAAE,EACd,OAAO,EAAE,iBAAiB,EAC1B,OAAO,EAAE,UAAU,CAAC,OAAO,gBAAgB,CAAC,EAC5C,WAAW,CAAC,EAAE,WAAW,GACvB,OAAO,CAAC,oBAAoB,GAAG,SAAS,CAAC,CA8C3C;AAED;;GAEG;AACH,wBAAsB,qBAAqB,CAC1C,UAAU,EAAE,UAAU,EACtB,OAAO,EAAE,UAAU,CAAC,OAAO,gBAAgB,CAAC,EAC5C,WAAW,CAAC,EAAE,WAAW,GACvB,OAAO,CAAC,oBAAoB,EAAE,CAAC,CA0DjC"}
+{"version":3,"file":"binding.d.ts","sourceRoot":"","sources":["../../../src/typeschema/core/binding.ts"],"names":[],"mappings":"AACA;;;;GAIG;AAEH,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,oCAAoC,CAAC;AAC3E,OAAO,KAAK,EAAE,UAAU,EAAE,iBAAiB,EAAE,MAAM,wBAAwB,CAAC;AAC5E,OAAO,KAAK,EAAE,WAAW,EAAE,oBAAoB,EAAE,MAAM,aAAa,CAAC;AAQrE;;GAEG;AACH,wBAAsB,uBAAuB,CAC5C,WAAW,EAAE,MAAM,EACnB,OAAO,EAAE,UAAU,CAAC,OAAO,gBAAgB,CAAC,GAC1C,OAAO,CACT,KAAK,CAAC;IAAE,MAAM,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,OAAO,CAAC,EAAE,MAAM,CAAA;CAAE,CAAC,GAAG,SAAS,CACrE,CA8DA;AAED;;GAEG;AACH,wBAAsB,SAAS,CAC9B,OAAO,EAAE,iBAAiB,EAC1B,OAAO,EAAE,UAAU,CAAC,OAAO,gBAAgB,CAAC,GAC1C,OAAO,CAAC,MAAM,EAAE,GAAG,SAAS,CAAC,CA4C/B;AAED;;GAEG;AACH,wBAAsB,qBAAqB,CAC1C,UAAU,EAAE,UAAU,EACtB,IAAI,EAAE,MAAM,EAAE,EACd,OAAO,EAAE,iBAAiB,EAC1B,OAAO,EAAE,UAAU,CAAC,OAAO,gBAAgB,CAAC,EAC5C,WAAW,CAAC,EAAE,WAAW,GACvB,OAAO,CAAC,oBAAoB,GAAG,SAAS,CAAC,CA8C3C;AAED;;GAEG;AACH,wBAAsB,qBAAqB,CAC1C,UAAU,EAAE,UAAU,EACtB,OAAO,EAAE,UAAU,CAAC,OAAO,gBAAgB,CAAC,EAC5C,WAAW,CAAC,EAAE,WAAW,GACvB,OAAO,CAAC,oBAAoB,EAAE,CAAC,CA0DjC"}

package/dist/typeschema/core/binding.js

@@ -0,0 +1,187 @@
+// @ts-nocheck
+/**
+ * Binding and Enum Handling
+ *
+ * Functions for processing value set bindings and generating enums
+ */
+import { buildFieldType } from "./field-builder.js";
+import { buildBindingIdentifier, buildValueSetIdentifier, dropVersionFromUrl, } from "./identifier.js";
+/**
+ * Extract concepts from a ValueSet
+ */
+export async function extractValueSetConcepts(valueSetUrl, manager) {
+    try {
+        const cleanUrl = dropVersionFromUrl(valueSetUrl) || valueSetUrl;
+        const valueSet = await manager.resolve(cleanUrl);
+        if (!valueSet)
+            return undefined;
+        // If expansion is available, use it
+        if (valueSet.expansion?.contains) {
+            return valueSet.expansion.contains.map((concept) => ({
+                system: concept.system,
+                code: concept.code,
+                display: concept.display,
+            }));
+        }
+        // Otherwise try to extract from compose
+        const concepts = [];
+        if (valueSet.compose?.include) {
+            for (const include of valueSet.compose.include) {
+                if (include.concept) {
+                    // Direct concept list
+                    for (const concept of include.concept) {
+                        concepts.push({
+                            system: include.system,
+                            code: concept.code,
+                            display: concept.display,
+                        });
+                    }
+                }
+                else if (include.system && !include.filter) {
+                    // Include all from CodeSystem
+                    try {
+                        const codeSystem = await manager.resolve(include.system);
+                        if (codeSystem?.concept) {
+                            const extractConcepts = (conceptList, system) => {
+                                for (const concept of conceptList) {
+                                    concepts.push({
+                                        system,
+                                        code: concept.code,
+                                        display: concept.display,
+                                    });
+                                    // Handle nested concepts
+                                    if (concept.concept) {
+                                        extractConcepts(concept.concept, system);
+                                    }
+                                }
+                            };
+                            extractConcepts(codeSystem.concept, include.system);
+                        }
+                    }
+                    catch {
+                        // Ignore if we can't resolve the CodeSystem
+                    }
+                }
+            }
+        }
+        return concepts.length > 0 ? concepts : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+/**
+ * Build enum values from binding if applicable
+ */
+export async function buildEnum(element, manager) {
+    if (!element.binding)
+        return undefined;
+    const { strength, valueSet } = element.binding;
+    if (!valueSet)
+        return undefined;
+    // Enhanced support for more binding strengths and types
+    // Generate enum for:
+    // 1. Required bindings (always)
+    // 2. Extensible bindings on code types (for better type safety)
+    // 3. Preferred bindings on code types (for common usage patterns)
+    const shouldGenerateEnum = strength === "required" ||
+        (strength === "extensible" && element.type === "code") ||
+        (strength === "preferred" && element.type === "code");
+    if (!shouldGenerateEnum) {
+        return undefined;
+    }
+    // Check if manager is available and functional
+    if (!manager.resolve) {
+        return undefined;
+    }
+    try {
+        const concepts = await extractValueSetConcepts(valueSet, manager);
+        if (!concepts || concepts.length === 0)
+            return undefined;
+        // Extract just the codes and filter out any empty/invalid ones
+        const codes = concepts
+            .map((c) => c.code)
+            .filter((code) => code && typeof code === "string" && code.trim().length > 0);
+        // Only return if we have valid codes and not too many (avoid huge enums)
+        return codes.length > 0 && codes.length <= 50 ? codes : undefined;
+    }
+    catch (error) {
+        // Log the error for debugging but don't fail the generation
+        console.debug(`Failed to extract enum values for ${valueSet}: ${error}`);
+        return undefined;
+    }
+}
+/**
+ * Generate a binding TypeSchema
+ */
+export async function generateBindingSchema(fhirSchema, path, element, manager, packageInfo) {
+    if (!element.binding?.valueSet)
+        return undefined;
+    const identifier = buildBindingIdentifier(fhirSchema, path, element.binding.bindingName, packageInfo);
+    const fieldType = buildFieldType(fhirSchema, path, element, manager, packageInfo);
+    const valueSetIdentifier = buildValueSetIdentifier(element.binding.valueSet, undefined, packageInfo);
+    const binding = {
+        identifier,
+        type: fieldType,
+        valueset: valueSetIdentifier,
+        strength: element.binding.strength,
+        dependencies: [],
+    };
+    // Add dependencies in specific order: type first, then value set
+    if (fieldType) {
+        binding.dependencies.push(fieldType);
+    }
+    binding.dependencies.push(valueSetIdentifier);
+    // Add enum if applicable
+    const enumValues = await buildEnum(element, manager);
+    if (enumValues) {
+        binding.enum = enumValues;
+    }
+    // Don't sort dependencies - keep them in the order: type, then value set
+    return binding;
+}
+/**
+ * Collect all binding schemas from a FHIRSchema
+ */
+export async function collectBindingSchemas(fhirSchema, manager, packageInfo) {
+    const bindings = [];
+    const processedPaths = new Set();
+    // Recursive function to process elements
+    async function processElement(elements, parentPath) {
+        for (const [key, element] of Object.entries(elements)) {
+            const path = [...parentPath, key];
+            const pathKey = path.join(".");
+            // Skip if already processed
+            if (processedPaths.has(pathKey))
+                continue;
+            processedPaths.add(pathKey);
+            // Generate binding if present
+            if (element.binding) {
+                const binding = await generateBindingSchema(fhirSchema, path, element, manager, packageInfo);
+                if (binding) {
+                    bindings.push(binding);
+                }
+            }
+            // Process nested elements
+            if (element.elements) {
+                await processElement(element.elements, path);
+            }
+        }
+    }
+    // Start processing from root elements
+    if (fhirSchema.elements) {
+        await processElement(fhirSchema.elements, []);
+    }
+    // Sort bindings by identifier name for consistent output
+    bindings.sort((a, b) => a.identifier.name.localeCompare(b.identifier.name));
+    // Remove duplicates (same identifier URL)
+    const uniqueBindings = [];
+    const seenUrls = new Set();
+    for (const binding of bindings) {
+        if (!seenUrls.has(binding.identifier.url)) {
+            seenUrls.add(binding.identifier.url);
+            uniqueBindings.push(binding);
+        }
+    }
+    return uniqueBindings;
+}

package/dist/typeschema/core/field-builder.d.ts

@@ -5,7 +5,7 @@
  */
 import type { CanonicalManager } from "@atomic-ehr/fhir-canonical-manager";
 import type { FHIRSchema, FHIRSchemaElement } from "@atomic-ehr/fhirschema";
-import type { PackageInfo, TypeSchemaField, TypeSchemaIdentifier } from "../types";
+import type { PackageInfo, TypeSchemaField, TypeSchemaIdentifier } from "../types.js";
 /**
  * Get the full element hierarchy for a given path
  */

package/dist/typeschema/core/field-builder.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"field-builder.d.ts","sourceRoot":"","sources":["../../../src/typeschema/core/field-builder.ts"],"names":[],"mappings":"AAEA;;;;GAIG;AAEH,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,oCAAoC,CAAC;AAC3E,OAAO,KAAK,EAAE,UAAU,EAAE,iBAAiB,EAAE,MAAM,wBAAwB,CAAC;AAC5E,OAAO,KAAK,EACX,WAAW,EACX,eAAe,EACf,oBAAoB,EACpB,MAAM,UAAU,CAAC;AAQlB;;GAEG;AACH,wBAAgB,mBAAmB,CAClC,UAAU,EAAE,UAAU,EACtB,IAAI,EAAE,MAAM,EAAE,EACd,QAAQ,EAAE,UAAU,CAAC,OAAO,gBAAgB,CAAC,GAC3C,iBAAiB,EAAE,CAkBrB;AAED;;GAEG;AACH,wBAAgB,qBAAqB,CACpC,SAAS,EAAE,iBAAiB,EAAE,GAC5B,iBAAiB,CAoDnB;AAED;;GAEG;AACH,wBAAgB,UAAU,CACzB,UAAU,EAAE,UAAU,EACtB,IAAI,EAAE,MAAM,EAAE,EACd,QAAQ,EAAE,UAAU,CAAC,OAAO,gBAAgB,CAAC,GAC3C,OAAO,CA4BT;AAED;;GAEG;AACH,wBAAgB,UAAU,CACzB,UAAU,EAAE,UAAU,EACtB,IAAI,EAAE,MAAM,EAAE,EACd,QAAQ,EAAE,UAAU,CAAC,OAAO,gBAAgB,CAAC,GAC3C,OAAO,CA4BT;AAED;;GAEG;AACH,wBAAsB,eAAe,CACpC,OAAO,EAAE,iBAAiB,EAC1B,OAAO,EAAE,UAAU,CAAC,OAAO,gBAAgB,CAAC,EAC5C,WAAW,CAAC,EAAE,WAAW,GACvB,OAAO,CAAC,oBAAoB,EAAE,GAAG,SAAS,CAAC,CAmB7C;AAED;;GAEG;AACH,wBAAgB,cAAc,CAC7B,UAAU,EAAE,UAAU,EACtB,KAAK,EAAE,MAAM,EAAE,EACf,OAAO,EAAE,iBAAiB,EAC1B,QAAQ,EAAE,UAAU,CAAC,OAAO,gBAAgB,CAAC,EAC7C,WAAW,CAAC,EAAE,WAAW,GACvB,oBAAoB,GAAG,SAAS,CAqClC;AAED;;GAEG;AACH,wBAAsB,UAAU,CAC/B,UAAU,EAAE,UAAU,EACtB,IAAI,EAAE,MAAM,EAAE,EACd,OAAO,EAAE,iBAAiB,EAC1B,OAAO,EAAE,UAAU,CAAC,OAAO,gBAAgB,CAAC,EAC5C,WAAW,CAAC,EAAE,WAAW,GACvB,OAAO,CAAC,eAAe,CAAC,CAiD1B;AAoBD;;GAEG;AACH,wBAAgB,eAAe,CAAC,OAAO,EAAE,iBAAiB,GAAG,OAAO,CAMnE;AAED;;GAEG;AACH,wBAAgB,gBAAgB,CAC/B,UAAU,EAAE,UAAU,EACtB,IAAI,EAAE,MAAM,EAAE,EACd,OAAO,EAAE,iBAAiB,EAC1B,OAAO,EAAE,UAAU,CAAC,OAAO,gBAAgB,CAAC,EAC5C,WAAW,CAAC,EAAE,WAAW,GACvB,eAAe,CAOjB"}
+{"version":3,"file":"field-builder.d.ts","sourceRoot":"","sources":["../../../src/typeschema/core/field-builder.ts"],"names":[],"mappings":"AAEA;;;;GAIG;AAEH,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,oCAAoC,CAAC;AAC3E,OAAO,KAAK,EAAE,UAAU,EAAE,iBAAiB,EAAE,MAAM,wBAAwB,CAAC;AAC5E,OAAO,KAAK,EACX,WAAW,EACX,eAAe,EACf,oBAAoB,EACpB,MAAM,aAAa,CAAC;AAQrB;;GAEG;AACH,wBAAgB,mBAAmB,CAClC,UAAU,EAAE,UAAU,EACtB,IAAI,EAAE,MAAM,EAAE,EACd,QAAQ,EAAE,UAAU,CAAC,OAAO,gBAAgB,CAAC,GAC3C,iBAAiB,EAAE,CAkBrB;AAED;;GAEG;AACH,wBAAgB,qBAAqB,CACpC,SAAS,EAAE,iBAAiB,EAAE,GAC5B,iBAAiB,CAoDnB;AAED;;GAEG;AACH,wBAAgB,UAAU,CACzB,UAAU,EAAE,UAAU,EACtB,IAAI,EAAE,MAAM,EAAE,EACd,QAAQ,EAAE,UAAU,CAAC,OAAO,gBAAgB,CAAC,GAC3C,OAAO,CA4BT;AAED;;GAEG;AACH,wBAAgB,UAAU,CACzB,UAAU,EAAE,UAAU,EACtB,IAAI,EAAE,MAAM,EAAE,EACd,QAAQ,EAAE,UAAU,CAAC,OAAO,gBAAgB,CAAC,GAC3C,OAAO,CA4BT;AAED;;GAEG;AACH,wBAAsB,eAAe,CACpC,OAAO,EAAE,iBAAiB,EAC1B,OAAO,EAAE,UAAU,CAAC,OAAO,gBAAgB,CAAC,EAC5C,WAAW,CAAC,EAAE,WAAW,GACvB,OAAO,CAAC,oBAAoB,EAAE,GAAG,SAAS,CAAC,CAmB7C;AAED;;GAEG;AACH,wBAAgB,cAAc,CAC7B,UAAU,EAAE,UAAU,EACtB,KAAK,EAAE,MAAM,EAAE,EACf,OAAO,EAAE,iBAAiB,EAC1B,QAAQ,EAAE,UAAU,CAAC,OAAO,gBAAgB,CAAC,EAC7C,WAAW,CAAC,EAAE,WAAW,GACvB,oBAAoB,GAAG,SAAS,CAqClC;AAED;;GAEG;AACH,wBAAsB,UAAU,CAC/B,UAAU,EAAE,UAAU,EACtB,IAAI,EAAE,MAAM,EAAE,EACd,OAAO,EAAE,iBAAiB,EAC1B,OAAO,EAAE,UAAU,CAAC,OAAO,gBAAgB,CAAC,EAC5C,WAAW,CAAC,EAAE,WAAW,GACvB,OAAO,CAAC,eAAe,CAAC,CAiD1B;AAoBD;;GAEG;AACH,wBAAgB,eAAe,CAAC,OAAO,EAAE,iBAAiB,GAAG,OAAO,CAMnE;AAED;;GAEG;AACH,wBAAgB,gBAAgB,CAC/B,UAAU,EAAE,UAAU,EACtB,IAAI,EAAE,MAAM,EAAE,EACd,OAAO,EAAE,iBAAiB,EAC1B,OAAO,EAAE,UAAU,CAAC,OAAO,gBAAgB,CAAC,EAC5C,WAAW,CAAC,EAAE,WAAW,GACvB,eAAe,CAOjB"}