@intentius/chant-lexicon-gitlab 0.124.31 → 0.124.33

package/dist/codegen/parse.js

@@ -0,0 +1,539 @@
+/**
+ * GitLab CI JSON Schema parser.
+ *
+ * Parses the single CI schema into multiple entity results — one per CI
+ * entity (Job, Pipeline, Artifacts, Cache, etc.). The schema is a single
+ * document unlike CloudFormation which has one schema per resource type.
+ */
+import { extractConstraints as coreExtractConstraints, constraintsIsEmpty as coreConstraintsIsEmpty, primaryType, } from "@intentius/chant/codegen/json-schema";
+export { coreConstraintsIsEmpty as constraintsIsEmpty };
+// ── Entity extraction mapping ──────────────────────────────────────
+/**
+ * Top-level entities (resources) to extract from the schema.
+ */
+const RESOURCE_ENTITIES = [
+    {
+        typeName: "GitLab::CI::Job",
+        source: "#/definitions/job_template",
+        description: "A GitLab CI/CD job definition",
+    },
+    {
+        typeName: "GitLab::CI::Default",
+        source: "root:default",
+        description: "Default settings inherited by all jobs",
+    },
+    {
+        typeName: "GitLab::CI::Workflow",
+        source: "root:workflow",
+        description: "Pipeline-level workflow configuration",
+    },
+    {
+        // The top-level keys that are neither a job, `default` nor `workflow`
+        // (#3669). The serializer writes them first, so an explicit `stages`
+        // list can name a stage no declared job uses (one an included file's
+        // jobs run in) and set the order.
+        typeName: "GitLab::CI::Pipeline",
+        source: "root",
+        description: "Top-level pipeline keys: include, stages and variables",
+        pick: ["include", "stages", "variables"],
+    },
+];
+/**
+ * Property types (nested) to extract from definitions.
+ */
+const PROPERTY_ENTITIES = [
+    { typeName: "GitLab::CI::Artifacts", source: "#/definitions/artifacts", description: "Job artifact configuration" },
+    { typeName: "GitLab::CI::Cache", source: "#/definitions/cache_item", description: "Cache configuration" },
+    { typeName: "GitLab::CI::Image", source: "#/definitions/image", description: "Docker image for a job" },
+    { typeName: "GitLab::CI::Service", source: "#/definitions/services:item", description: "Docker service container for a job" },
+    { typeName: "GitLab::CI::Rule", source: "#/definitions/rules:item", description: "Conditional rule for job execution" },
+    { typeName: "GitLab::CI::Retry", source: "#/definitions/retry", description: "Job retry configuration" },
+    { typeName: "GitLab::CI::AllowFailure", source: "#/definitions/allow_failure", description: "Allow failure configuration" },
+    { typeName: "GitLab::CI::Parallel", source: "#/definitions/parallel", description: "Parallel job configuration" },
+    { typeName: "GitLab::CI::Include", source: "#/definitions/include_item", description: "Include configuration item" },
+    { typeName: "GitLab::CI::Release", source: "job_template:release", description: "Release configuration" },
+    { typeName: "GitLab::CI::Environment", source: "job_template:environment", description: "Deployment environment" },
+    { typeName: "GitLab::CI::Trigger", source: "job_template:trigger", description: "Trigger downstream pipeline" },
+    { typeName: "GitLab::CI::AutoCancel", source: "#/definitions/workflowAutoCancel", description: "Auto-cancel configuration" },
+    { typeName: "GitLab::CI::WorkflowRule", source: "root:workflow:rules:item", description: "Workflow rule with restricted when values" },
+    { typeName: "GitLab::CI::Need", source: "job_template:needs:item", description: "Job dependency specification" },
+    { typeName: "GitLab::CI::Inherit", source: "job_template:inherit", description: "Control default/variable inheritance" },
+];
+// ── Parser ─────────────────────────────────────────────────────────
+/**
+ * Parse the GitLab CI JSON Schema into multiple entity results.
+ * Returns one result per CI entity with its properties and nested types.
+ */
+export function parseCISchema(data) {
+    const schema = JSON.parse(typeof data === "string" ? data : data.toString("utf-8"));
+    const results = [];
+    // Extract resource entities
+    for (const entity of RESOURCE_ENTITIES) {
+        const result = extractResourceEntity(schema, entity);
+        if (result)
+            results.push(result);
+    }
+    // Extract property entities as pseudo-resources (each gets its own ParseResult)
+    for (const entity of PROPERTY_ENTITIES) {
+        const result = extractPropertyEntity(schema, entity);
+        if (result) {
+            result.isProperty = true;
+            results.push(result);
+        }
+    }
+    return results;
+}
+/**
+ * Extract a resource entity from the schema.
+ */
+function extractResourceEntity(schema, entity) {
+    const def = resolveSource(schema, entity.source);
+    if (!def)
+        return null;
+    // Find the object variant if it's a oneOf/anyOf
+    const found = findObjectVariant(def, schema);
+    if (!found?.properties)
+        return null;
+    const pick = entity.pick;
+    const objectDef = pick
+        ? { ...found, properties: Object.fromEntries(Object.entries(found.properties).filter(([k]) => pick.includes(k))), required: undefined }
+        : found;
+    if (!objectDef.properties)
+        return null;
+    const requiredSet = new Set(objectDef.required ?? []);
+    const properties = parseProperties(objectDef.properties, requiredSet, schema);
+    const shortName = gitlabShortName(entity.typeName);
+    // Apply property type overrides for known entity references
+    const overrides = RESOURCE_PROPERTY_OVERRIDES[entity.typeName];
+    if (overrides) {
+        for (const prop of properties) {
+            if (overrides[prop.name]) {
+                prop.tsType = overrides[prop.name];
+            }
+        }
+    }
+    const comment = COMMENT_PROPERTIES[entity.typeName];
+    if (comment)
+        properties.push({ name: "comment", tsType: "string", required: false, description: comment, constraints: {} });
+    // Extract nested property types from definition properties
+    const { propertyTypes, enums } = extractNestedTypes(objectDef, shortName, schema);
+    const deprecatedProperties = mineDeprecatedProperties(properties);
+    return {
+        resource: {
+            typeName: entity.typeName,
+            description: entity.description ?? objectDef.description,
+            properties,
+            attributes: [], // CI entities have no read-only attributes
+            deprecatedProperties,
+        },
+        propertyTypes,
+        enums,
+    };
+}
+/**
+ * Extract a property entity — represented as a ParseResult with the entity
+ * as the "resource" (the pipeline treats all parsed results uniformly).
+ */
+function extractPropertyEntity(schema, entity) {
+    const def = resolveSource(schema, entity.source);
+    if (!def)
+        return null;
+    const objectDef = findObjectVariant(def, schema);
+    if (!objectDef?.properties) {
+        // Some entities like Parallel might be simple types
+        // Create a minimal entry with no properties
+        return {
+            resource: {
+                typeName: entity.typeName,
+                description: entity.description ?? def.description,
+                properties: [],
+                attributes: [],
+                deprecatedProperties: [],
+            },
+            propertyTypes: [],
+            enums: [],
+        };
+    }
+    const requiredSet = new Set(objectDef.required ?? []);
+    const properties = parseProperties(objectDef.properties, requiredSet, schema);
+    const shortName = gitlabShortName(entity.typeName);
+    const { propertyTypes, enums } = extractNestedTypes(objectDef, shortName, schema);
+    const deprecatedProperties = mineDeprecatedProperties(properties);
+    return {
+        resource: {
+            typeName: entity.typeName,
+            description: entity.description ?? objectDef.description,
+            properties,
+            attributes: [],
+            deprecatedProperties,
+        },
+        propertyTypes,
+        enums,
+    };
+}
+/**
+ * Resources that carry a `comment`: not a GitLab key, but `#` lines the
+ * serializer writes above the entry (#3669, as #3667 for github).
+ */
+const COMMENT_PROPERTIES = {
+    "GitLab::CI::Pipeline": "YAML comment lines written at the top of the file. Not a GitLab key; each line of the string becomes a `#` line",
+    "GitLab::CI::Job": "YAML comment lines written above the job's key. Not a GitLab key; each line of the string becomes a `#` line",
+};
+// ── Helpers ────────────────────────────────────────────────────────
+/**
+ * Resolve a source path to a schema definition.
+ */
+function resolveSource(schema, source) {
+    if (source === "root")
+        return { properties: schema.properties };
+    if (source.startsWith("#/definitions/")) {
+        // Array item extraction: "#/definitions/foo:item" → foo.items object variant
+        if (source.includes(":item")) {
+            const defName = source.slice("#/definitions/".length).replace(":item", "");
+            const arrayDef = schema.definitions?.[defName];
+            if (!arrayDef?.items)
+                return null;
+            return findObjectVariant(arrayDef.items, schema);
+        }
+        const defName = source.slice("#/definitions/".length);
+        return schema.definitions?.[defName] ?? null;
+    }
+    // Multi-segment path under root: root:prop:subprop:...:item
+    if (source.startsWith("root:")) {
+        const segments = source.slice("root:".length).split(":");
+        let current = { properties: schema.properties };
+        for (const seg of segments) {
+            if (!current)
+                return null;
+            if (seg === "item") {
+                if (!current.items)
+                    return null;
+                return findObjectVariant(current.items, schema);
+            }
+            if (!current.properties)
+                return null;
+            const prop = current.properties[seg];
+            if (!prop)
+                return null;
+            current = prop.$ref ? resolveRef(prop.$ref, schema) : prop;
+        }
+        return current;
+    }
+    // Multi-segment path under job_template: job_template:prop:...:item
+    if (source.startsWith("job_template:")) {
+        const segments = source.slice("job_template:".length).split(":");
+        let current = schema.definitions?.job_template ?? null;
+        if (!current)
+            return null;
+        for (const seg of segments) {
+            if (!current)
+                return null;
+            if (seg === "item") {
+                if (!current.items)
+                    return null;
+                return findObjectVariant(current.items, schema);
+            }
+            if (!current.properties)
+                return null;
+            const prop = current.properties[seg];
+            if (!prop)
+                return null;
+            current = prop.$ref ? resolveRef(prop.$ref, schema) : prop;
+        }
+        return current;
+    }
+    return null;
+}
+/**
+ * Resolve a $ref string to a schema definition.
+ */
+function resolveRef(ref, schema) {
+    const prefix = "#/definitions/";
+    if (!ref.startsWith(prefix))
+        return null;
+    const defName = ref.slice(prefix.length);
+    return schema.definitions?.[defName] ?? null;
+}
+/**
+ * Find the object variant from a oneOf/anyOf union, or return the
+ * definition itself if it already has properties.
+ *
+ * When multiple object variants exist, merges their properties:
+ * - Picks the variant with the most properties as the base
+ * - Adds unique properties from other variants
+ * - Union-merges overlapping property types (e.g. exit_codes: integer | integer[])
+ * - Required = intersection of all variants' required sets
+ */
+function findObjectVariant(def, schema) {
+    if (def.properties)
+        return def;
+    const variants = def.oneOf ?? def.anyOf;
+    if (!variants)
+        return null;
+    // Collect all object variants, resolving $refs
+    const objectVariants = [];
+    for (const v of variants) {
+        let resolved = v;
+        if (v.$ref && schema) {
+            const r = resolveRef(v.$ref, schema);
+            if (r)
+                resolved = r;
+            else
+                continue;
+        }
+        else if (v.$ref) {
+            continue;
+        }
+        if (resolved.properties) {
+            objectVariants.push(resolved);
+        }
+    }
+    if (objectVariants.length === 0)
+        return null;
+    if (objectVariants.length === 1)
+        return objectVariants[0];
+    // Find the variant with the most properties as the base
+    let best = objectVariants[0];
+    let bestCount = Object.keys(best.properties).length;
+    for (let i = 1; i < objectVariants.length; i++) {
+        const count = Object.keys(objectVariants[i].properties).length;
+        if (count > bestCount) {
+            best = objectVariants[i];
+            bestCount = count;
+        }
+    }
+    // Merge properties from other object variants into the base
+    const mergedProperties = { ...best.properties };
+    const allRequiredSets = objectVariants.map((v) => new Set(v.required ?? []));
+    for (const variant of objectVariants) {
+        if (variant === best)
+            continue;
+        for (const [propName, propDef] of Object.entries(variant.properties)) {
+            if (propName in mergedProperties) {
+                // Property exists in base — if types differ, create a merged oneOf
+                const existing = mergedProperties[propName];
+                if (JSON.stringify(existing) !== JSON.stringify(propDef)) {
+                    mergedProperties[propName] = {
+                        oneOf: [existing, propDef],
+                        description: existing.description ?? propDef.description,
+                    };
+                }
+            }
+            else {
+                // New property from another variant
+                mergedProperties[propName] = propDef;
+            }
+        }
+    }
+    // Required = intersection across all object variants
+    const requiredIntersection = [...allRequiredSets[0]].filter((r) => allRequiredSets.every((s) => s.has(r)));
+    return {
+        ...best,
+        properties: mergedProperties,
+        required: requiredIntersection.length > 0 ? requiredIntersection : undefined,
+    };
+}
+/**
+ * Parse properties from a schema definition into ParsedProperty[].
+ */
+function parseProperties(properties, requiredSet, schema) {
+    const result = [];
+    for (const [name, prop] of Object.entries(properties)) {
+        // Skip internal/hidden properties
+        if (name === "!reference")
+            continue;
+        const tsType = resolvePropertyType(prop, schema);
+        result.push({
+            name,
+            tsType,
+            required: requiredSet.has(name),
+            description: prop.description,
+            enum: prop.enum,
+            constraints: coreExtractConstraints(prop),
+        });
+    }
+    return result;
+}
+/**
+ * Resolve a schema property to its TypeScript type string.
+ */
+function resolvePropertyType(prop, schema) {
+    if (!prop)
+        return "any";
+    // Handle $ref
+    if (prop.$ref) {
+        const ref = prop.$ref;
+        const prefix = "#/definitions/";
+        if (ref.startsWith(prefix)) {
+            const defName = ref.slice(prefix.length);
+            const def = schema.definitions?.[defName];
+            if (def) {
+                // Check for known entity types
+                const entityType = definitionToTsType(defName);
+                if (entityType)
+                    return entityType;
+                // Enum
+                if (def.enum && def.enum.length > 0 && !def.properties) {
+                    return def.enum.map((v) => JSON.stringify(v)).join(" | ");
+                }
+                // Primitive type
+                if (def.type && !def.properties) {
+                    return jsonTypeToTs(primaryType(def.type));
+                }
+                // Object with properties
+                if (def.properties)
+                    return "Record<string, any>";
+            }
+        }
+        return "any";
+    }
+    // Inline enum
+    if (prop.enum && prop.enum.length > 0) {
+        return prop.enum.map((v) => JSON.stringify(v)).join(" | ");
+    }
+    // Handle oneOf/anyOf
+    if (prop.oneOf || prop.anyOf) {
+        const variants = prop.oneOf ?? prop.anyOf ?? [];
+        const types = new Set();
+        for (const v of variants) {
+            types.add(resolvePropertyType(v, schema));
+        }
+        // Simplify if all variants resolve to the same type
+        const uniqueTypes = [...types].filter((t) => t !== "any");
+        if (uniqueTypes.length === 0)
+            return "any";
+        if (uniqueTypes.length === 1)
+            return uniqueTypes[0];
+        return uniqueTypes.join(" | ");
+    }
+    const pt = primaryType(prop.type);
+    switch (pt) {
+        case "string":
+            return "string";
+        case "integer":
+        case "number":
+            return "number";
+        case "boolean":
+            return "boolean";
+        case "array":
+            if (prop.items) {
+                const itemType = resolvePropertyType(prop.items, schema);
+                // Wrap union types in parens so [] applies to the whole union
+                if (itemType.includes(" | ")) {
+                    return `(${itemType})[]`;
+                }
+                return `${itemType}[]`;
+            }
+            return "any[]";
+        case "object":
+            return "Record<string, any>";
+        default:
+            return "any";
+    }
+}
+/**
+ * Property type overrides for resource entities.
+ * Maps entity typeName → property name → desired TS type.
+ * Applied after parseProperties to replace generic types with entity references.
+ */
+const RESOURCE_PROPERTY_OVERRIDES = {
+    "GitLab::CI::Job": {
+        environment: "Environment | string",
+        trigger: "Trigger | string",
+        release: "Release",
+        // GitLab takes the plain forms too: `image: node:22`, `needs: [build]`.
+        image: "Image | string",
+        needs: "(Need | string)[]",
+        inherit: "Inherit",
+    },
+    "GitLab::CI::Default": {
+        image: "Image | string",
+    },
+    "GitLab::CI::Pipeline": {
+        include: "Include | string | (Include | string)[]",
+        stages: "string[]",
+    },
+    "GitLab::CI::Workflow": {
+        rules: "WorkflowRule[]",
+    },
+};
+/**
+ * Map well-known definition names to their TypeScript entity types.
+ */
+function definitionToTsType(defName) {
+    const map = {
+        image: "Image",
+        services: "Service[]",
+        artifacts: "Artifacts",
+        cache: "Cache | Cache[]",
+        cache_item: "Cache",
+        rules: "Rule[]",
+        retry: "Retry | number",
+        allow_failure: "AllowFailure | boolean",
+        parallel: "Parallel | number",
+        include_item: "Include",
+        before_script: "string | string[]",
+        after_script: "string | string[]",
+        script: "string | string[]",
+        optional_script: "string | string[]",
+        globalVariables: "Record<string, any>",
+        jobVariables: "Record<string, any>",
+        rulesVariables: "Record<string, any>",
+        when: '"on_success" | "on_failure" | "always" | "never" | "manual" | "delayed"',
+        workflowAutoCancel: "AutoCancel",
+        id_tokens: "Record<string, { aud: string | string[] }>",
+        secrets: "Record<string, any>",
+        timeout: "string",
+        start_in: "string",
+    };
+    return map[defName] ?? null;
+}
+function jsonTypeToTs(type) {
+    switch (type) {
+        case "string": return "string";
+        case "integer":
+        case "number": return "number";
+        case "boolean": return "boolean";
+        case "array": return "any[]";
+        case "object": return "Record<string, any>";
+        default: return "any";
+    }
+}
+/**
+ * Extract nested property types and enums from a definition.
+ * For now, we keep this minimal — the main types are extracted as
+ * top-level entities via PROPERTY_ENTITIES.
+ */
+function extractNestedTypes(_def, _shortName, _schema) {
+    // GitLab CI entities don't have deeply nested property types like CFN.
+    // The main nested types (Artifacts, Cache, etc.) are extracted as
+    // top-level property entities instead.
+    return { propertyTypes: [], enums: [] };
+}
+const DEPRECATION_RE = /\bDeprecated\b|\bdeprecated\b|\blegacy\b|no longer (available|recommended|used|supported)|is not recommended/i;
+/**
+ * Mine property descriptions for deprecation signals.
+ */
+function mineDeprecatedProperties(properties) {
+    const deprecated = [];
+    for (const prop of properties) {
+        if (prop.description && DEPRECATION_RE.test(prop.description)) {
+            deprecated.push(prop.name);
+        }
+    }
+    return deprecated;
+}
+/**
+ * Extract short name: "GitLab::CI::Job" → "Job"
+ */
+export function gitlabShortName(typeName) {
+    const parts = typeName.split("::");
+    return parts[parts.length - 1];
+}
+/**
+ * Extract service name: "GitLab::CI::Job" → "CI"
+ */
+export function gitlabServiceName(typeName) {
+    const parts = typeName.split("::");
+    return parts.length >= 2 ? parts[1] : "CI";
+}

