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

package/dist/typeschema/core/field-builder.js

@@ -0,0 +1,259 @@
+// @ts-nocheck
+import { buildEnum } from "./binding.js";
+import { buildBindingIdentifier, buildNestedIdentifier, buildSchemaIdentifier, } from "./identifier.js";
+/**
+ * Get the full element hierarchy for a given path
+ */
+export function getElementHierarchy(fhirSchema, path, _manager) {
+    const hierarchy = [];
+    // Get element at path from current schema
+    let element = fhirSchema.elements;
+    for (const key of path) {
+        element = element?.[key];
+        if (!element)
+            break;
+    }
+    if (element) {
+        hierarchy.push(element);
+    }
+    // For now, we only use the current schema's element
+    // TODO: Implement base schema traversal when we have proper schema loading
+    return hierarchy;
+}
+/**
+ * Merge element hierarchy into a snapshot
+ */
+export function mergeElementHierarchy(hierarchy) {
+    // Handle empty hierarchy
+    if (hierarchy.length === 0) {
+        return {};
+    }
+    // Start with the most specific (first) element
+    const snapshot = { ...hierarchy[0] };
+    // Merge properties from base elements (reverse order to apply from base to specific)
+    for (let i = hierarchy.length - 1; i >= 0; i--) {
+        const element = hierarchy[i];
+        // Properties that should be taken from the most specific element
+        const specificProps = [
+            "choices",
+            "short",
+            "index",
+            "elements",
+            "required",
+            "excluded",
+            "binding",
+            "refers",
+            "elementReference",
+            "mustSupport",
+            "slices",
+            "slicing",
+            "url",
+            "extensions",
+        ];
+        // Merge non-specific properties
+        for (const [key, value] of Object.entries(element)) {
+            if (!specificProps.includes(key) && value !== undefined) {
+                snapshot[key] = value;
+            }
+        }
+    }
+    // Override with specific properties from the first element
+    for (const prop of ["choices", "binding", "refers", "elementReference"]) {
+        // @ts-ignore
+        if (hierarchy[0] &&
+            hierarchy[0][prop] !== undefined) {
+            // @ts-ignore
+            snapshot[prop] = hierarchy[0][prop];
+        }
+    }
+    return snapshot;
+}
+/**
+ * Check if a field is required based on parent required arrays
+ */
+export function isRequired(fhirSchema, path, _manager) {
+    if (path.length === 0)
+        return false;
+    const fieldName = path[path.length - 1];
+    const parentPath = path.slice(0, -1);
+    // Navigate to parent element
+    let parentElement = fhirSchema;
+    for (const key of parentPath) {
+        parentElement = parentElement.elements?.[key];
+        if (!parentElement)
+            break;
+    }
+    // Check if field is in required array
+    if (parentElement?.required?.includes(fieldName)) {
+        return true;
+    }
+    // Also check at root level
+    if (parentPath.length === 0 &&
+        fieldName &&
+        fhirSchema.required?.includes(fieldName)) {
+        return true;
+    }
+    return false;
+}
+/**
+ * Check if a field is excluded
+ */
+export function isExcluded(fhirSchema, path, _manager) {
+    if (path.length === 0)
+        return false;
+    const fieldName = path[path.length - 1];
+    const parentPath = path.slice(0, -1);
+    // Navigate to parent element
+    let parentElement = fhirSchema;
+    for (const key of parentPath) {
+        parentElement = parentElement.elements?.[key];
+        if (!parentElement)
+            break;
+    }
+    // Check if field is in excluded array
+    if (parentElement?.excluded?.includes(fieldName)) {
+        return true;
+    }
+    // Also check at root level
+    if (parentPath.length === 0 &&
+        fieldName &&
+        fhirSchema.excluded?.includes(fieldName)) {
+        return true;
+    }
+    return false;
+}
+/**
+ * Build reference array from element refers
+ */
+export async function buildReferences(element, manager, packageInfo) {
+    if (!element.refers || element.refers.length === 0) {
+        return undefined;
+    }
+    const references = [];
+    for (const ref of element.refers) {
+        try {
+            const resource = await manager.resolve(ref);
+            if (resource) {
+                references.push(buildSchemaIdentifier(resource, packageInfo));
+            }
+        }
+        catch { }
+    }
+    return references;
+}
+/**
+ * Build field type identifier
+ */
+export function buildFieldType(fhirSchema, _path, element, _manager, packageInfo) {
+    // Handle element reference (for slicing)
+    if (element.elementReference) {
+        const refPath = element.elementReference
+            .filter((_, i) => i % 2 === 1) // Get odd indices (the actual path parts)
+            .map((p) => p)
+            .filter((p) => p !== "elements"); // Remove 'elements' which is just a container
+        // Only return nested identifier if we have a non-empty path
+        if (refPath.length > 0) {
+            return buildNestedIdentifier(fhirSchema, refPath, packageInfo);
+        }
+    }
+    // Handle normal type
+    if (element.type) {
+        const typeUrl = element.type.includes("/")
+            ? element.type
+            : `http://hl7.org/fhir/StructureDefinition/${element.type}`;
+        // Always create a type identifier, even if we can't resolve
+        const kind = element.type.match(/^[a-z]/)
+            ? "primitive-type"
+            : "complex-type";
+        const isStandardFhir = typeUrl.startsWith("http://hl7.org/fhir/");
+        return {
+            kind: kind,
+            package: isStandardFhir
+                ? "hl7.fhir.r4.core"
+                : packageInfo?.name || "undefined",
+            version: isStandardFhir ? "4.0.1" : packageInfo?.version || "undefined",
+            name: element.type,
+            url: typeUrl,
+        };
+    }
+    return undefined;
+}
+/**
+ * Build a TypeSchema field from a FHIRSchema element
+ */
+export async function buildField(fhirSchema, path, element, manager, packageInfo) {
+    const field = {
+        array: element.array || false,
+        required: isRequired(fhirSchema, path, manager),
+        excluded: isExcluded(fhirSchema, path, manager),
+    };
+    // Add type if present
+    const type = buildFieldType(fhirSchema, path, element, manager, packageInfo);
+    if (type) {
+        field.type = type;
+    }
+    // Add cardinality
+    if (element.min !== undefined)
+        field.min = element.min;
+    if (element.max !== undefined)
+        field.max = element.max;
+    // Add choices
+    // @ts-ignore
+    if (element.choices)
+        field.choices = element.choices;
+    // @ts-ignore
+    if (element.choiceOf)
+        field.choiceOf = element.choiceOf;
+    // Add binding if present
+    if (element.binding) {
+        field.binding = buildBindingIdentifier(fhirSchema, path, element.binding.bindingName, packageInfo);
+        // Add enum for required bindings on code types
+        if (element.binding.strength === "required" && element.type === "code") {
+            const enumValues = await buildEnum(element, manager);
+            if (enumValues && enumValues.length > 0) {
+                field.enum = enumValues;
+            }
+        }
+    }
+    // Add references
+    const references = await buildReferences(element, manager, packageInfo);
+    if (references) {
+        field.reference = references;
+    }
+    // Remove empty/default values
+    return removeEmptyValues(field);
+}
+/**
+ * Remove empty values from an object
+ */
+function removeEmptyValues(obj) {
+    const result = {};
+    for (const [key, value] of Object.entries(obj)) {
+        if (value !== undefined && value !== null) {
+            if (Array.isArray(value) && value.length === 0) {
+                continue;
+            }
+            result[key] = value;
+        }
+    }
+    return result;
+}
+/**
+ * Check if an element represents a nested type (BackboneElement)
+ */
+export function isNestedElement(element) {
+    return (element.type === "BackboneElement" ||
+        (element.elements && Object.keys(element.elements).length > 0) ||
+        false);
+}
+/**
+ * Build a field reference to a nested type
+ */
+export function buildNestedField(fhirSchema, path, element, manager, packageInfo) {
+    return {
+        type: buildNestedIdentifier(fhirSchema, path, packageInfo),
+        array: element.array || false,
+        required: isRequired(fhirSchema, path, manager),
+        excluded: isExcluded(fhirSchema, path, manager),
+    };
+}

