@goast/core 0.4.0-beta3 → 0.4.0

package/esm/src/transform/helpers.test.js

@@ -0,0 +1,265 @@
+import "../../_dnt.test_polyfills.js";
+import { expect, fn } from '../../deps/jsr.io/@std/expect/1.0.5/mod.js';
+import { describe, test } from '../../deps/jsr.io/@std/testing/1.0.3/bdd.js';
+import { determineEndpointName, determineSchemaAccessibility, determineSchemaKind, determineSchemaName, getCustomFields, IdGenerator, transformAdditionalProperties, transformSchemaProperties, } from './helpers.js';
+describe('determineSchemaKind', () => {
+    const ctx = { config: { unknownTypeBehavior: 'keep-unknown' } };
+    test('returns "oneOf" if schema has "oneOf" property', () => {
+        const schema = { oneOf: [{}] };
+        expect(determineSchemaKind(ctx, schema)).toBe('oneOf');
+    });
+    test('returns "combined" if schema has "allOf" or "anyOf" property', () => {
+        const schema = { allOf: [{}], anyOf: [{}] };
+        expect(determineSchemaKind(ctx, schema)).toBe('combined');
+    });
+    test('returns "multi-type" if schema has "type" property as an array', () => {
+        const schema = { type: ['string', 'number'] };
+        expect(determineSchemaKind(ctx, schema)).toBe('multi-type');
+    });
+    test('returns the value of "type" property if it is a string', () => {
+        const schema = { type: 'string' };
+        expect(determineSchemaKind(ctx, schema)).toBe('string');
+    });
+    test('returns "unknown" if schema has no recognizable properties', () => {
+        const schema = {};
+        expect(determineSchemaKind(ctx, schema)).toBe('unknown');
+    });
+});
+describe('determineSchemaName', () => {
+    test('returns the schema title if it exists', () => {
+        const schema = {
+            title: 'TestSchema',
+            $src: { file: 'my-api.yml', path: '/test/schema', document: {}, originalComponent: {} },
+        };
+        expect(determineSchemaName(schema, 'TestId')).toEqual({
+            name: 'TestSchema',
+            isGenerated: false,
+        });
+    });
+    test("returns the json schema file name if the schema title doesn't exist", () => {
+        const schema = {
+            $src: { path: '/', file: 'test.json', document: {}, originalComponent: {} },
+        };
+        expect(determineSchemaName(schema, 'TestId')).toEqual({
+            name: 'test',
+            isGenerated: true,
+        });
+    });
+    test('returns the schema name extracted from $src.path if it starts with "/components/schemas/"', () => {
+        const schema = {
+            $src: {
+                file: 'my-api.yml',
+                path: '/components/schemas/TestSchema',
+                document: {},
+                originalComponent: {},
+            },
+        };
+        expect(determineSchemaName(schema, 'TestId')).toEqual({
+            name: 'TestSchema',
+            isGenerated: false,
+        });
+    });
+    test('returns the schema name extracted from $src.path if it starts with "/definitions/"', () => {
+        const schema = {
+            $src: {
+                file: 'my-api.yml',
+                path: '/definitions/TestSchema',
+                document: {},
+                originalComponent: {},
+            },
+        };
+        expect(determineSchemaName(schema, 'TestId')).toEqual({
+            name: 'TestSchema',
+            isGenerated: false,
+        });
+    });
+    test('returns a generated name based on the $src.path for response schemas', () => {
+        const schema = {
+            $src: {
+                file: 'my-api.yml',
+                path: '/paths/users/{userId}/email-verification/{token}/get/responses/200/',
+                document: {},
+                originalComponent: {},
+            },
+        };
+        expect(determineSchemaName(schema, 'TestId')).toEqual({
+            name: 'get_users_:userId_email-verification_:token_200_Response',
+            isGenerated: true,
+        });
+    });
+    test('returns the provided id if no other name can be determined', () => {
+        const schema = {
+            $src: { file: 'my-api.yml', path: '/test/schema', document: {}, originalComponent: {} },
+        };
+        expect(determineSchemaName(schema, 'TestId')).toEqual({ name: 'TestId', isGenerated: true });
+    });
+});
+describe('determineSchemaAccessibility', () => {
+    test('returns "readOnly" if "readOnly" property is true and "writeOnly" property is false or undefined', () => {
+        const schema = { readOnly: true };
+        expect(determineSchemaAccessibility(schema)).toBe('readOnly');
+    });
+    test('returns "writeOnly" if "writeOnly" property is true and "readOnly" property is false or undefined', () => {
+        const schema = { writeOnly: true };
+        expect(determineSchemaAccessibility(schema)).toBe('writeOnly');
+    });
+    test('returns "none" if both "readOnly" and "writeOnly" properties are true', () => {
+        const schema = { readOnly: true, writeOnly: true };
+        expect(determineSchemaAccessibility(schema)).toBe('none');
+    });
+    test('returns "all" if neither "readOnly" nor "writeOnly" properties are true', () => {
+        const schema = {};
+        expect(determineSchemaAccessibility(schema)).toBe('all');
+    });
+});
+describe('getCustomFields', () => {
+    test('returns an empty object if no custom fields are present', () => {
+        const schema = { type: 'string' };
+        expect(getCustomFields(schema)).toEqual({});
+    });
+    test('returns an object containing all custom fields starting with "x-"', () => {
+        const schema = {
+            type: 'string',
+            'x-custom-field-1': 'value1',
+            'x-custom-field-2': 'value2',
+        };
+        expect(getCustomFields(schema)).toEqual({
+            'custom-field-1': 'value1',
+            'custom-field-2': 'value2',
+        });
+    });
+    test('returns an object containing only custom fields starting with "x-"', () => {
+        const schema = {
+            type: 'string',
+            'x-custom-field-1': 'value1',
+            'not-a-custom-field': 'value2',
+        };
+        expect(getCustomFields(schema)).toEqual({ 'custom-field-1': 'value1' });
+    });
+    test('returns an object with the same values as the original custom fields', () => {
+        const schema = {
+            type: 'string',
+            'x-custom-field-1': { key1: 'value1' },
+            'x-custom-field-2': ['value2'],
+        };
+        expect(getCustomFields(schema)).toEqual({
+            'custom-field-1': { key1: 'value1' },
+            'custom-field-2': ['value2'],
+        });
+    });
+});
+describe('determineEndpointName', () => {
+    test('returns the operationId if it exists', () => {
+        const endpointInfo = {
+            method: 'get',
+            path: '/users',
+            operation: { operationId: 'getUserList' },
+        };
+        expect(determineEndpointName(endpointInfo)).toBe('getUserList');
+    });
+    test('returns a generated name based on the method and path if operationId is not present', () => {
+        const endpointInfo = { method: 'post', path: '/users/{userId}/comments', operation: {} };
+        expect(determineEndpointName(endpointInfo)).toBe('post_users_:userId_comments');
+    });
+    test('replaces path parameters with their names in the generated name', () => {
+        const endpointInfo = {
+            method: 'get',
+            path: '/users/{userId}/comments/{commentId}',
+            operation: {},
+        };
+        expect(determineEndpointName(endpointInfo)).toBe('get_users_:userId_comments_:commentId');
+    });
+    test('replaces slashes in the path with underscores in the generated name', () => {
+        const endpointInfo = { method: 'put', path: '/users/{userId}/profile-picture', operation: {} };
+        expect(determineEndpointName(endpointInfo)).toBe('put_users_:userId_profile-picture');
+    });
+});
+describe('transformAdditionalProperties', () => {
+    const context = {};
+    test('returns undefined if additionalProperties is undefined or null', () => {
+        const schema1 = { additionalProperties: undefined };
+        const schema2 = { additionalProperties: null };
+        expect(transformAdditionalProperties(context, schema1, () => ({}))).toBeUndefined();
+        expect(transformAdditionalProperties(context, schema2, () => ({}))).toBeUndefined();
+    });
+    test('returns a boolean value if additionalProperties is a boolean value', () => {
+        const schema1 = { additionalProperties: true };
+        const schema2 = { additionalProperties: false };
+        expect(transformAdditionalProperties(context, schema1, () => ({}))).toBe(true);
+        expect(transformAdditionalProperties(context, schema2, () => ({}))).toBe(false);
+    });
+    test('calls transformSchema with the additionalProperties schema if it exists', () => {
+        const schema = { additionalProperties: { type: 'string' } };
+        const transformSchema = fn(() => ({}));
+        transformAdditionalProperties(context, schema, transformSchema);
+        expect(transformSchema).toHaveBeenCalledWith(context, schema.additionalProperties);
+    });
+    test('returns the result of calling transformSchema with the additionalProperties schema if it exists', () => {
+        const schema = { additionalProperties: { type: 'string' } };
+        const transformedSchema = { type: 'string' };
+        const transformSchema = fn(() => transformedSchema);
+        expect(transformAdditionalProperties(context, schema, transformSchema)).toBe(transformedSchema);
+    });
+});
+describe('transformSchemaProperties', () => {
+    const context = {};
+    test('returns an empty array if properties is undefined', () => {
+        const schema = {};
+        const transformSchema = fn(() => ({}));
+        expect(transformSchemaProperties(context, schema, transformSchema).size).toEqual(0);
+    });
+    test('calls transformSchema with each property schema and builds an array of ApiSchemaProperties', () => {
+        const schema = {
+            properties: {
+                prop1: { type: 'string' },
+                prop2: { type: 'integer' },
+            },
+            required: ['prop1'],
+        };
+        const transformedSchema1 = { type: 'string' };
+        const transformedSchema2 = { type: 'integer' };
+        // deno-lint-ignore no-explicit-any
+        const transformSchema = fn((_, subSchema) => subSchema.type === 'string' ? transformedSchema1 : transformedSchema2);
+        const result = transformSchemaProperties(context, schema, transformSchema);
+        expect(Array.from(result.entries())).toEqual([
+            ['prop1', { name: 'prop1', schema: transformedSchema1 }],
+            ['prop2', { name: 'prop2', schema: transformedSchema2 }],
+        ]);
+        expect(transformSchema).toHaveBeenCalledTimes(2);
+        expect(transformSchema).toHaveBeenCalledWith(context, schema.properties.prop1);
+        expect(transformSchema).toHaveBeenCalledWith(context, schema.properties.prop2);
+    });
+    test('ignores properties with the name "$src"', () => {
+        const schema = { properties: { prop1: { type: 'string' }, $src: { path: '/test/schema' } } };
+        const transformedSchema1 = { type: 'string' };
+        const transformSchema = fn(() => transformedSchema1);
+        const result = transformSchemaProperties(context, schema, transformSchema);
+        expect(Array.from(result.entries())).toEqual([['prop1', { name: 'prop1', schema: transformedSchema1 }]]);
+        expect(transformSchema).toHaveBeenCalledTimes(1);
+        expect(transformSchema).toHaveBeenCalledWith(context, schema.properties.prop1);
+    });
+});
+describe('IdGenerator', () => {
+    test('generates unique ids based on the provided name', () => {
+        const idGenerator = new IdGenerator();
+        const id1 = idGenerator.generateId('test');
+        const id2 = idGenerator.generateId('test');
+        expect(id1).not.toBe(id2);
+    });
+    test('generates ids with the format "{name}-{n}"', () => {
+        const idGenerator = new IdGenerator();
+        const id1 = idGenerator.generateId('test');
+        expect(id1).toMatch(/^test-\d+$/);
+    });
+    test('increments the id number for each new id generated with the same name', () => {
+        const idGenerator = new IdGenerator();
+        const id1 = idGenerator.generateId('test');
+        const id2 = idGenerator.generateId('test');
+        const id3 = idGenerator.generateId('test2');
+        const id4 = idGenerator.generateId('test');
+        expect(id1).toBe('test-1');
+        expect(id2).toBe('test-2');
+        expect(id3).toBe('test2-1');
+        expect(id4).toBe('test-3');
+    });
+});