package/dist/codegen/patches.js

@@ -0,0 +1,84 @@
+/**
+ * Schema augmentation patches for GitLab CI JSON Schema.
+ *
+ * The official GitLab CI schema sometimes has gaps, missing properties,
+ * or incorrect types. Patches are applied after fetch but before parse
+ * to fix these issues.
+ */
+/**
+ * Registry of known schema patches.
+ */
+export const schemaPatches = [
+    {
+        description: "Add 'pages' property type to job_template if missing",
+        path: "definitions.job_template",
+        apply(def) {
+            const props = def.properties;
+            if (props && !props.pages) {
+                props.pages = {
+                    description: "GitLab Pages configuration for publishing static sites.",
+                    oneOf: [
+                        { type: "object", properties: { publish: { type: "string" } } },
+                        { type: "boolean" },
+                    ],
+                };
+            }
+        },
+    },
+    {
+        description: "Add 'manual_confirmation' property to job_template if missing",
+        path: "definitions.job_template",
+        apply(def) {
+            const props = def.properties;
+            if (props && !props.manual_confirmation) {
+                props.manual_confirmation = {
+                    type: "string",
+                    description: "Confirmation message displayed when a manual job is triggered.",
+                };
+            }
+        },
+    },
+    {
+        description: "Add 'inputs' property to job_template if missing",
+        path: "definitions.job_template",
+        apply(def) {
+            const props = def.properties;
+            if (props && !props.inputs) {
+                props.inputs = {
+                    type: "object",
+                    description: "Input parameters for CI/CD component jobs.",
+                    additionalProperties: true,
+                };
+            }
+        },
+    },
+];
+/**
+ * Apply all registered patches to a parsed schema.
+ * Modifies the schema in place.
+ */
+export function applyPatches(schema) {
+    const applied = [];
+    const skipped = [];
+    for (const patch of schemaPatches) {
+        const segments = patch.path.split(".");
+        let target = schema;
+        for (const segment of segments) {
+            if (target && typeof target === "object" && segment in target) {
+                target = target[segment];
+            }
+            else {
+                target = undefined;
+                break;
+            }
+        }
+        if (target) {
+            patch.apply(target);
+            applied.push(patch.description);
+        }
+        else {
+            skipped.push(`${patch.description} (path "${patch.path}" not found)`);
+        }
+    }
+    return { applied, skipped };
+}