package/dist/typeschema/core/identifier.js

@@ -0,0 +1,117 @@
+/**
+ * Identifier Building Utilities
+ *
+ * Functions for creating TypeSchema identifiers from FHIRSchema entities
+ */
+/**
+ * Drop version suffix from canonical URL (e.g., "http://example.com|1.0.0" -> "http://example.com")
+ */
+export function dropVersionFromUrl(url) {
+    if (!url)
+        return undefined;
+    return url.split("|")[0];
+}
+/**
+ * Determine the kind of schema based on FHIRSchema properties
+ */
+function determineKind(fhirSchema) {
+    // Check for constraint/profile
+    if (fhirSchema.derivation === "constraint") {
+        // Distinguish between profiles and other constraints
+        // Profiles typically constrain resources or complex types and have a base type
+        if (fhirSchema.base &&
+            (fhirSchema.type === "Resource" ||
+                fhirSchema.kind === "resource" ||
+                fhirSchema.kind === "complex-type")) {
+            return "profile";
+        }
+        return "profile";
+    }
+    // Use explicit kind if available
+    if (fhirSchema.kind) {
+        switch (fhirSchema.kind) {
+            case "primitive-type":
+                return "primitive-type";
+            case "complex-type":
+                return "complex-type";
+            case "resource":
+                return "resource";
+        }
+    }
+    // Default to resource
+    return "resource";
+}
+/**
+ * Build identifier for primitive-type, complex-type, resource, or constraint
+ */
+export function buildSchemaIdentifier(fhirSchema, packageInfo) {
+    const kind = determineKind(fhirSchema);
+    return {
+        kind,
+        package: packageInfo?.name || fhirSchema.package_name || "undefined",
+        version: packageInfo?.version || fhirSchema.package_version || "undefined",
+        name: fhirSchema.name,
+        url: fhirSchema.url,
+    };
+}
+/**
+ * Build nested type identifier for BackboneElements
+ */
+export function buildNestedIdentifier(fhirSchema, path, packageInfo) {
+    const nestedName = path.join(".");
+    return {
+        kind: "nested",
+        package: packageInfo?.name || fhirSchema.package_name || "undefined",
+        version: packageInfo?.version || fhirSchema.package_version || "undefined",
+        name: nestedName,
+        url: `${fhirSchema.url}#${nestedName}`,
+    };
+}
+/**
+ * Build value set identifier
+ */
+export function buildValueSetIdentifier(valueSetUrl, valueSet, packageInfo) {
+    const cleanUrl = dropVersionFromUrl(valueSetUrl) || valueSetUrl;
+    // Generate a meaningful name from the URL instead of using potentially hash-like IDs
+    let name = "unknown";
+    // First try to get the last segment of the URL path
+    const urlParts = cleanUrl.split("/");
+    const lastSegment = urlParts[urlParts.length - 1];
+    if (lastSegment && lastSegment.length > 0) {
+        // Convert kebab-case or snake_case to PascalCase for better readability
+        name = lastSegment
+            .split(/[-_]/)
+            .map((word) => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase())
+            .join("");
+    }
+    // Only fall back to valueSet.id if we couldn't extract a meaningful name from URL
+    // and the ID doesn't look like a hash (no long alphanumeric strings)
+    if (name === "unknown" &&
+        valueSet?.id &&
+        !/^[a-zA-Z0-9_-]{20,}$/.test(valueSet.id)) {
+        name = valueSet.id;
+    }
+    return {
+        kind: "value-set",
+        package: packageInfo?.name || valueSet?.package_name || "undefined",
+        version: packageInfo?.version || valueSet?.package_version || "undefined",
+        name,
+        url: cleanUrl,
+    };
+}
+/**
+ * Build binding identifier for an element with value set binding
+ */
+export function buildBindingIdentifier(fhirSchema, path, bindingName, packageInfo) {
+    const pathStr = path.join(".");
+    const name = bindingName || `${fhirSchema.name}.${pathStr}_binding`;
+    return {
+        kind: "binding",
+        package: packageInfo?.name || fhirSchema.package_name || "undefined",
+        version: packageInfo?.version || fhirSchema.package_version || "undefined",
+        name,
+        url: bindingName
+            ? `urn:fhir:binding:${name}`
+            : `${fhirSchema.url}#${pathStr}_binding`,
+    };
+}