package/esm/src/transform/transform-document.d.ts

@@ -0,0 +1,5 @@
+import type { OpenApiDocument } from '../parse/openapi-types.js';
+import type { Deref } from '../parse/types.js';
+import type { OpenApiTransformerContext } from './types.js';
+export declare function transformDocument(context: OpenApiTransformerContext, document: Deref<OpenApiDocument>): void;
+//# sourceMappingURL=transform-document.d.ts.map

package/esm/src/transform/transform-document.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"transform-document.d.ts","sourceRoot":"","sources":["../../../src/src/transform/transform-document.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAc,MAAM,2BAA2B,CAAC;AAC7E,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,mBAAmB,CAAC;AAG/C,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,YAAY,CAAC;AAE5D,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,yBAAyB,EAAE,QAAQ,EAAE,KAAK,CAAC,eAAe,CAAC,QAIrG"}

package/esm/src/transform/transform-endpoint.d.ts

@@ -0,0 +1,5 @@
+import type { OpenApiCollectorEndpointInfo } from '../collect/types.js';
+import type { ApiEndpoint } from './api-types.js';
+import type { OpenApiTransformerContext } from './types.js';
+export declare function transformEndpoint(context: OpenApiTransformerContext, endpointInfo: OpenApiCollectorEndpointInfo): ApiEndpoint;
+//# sourceMappingURL=transform-endpoint.d.ts.map