package/dist/codegen/typecheck.js

@@ -0,0 +1,4 @@
+/**
+ * Re-export from core — typecheck is lexicon-agnostic.
+ */
+export { typecheckDTS } from "@intentius/chant/codegen/typecheck";

package/dist/components/ci-jobs.js

@@ -0,0 +1,16 @@
+/**
+ * The GitLab CI pieces the three generators share (#3765): the Op pipeline
+ * (`./generate-op-pipeline.ts`), the Op waves pipeline
+ * (`./generate-op-waves-pipeline.ts`) and the component pipeline
+ * (`./generate-pipeline.ts`). The `rules:` expressions, `id_tokens:`, setup
+ * and environment checks are core's, in `@intentius/chant/ci-jobs`.
+ */
+import { emitYAMLEntry } from "@intentius/chant/yaml";
+/**
+ * A `.gitlab-ci.yml` document: the comment header, when there is one, then
+ * each top-level entry in the order given, a blank line between each.
+ */
+export function emitGitlabFile(entries, header = []) {
+    const body = entries.map(([key, value]) => emitYAMLEntry(key, value)).join("\n\n") + "\n";
+    return header.length > 0 ? header.join("\n") + "\n\n" + body : body;
+}

package/dist/components/generate-op-pipeline.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"generate-op-pipeline.d.ts","sourceRoot":"","sources":["../../src/components/generate-op-pipeline.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyGG;AAeH,OAAO,KAAK,EACV,wBAAwB,IAAI,uBAAuB,EAInD,gBAAgB,IAAI,sBAAsB,EAE1C,eAAe,EAChB,MAAM,0BAA0B,CAAC;AAIlC,YAAY,EAAE,uBAAuB,EAAE,sBAAsB,EAAE,CAAC;AAqHhE;;;;GAIG;AACH,wBAAgB,wBAAwB,CACtC,GAAG,EAAE,eAAe,EAAE,EACtB,OAAO,GAAE,uBAA4B,GACpC,sBAAsB,CAsGxB"}
+{"version":3,"file":"generate-op-pipeline.d.ts","sourceRoot":"","sources":["../../src/components/generate-op-pipeline.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyGG;AAeH,OAAO,KAAK,EACV,wBAAwB,IAAI,uBAAuB,EAInD,gBAAgB,IAAI,sBAAsB,EAE1C,eAAe,EAChB,MAAM,0BAA0B,CAAC;AAIlC,YAAY,EAAE,uBAAuB,EAAE,sBAAsB,EAAE,CAAC;AA4HhE;;;;GAIG;AACH,wBAAgB,wBAAwB,CACtC,GAAG,EAAE,eAAe,EAAE,EACtB,OAAO,GAAE,uBAA4B,GACpC,sBAAsB,CAsGxB"}