package/dist/typeschema/core/nested-types.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";
 /**
  * Collect all nested elements from a FHIRSchema
  */

package/dist/typeschema/core/nested-types.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"nested-types.d.ts","sourceRoot":"","sources":["../../../src/typeschema/core/nested-types.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;AAIlB;;GAEG;AACH,wBAAgB,qBAAqB,CACpC,UAAU,EAAE,UAAU,EACtB,UAAU,EAAE,MAAM,EAAE,EACpB,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,iBAAiB,CAAC,GACzC,KAAK,CAAC,CAAC,MAAM,EAAE,EAAE,iBAAiB,CAAC,CAAC,CAkBtC;AAED;;GAEG;AACH,wBAAsB,uBAAuB,CAC5C,UAAU,EAAE,UAAU,EACtB,UAAU,EAAE,MAAM,EAAE,EACpB,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,iBAAiB,CAAC,EAC3C,OAAO,EAAE,UAAU,CAAC,OAAO,gBAAgB,CAAC,EAC5C,WAAW,CAAC,EAAE,WAAW,GACvB,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,eAAe,CAAC,CAAC,CA4B1C;AAED;;GAEG;AACH,wBAAsB,gBAAgB,CACrC,UAAU,EAAE,UAAU,EACtB,OAAO,EAAE,UAAU,CAAC,OAAO,gBAAgB,CAAC,EAC5C,WAAW,CAAC,EAAE,WAAW,GACvB,OAAO,CAAC,GAAG,EAAE,CAAC,CAgEhB;AAED;;GAEG;AACH,wBAAgB,yBAAyB,CACxC,WAAW,EAAE,oBAAoB,EAAE,GACjC,oBAAoB,EAAE,CAwBxB"}
+{"version":3,"file":"nested-types.d.ts","sourceRoot":"","sources":["../../../src/typeschema/core/nested-types.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,qBAAqB,CACpC,UAAU,EAAE,UAAU,EACtB,UAAU,EAAE,MAAM,EAAE,EACpB,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,iBAAiB,CAAC,GACzC,KAAK,CAAC,CAAC,MAAM,EAAE,EAAE,iBAAiB,CAAC,CAAC,CAkBtC;AAED;;GAEG;AACH,wBAAsB,uBAAuB,CAC5C,UAAU,EAAE,UAAU,EACtB,UAAU,EAAE,MAAM,EAAE,EACpB,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,iBAAiB,CAAC,EAC3C,OAAO,EAAE,UAAU,CAAC,OAAO,gBAAgB,CAAC,EAC5C,WAAW,CAAC,EAAE,WAAW,GACvB,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,eAAe,CAAC,CAAC,CA4B1C;AAED;;GAEG;AACH,wBAAsB,gBAAgB,CACrC,UAAU,EAAE,UAAU,EACtB,OAAO,EAAE,UAAU,CAAC,OAAO,gBAAgB,CAAC,EAC5C,WAAW,CAAC,EAAE,WAAW,GACvB,OAAO,CAAC,GAAG,EAAE,CAAC,CAgEhB;AAED;;GAEG;AACH,wBAAgB,yBAAyB,CACxC,WAAW,EAAE,oBAAoB,EAAE,GACjC,oBAAoB,EAAE,CAwBxB"}

package/dist/typeschema/core/nested-types.js

@@ -0,0 +1,111 @@
+// @ts-nocheck
+import { buildField, buildNestedField, isNestedElement, } from "./field-builder.js";
+import { buildNestedIdentifier } from "./identifier.js";
+/**
+ * Collect all nested elements from a FHIRSchema
+ */
+export function collectNestedElements(fhirSchema, parentPath, elements) {
+    const nested = [];
+    for (const [key, element] of Object.entries(elements)) {
+        const path = [...parentPath, key];
+        // Add this element if it's nested (BackboneElement or has elements)
+        if (isNestedElement(element)) {
+            nested.push([path, element]);
+        }
+        // Recursively collect from child elements
+        if (element.elements) {
+            nested.push(...collectNestedElements(fhirSchema, path, element.elements));
+        }
+    }
+    return nested;
+}
+/**
+ * Transform elements into fields for a nested type
+ */
+export async function transformNestedElements(fhirSchema, parentPath, elements, manager, packageInfo) {
+    const fields = {};
+    for (const [key, element] of Object.entries(elements)) {
+        const path = [...parentPath, key];
+        if (isNestedElement(element)) {
+            // Reference to another nested type
+            fields[key] = buildNestedField(fhirSchema, path, element, manager, packageInfo);
+        }
+        else {
+            // Regular field
+            fields[key] = await buildField(fhirSchema, path, element, manager, packageInfo);
+        }
+    }
+    return fields;
+}
+/**
+ * Build TypeSchema for all nested types in a FHIRSchema
+ */
+export async function buildNestedTypes(fhirSchema, manager, packageInfo) {
+    if (!fhirSchema.elements)
+        return [];
+    const nestedTypes = [];
+    const nestedElements = collectNestedElements(fhirSchema, [], fhirSchema.elements);
+    // Filter to only include elements that have sub-elements (actual nested types)
+    const actualNested = nestedElements.filter(([_, element]) => element.elements && Object.keys(element.elements).length > 0);
+    for (const [path, element] of actualNested) {
+        const identifier = buildNestedIdentifier(fhirSchema, path, packageInfo);
+        // Base is usually BackboneElement - ensure all nested types have a base
+        // biome-ignore lint/suspicious/noImplicitAnyLet: <explanation>
+        let base;
+        if (element.type === "BackboneElement" || !element.type) {
+            // For BackboneElement or undefined type, always use BackboneElement as base
+            base = {
+                kind: "complex-type",
+                package: packageInfo?.name || "hl7.fhir.r4.core",
+                version: packageInfo?.version || "4.0.1",
+                name: "BackboneElement",
+                url: "http://hl7.org/fhir/StructureDefinition/BackboneElement",
+            };
+        }
+        else {
+            // Use the specified type as base
+            base = {
+                kind: "complex-type",
+                package: packageInfo?.name || "hl7.fhir.r4.core",
+                version: packageInfo?.version || "4.0.1",
+                name: element.type,
+                url: `http://hl7.org/fhir/StructureDefinition/${element.type}`,
+            };
+        }
+        // Transform sub-elements into fields
+        const fields = await transformNestedElements(fhirSchema, path, element.elements, manager, packageInfo);
+        const nestedType = {
+            identifier,
+            base, // Always include base
+            fields,
+        };
+        nestedTypes.push(nestedType);
+    }
+    // Sort by URL for consistent output
+    nestedTypes.sort((a, b) => a.identifier.url.localeCompare(b.identifier.url));
+    return nestedTypes;
+}
+/**
+ * Extract dependencies from nested types
+ */
+export function extractNestedDependencies(nestedTypes) {
+    const deps = [];
+    for (const nested of nestedTypes) {
+        // Add the nested type itself as a dependency
+        deps.push(nested.identifier);
+        // Add base dependency
+        if (nested.base) {
+            deps.push(nested.base);
+        }
+        // Add field type dependencies
+        for (const field of Object.values(nested.fields)) {
+            if ("type" in field && field.type) {
+                deps.push(field.type);
+            }
+            if ("binding" in field && field.binding) {
+                deps.push(field.binding);
+            }
+        }
+    }
+    return deps;
+}

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

@@ -5,8 +5,8 @@
  */
 import type { CanonicalManager } from "@atomic-ehr/fhir-canonical-manager";
 import type { FHIRSchema, FHIRSchemaElement } from "@atomic-ehr/fhirschema";
-import type { TypeSchema, TypeSchemaField } from "../type-schema.types";
-import type { PackageInfo } from "../types";
+import type { TypeSchema, TypeSchemaField } from "../type-schema.types.js";
+import type { PackageInfo } from "../types.js";
 /**
  * Transform elements into fields
  */

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

@@ -1 +1 @@
-{"version":3,"file":"transformer.d.ts","sourceRoot":"","sources":["../../../src/typeschema/core/transformer.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;AAE5E,OAAO,KAAK,EACX,UAAU,EACV,eAAe,EAGf,MAAM,sBAAsB,CAAC;AAC9B,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,UAAU,CAAC;AAY5C;;GAEG;AACH,wBAAsB,iBAAiB,CACtC,UAAU,EAAE,UAAU,EACtB,UAAU,EAAE,MAAM,EAAE,EACpB,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,iBAAiB,CAAC,EAC3C,OAAO,EAAE,UAAU,CAAC,OAAO,gBAAgB,CAAC,EAC5C,WAAW,CAAC,EAAE,WAAW,GACvB,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,eAAe,CAAC,CAAC,CAiC1C;AAqOD;;;GAGG;AACH,wBAAsB,mBAAmB,CACxC,UAAU,EAAE,UAAU,EACtB,OAAO,EAAE,UAAU,CAAC,OAAO,gBAAgB,CAAC,EAC5C,WAAW,CAAC,EAAE,WAAW,GACvB,OAAO,CAAC,UAAU,EAAE,CAAC,CAmMvB;AAED;;GAEG;AACH,wBAAsB,oBAAoB,CACzC,WAAW,EAAE,UAAU,EAAE,EACzB,OAAO,EAAE,UAAU,CAAC,OAAO,gBAAgB,CAAC,EAC5C,WAAW,CAAC,EAAE,WAAW,GACvB,OAAO,CAAC,UAAU,EAAE,CAAC,CASvB"}
+{"version":3,"file":"transformer.d.ts","sourceRoot":"","sources":["../../../src/typeschema/core/transformer.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;AAE5E,OAAO,KAAK,EACX,UAAU,EACV,eAAe,EAGf,MAAM,yBAAyB,CAAC;AACjC,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAY/C;;GAEG;AACH,wBAAsB,iBAAiB,CACtC,UAAU,EAAE,UAAU,EACtB,UAAU,EAAE,MAAM,EAAE,EACpB,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,iBAAiB,CAAC,EAC3C,OAAO,EAAE,UAAU,CAAC,OAAO,gBAAgB,CAAC,EAC5C,WAAW,CAAC,EAAE,WAAW,GACvB,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,eAAe,CAAC,CAAC,CAiC1C;AAqOD;;;GAGG;AACH,wBAAsB,mBAAmB,CACxC,UAAU,EAAE,UAAU,EACtB,OAAO,EAAE,UAAU,CAAC,OAAO,gBAAgB,CAAC,EAC5C,WAAW,CAAC,EAAE,WAAW,GACvB,OAAO,CAAC,UAAU,EAAE,CAAC,CAmMvB;AAED;;GAEG;AACH,wBAAsB,oBAAoB,CACzC,WAAW,EAAE,UAAU,EAAE,EACzB,OAAO,EAAE,UAAU,CAAC,OAAO,gBAAgB,CAAC,EAC5C,WAAW,CAAC,EAAE,WAAW,GACvB,OAAO,CAAC,UAAU,EAAE,CAAC,CASvB"}