package/esm/src/transform/transform-endpoint.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"transform-endpoint.d.ts","sourceRoot":"","sources":["../../../src/src/transform/transform-endpoint.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,4BAA4B,EAAE,MAAM,qBAAqB,CAAC;AAYxE,OAAO,KAAK,EAEV,WAAW,EAOZ,MAAM,gBAAgB,CAAC;AAGxB,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,YAAY,CAAC;AAE5D,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,yBAAyB,EAAE,YAAY,EAAE,4BAA4B,eAiD/G"}

package/esm/src/transform/transform-endpoint.js

@@ -0,0 +1,269 @@
+import { isOpenApiObjectProperty } from '../internal-utils.js';
+import { determineEndpointName, getCustomFields, getOpenApiObjectIdentifier } from './helpers.js';
+import { transformSchema } from './transform-schema.js';
+export function transformEndpoint(context, endpointInfo) {
+    var _a, _b, _c, _d;
+    const apiPath = transformApiPath(context, endpointInfo.path, endpointInfo.pathItem);
+    const endpoint = {
+        $src: {
+            ...endpointInfo.operation.$src,
+            component: endpointInfo.operation,
+        },
+        $ref: undefined,
+        id: context.idGenerator.generateId('endpoint'),
+        name: determineEndpointName(endpointInfo),
+        path: endpointInfo.path,
+        pathInfo: apiPath,
+        method: endpointInfo.method,
+        summary: endpointInfo.operation.summary,
+        description: endpointInfo.operation.description,
+        parameters: combineParameters(apiPath.parameters, (_b = (_a = endpointInfo.operation.parameters) === null || _a === void 0 ? void 0 : _a.map((p) => transformParameter(context, p))) !== null && _b !== void 0 ? _b : []),
+        deprecated: (_c = endpointInfo.operation.deprecated) !== null && _c !== void 0 ? _c : false,
+        requestBody: endpointInfo.operation.requestBody
+            ? transformRequestBody(context, endpointInfo.operation.requestBody)
+            : undefined,
+        responses: transformResponses(context, endpointInfo.operation.responses),
+        tags: (_d = endpointInfo.operation.tags) !== null && _d !== void 0 ? _d : [],
+        custom: getCustomFields(endpointInfo.operation),
+    };
+    const tags = endpoint.tags.length === 0 ? [''] : endpoint.tags;
+    for (const tag of tags) {
+        let service = context.services.get(tag);
+        if (!service) {
+            const id = context.idGenerator.generateId('service');
+            service = {
+                $ref: undefined,
+                id,
+                name: tag || id,
+                description: undefined,
+                endpoints: [],
+            };
+            context.services.set(tag, service);
+        }
+        service.endpoints.push(endpoint);
+    }
+    apiPath[endpointInfo.method] = endpoint;
+    context.endpoints.set(`${endpointInfo.method}:${endpointInfo.path}`, endpoint);
+    return endpoint;
+}
+function transformApiPath(context, path, pathItem, isReference = false) {
+    var _a, _b;
+    const existingPath = context.paths.get(path);
+    if (existingPath)
+        return existingPath;
+    const openApiObjectId = getOpenApiObjectIdentifier(pathItem);
+    const existing = context.transformed.paths.get(openApiObjectId);
+    if (existing)
+        return existing;
+    const ref = pathItem.$ref ? transformApiPath(context, path, pathItem.$ref, true) : undefined;
+    const apiPath = {
+        $src: {
+            ...pathItem.$src,
+            component: pathItem,
+        },
+        $ref: ref,
+        id: context.idGenerator.generateId('path'),
+        summary: pathItem.summary,
+        description: pathItem.description,
+        path: path,
+        parameters: (_b = (_a = pathItem.parameters) === null || _a === void 0 ? void 0 : _a.map((p) => transformParameter(context, p))) !== null && _b !== void 0 ? _b : [],
+        // HTTP methods are added later (see transformEndpoint)
+        get: undefined,
+        put: undefined,
+        post: undefined,
+        delete: undefined,
+        options: undefined,
+        head: undefined,
+        patch: undefined,
+        trace: undefined,
+    };
+    context.transformed.paths.set(openApiObjectId, apiPath);
+    if (!isReference)
+        context.paths.set(path, apiPath);
+    return apiPath;
+}
+function transformParameter(context, parameter) {
+    var _a, _b, _c;
+    const openApiObjectId = getOpenApiObjectIdentifier(parameter);
+    const existing = context.transformed.parameters.get(openApiObjectId);
+    if (existing)
+        return existing;
+    const ref = parameter.$ref ? transformParameter(context, parameter.$ref) : undefined;
+    const id = context.idGenerator.generateId('parameter');
+    const p = {
+        $src: {
+            ...parameter.$src,
+            component: parameter,
+        },
+        $ref: ref,
+        id: id,
+        name: (_a = parameter.name) !== null && _a !== void 0 ? _a : id,
+        target: parameter.in,
+        description: parameter.description,
+        required: (_b = parameter.required) !== null && _b !== void 0 ? _b : false,
+        deprecated: (_c = parameter.deprecated) !== null && _c !== void 0 ? _c : false,
+        allowEmptyValue: parameter.allowEmptyValue,
+        style: parameter.style,
+        explode: parameter.explode,
+        allowReserved: parameter.allowReserved,
+        schema: parameter.schema ? transformSchema(context, parameter.schema) : undefined,
+    };
+    context.transformed.parameters.set(openApiObjectId, p);
+    return p;
+}
+function transformRequestBody(context, requestBody) {
+    var _a;
+    const openApiObjectId = getOpenApiObjectIdentifier(requestBody);
+    const existing = context.transformed.requestBodies.get(openApiObjectId);
+    if (existing)
+        return existing;
+    const ref = requestBody.$ref ? transformRequestBody(context, requestBody.$ref) : undefined;
+    const rb = {
+        $src: {
+            ...requestBody.$src,
+            component: requestBody,
+        },
+        $ref: ref,
+        id: context.idGenerator.generateId('requestBody'),
+        description: requestBody.description,
+        required: (_a = requestBody.required) !== null && _a !== void 0 ? _a : false,
+        content: transformContent(context, requestBody.content),
+    };
+    context.transformed.requestBodies.set(openApiObjectId, rb);
+    return rb;
+}
+function transformResponses(context, responses) {
+    if (!responses)
+        return [];
+    const result = [];
+    for (const status of Object.keys(responses)) {
+        if (!isOpenApiObjectProperty(status))
+            continue;
+        result.push(transformResponse(context, responses[status], status));
+    }
+    return result;
+}
+function transformResponse(context, response, status) {
+    const openApiObjectId = getOpenApiObjectIdentifier(response);
+    const existing = context.transformed.responses.get(openApiObjectId);
+    if (existing)
+        return existing;
+    const ref = response.$ref ? transformResponse(context, response.$ref, status) : undefined;
+    const r = {
+        $src: {
+            ...response.$src,
+            component: response,
+        },
+        $ref: ref,
+        id: context.idGenerator.generateId('response'),
+        statusCode: Number(status) || undefined,
+        description: response.description,
+        headers: transformHeaders(context, response.headers),
+        contentOptions: transformContent(context, response.content),
+    };
+    context.transformed.responses.set(openApiObjectId, r);
+    return r;
+}
+function transformContent(context, content) {
+    if (!content)
+        return [];
+    const result = [];
+    for (const media of Object.keys(content)) {
+        if (!isOpenApiObjectProperty(media))
+            continue;
+        result.push(transformMediaType(context, content[media], media));
+    }
+    return result;
+}
+function transformMediaType(context, mediaType, media) {
+    const openApiObjectId = getOpenApiObjectIdentifier(mediaType);
+    const existing = context.transformed.content.get(openApiObjectId);
+    if (existing)
+        return existing;
+    const ref = mediaType.$ref ? transformMediaType(context, mediaType.$ref, media) : undefined;
+    const mt = {
+        $src: {
+            ...mediaType.$src,
+            component: mediaType,
+        },
+        $ref: ref,
+        id: context.idGenerator.generateId('content'),
+        type: media,
+        schema: mediaType.schema ? transformSchema(context, mediaType.schema) : undefined,
+    };
+    context.transformed.content.set(openApiObjectId, mt);
+    return mt;
+}
+function combineParameters(pathParams, operationParams) {
+    const result = [...pathParams];
+    for (const opParam of operationParams) {
+        const existingParam = result.findIndex((p) => p.name === opParam.name);
+        if (existingParam >= 0) {
+            result[existingParam] = opParam;
+        }
+        else {
+            result.push(opParam);
+        }
+    }
+    return result;
+}
+function isSchema(obj) {
+    return obj && typeof obj === 'object' && obj['type'] !== undefined;
+}
+function transformHeaders(context, headers) {
+    if (!headers)
+        return [];
+    const result = [];
+    for (const name of Object.keys(headers)) {
+        if (!isOpenApiObjectProperty(name))
+            continue;
+        result.push(transformHeader(context, headers[name], name));
+    }
+    return result;
+}
+function transformHeader(context, header, name) {
+    var _a, _b;
+    const openApiObjectId = getOpenApiObjectIdentifier(header);
+    const existing = context.transformed.headers.get(openApiObjectId);
+    if (existing)
+        return existing;
+    let h;
+    const ref = header.$ref ? transformHeader(context, header.$ref, name) : undefined;
+    const id = context.idGenerator.generateId('header');
+    if (isSchema(header)) {
+        h = {
+            // deno-lint-ignore no-explicit-any
+            $src: Object.assign({}, header.$src, { component: header }),
+            $ref: ref,
+            id,
+            name,
+            description: header.description,
+            required: false,
+            deprecated: false,
+            allowEmptyValue: undefined,
+            style: undefined,
+            explode: undefined,
+            allowReserved: undefined,
+            schema: transformSchema(context, header),
+        };
+    }
+    else {
+        h = {
+            // deno-lint-ignore no-explicit-any
+            $src: Object.assign({}, header.$src, { component: header }),
+            $ref: ref,
+            id,
+            name,
+            description: header.description,
+            required: (_a = header.required) !== null && _a !== void 0 ? _a : false,
+            deprecated: (_b = header.deprecated) !== null && _b !== void 0 ? _b : false,
+            allowEmptyValue: header.allowEmptyValue,
+            style: header.style,
+            explode: header.explode,
+            allowReserved: header.allowReserved,
+            schema: header.schema ? transformSchema(context, header.schema) : undefined,
+        };
+    }
+    context.transformed.headers.set(openApiObjectId, h);
+    return h;
+}

package/esm/src/transform/transform-schema.d.ts

@@ -0,0 +1,6 @@
+import type { OpenApiSchema } from '../parse/openapi-types.js';
+import type { Deref } from '../parse/types.js';
+import type { ApiSchema } from './api-types.js';
+import type { OpenApiTransformerContext } from './types.js';
+export declare function transformSchema<T extends Deref<OpenApiSchema>>(ctx: OpenApiTransformerContext, schema: T): ApiSchema;
+//# sourceMappingURL=transform-schema.d.ts.map

package/esm/src/transform/transform-schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"transform-schema.d.ts","sourceRoot":"","sources":["../../../src/src/transform/transform-schema.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,2BAA2B,CAAC;AAC/D,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,mBAAmB,CAAC;AAE/C,OAAO,KAAK,EAAE,SAAS,EAAsC,MAAM,gBAAgB,CAAC;AAUpF,OAAO,KAAK,EAAuB,yBAAyB,EAAE,MAAM,YAAY,CAAC;AAEjF,wBAAgB,eAAe,CAAC,CAAC,SAAS,KAAK,CAAC,aAAa,CAAC,EAAE,GAAG,EAAE,yBAAyB,EAAE,MAAM,EAAE,CAAC,GAAG,SAAS,CAiFpH"}