@scalar/oas-utils 0.11.1 → 0.12.0

package/dist/entities/spec/request-examples.js

@@ -1,449 +0,0 @@
-import { isDefined } from '@scalar/helpers/array/is-defined';
-import { objectKeys } from '@scalar/helpers/object/object-keys';
-import { keysOf } from '@scalar/object-utils/arrays';
-import { nanoidSchema } from '@scalar/types/utils';
-import { z } from 'zod';
-import { schemaModel } from '../../helpers/schema-model.js';
-import { getRequestBodyFromOperation } from '../../spec-getters/get-request-body-from-operation.js';
-import { getServerVariableExamples } from '../../spec-getters/get-server-variable-examples.js';
-// ---------------------------------------------------------------------------
-// Example Parameters
-/**
- * TODO: Deprecate this.
- *
- * The request schema should be stored in the request and any
- * parameters should be validated against that
- */
-export const requestExampleParametersSchema = z
-    .object({
-    key: z.string().default(''),
-    value: z.coerce.string().default(''),
-    enabled: z.boolean().default(true),
-    file: z.any().optional(),
-    description: z.string().optional(),
-    required: z.boolean().optional(),
-    enum: z.array(z.string()).optional(),
-    examples: z.array(z.any()).optional(),
-    type: z
-        .union([
-        // 'string'
-        z.string(),
-        // ['string', 'null']
-        z.array(z.string()),
-    ])
-        .optional(),
-    format: z.string().optional(),
-    minimum: z.number().optional(),
-    maximum: z.number().optional(),
-    default: z.any().optional(),
-    nullable: z.boolean().optional(),
-})
-    // set nullable: to true if type is ['string', 'null']
-    .transform((_data) => {
-    const data = { ..._data };
-    // type: ['string', 'null'] -> nullable: true
-    if (Array.isArray(data.type) && data.type.includes('null')) {
-        data.nullable = true;
-    }
-    // Hey, if it's just one value and 'null', we can make it a string and ditch the 'null'.
-    if (Array.isArray(data.type) && data.type.length === 2 && data.type.includes('null')) {
-        data.type = data.type.find((item) => item !== 'null');
-    }
-    return data;
-});
-/** Convert the array of parameters to an object keyed by the parameter name */
-export const parameterArrayToObject = (params) => params.reduce((map, param) => {
-    map[param.key] = param.value;
-    return map;
-}, {});
-const xScalarFileValueSchema = z
-    .object({
-    url: z.string(),
-    base64: z.string().optional(),
-})
-    .nullable();
-/**
- * When files are required for an example we provide the options
- * to provide a public URL or a base64 encoded string
- */
-// not used but kept for consistency
-// export type XScalarFileValue = z.infer<typeof xScalarFileValueSchema>
-/**
- * Schema for the OAS serialization of request example parameters
- *
- * File values can be optionally fetched on import OR inserted as a base64 encoded string
- */
-const xScalarFormDataValue = z.union([
-    z.object({
-        type: z.literal('string'),
-        value: z.string(),
-    }),
-    z.object({
-        type: z.literal('file'),
-        file: xScalarFileValueSchema,
-    }),
-]);
-// ---------------------------------------------------------------------------
-// Example Body
-/**
- * Possible encodings for example request bodies when using text formats
- *
- * TODO: This list may not be comprehensive enough
- */
-const exampleRequestBodyEncoding = ['json', 'text', 'html', 'javascript', 'xml', 'yaml', 'edn'];
-const exampleBodyMime = [
-    'application/json',
-    'text/plain',
-    'text/html',
-    'application/javascript',
-    'application/xml',
-    'application/yaml',
-    'application/edn',
-    'application/octet-stream',
-    'application/x-www-form-urlencoded',
-    'multipart/form-data',
-    /** Used for direct files */
-    'binary',
-];
-const contentMapping = {
-    json: 'application/json',
-    text: 'text/plain',
-    html: 'text/html',
-    javascript: 'application/javascript',
-    xml: 'application/xml',
-    yaml: 'application/yaml',
-    edn: 'application/edn',
-};
-/**
- * TODO: Migrate away from this layout to the format used in the extension
- *
- * If a user changes the encoding of the body we expect the content to change as well
- */
-const exampleRequestBodySchema = z.object({
-    raw: z
-        .object({
-        encoding: z.enum(exampleRequestBodyEncoding),
-        value: z.string().default(''),
-        mimeType: z.string().optional(),
-    })
-        .optional(),
-    formData: z
-        .object({
-        encoding: z.union([z.literal('form-data'), z.literal('urlencoded')]).default('form-data'),
-        value: requestExampleParametersSchema.array().default([]),
-    })
-        .optional(),
-    binary: z.instanceof(Blob).optional(),
-    activeBody: z.union([z.literal('raw'), z.literal('formData'), z.literal('binary')]).default('raw'),
-});
-/** Schema for the OAS serialization of request example bodies */
-const xScalarExampleBodySchema = z.object({
-    encoding: z.enum(exampleBodyMime),
-    /**
-     * Body content as an object with a separately specified encoding or a simple pre-encoded string value
-     *
-     * Ideally we would convert any objects into the proper encoding on import
-     */
-    content: z.union([z.record(z.string(), z.any()), z.string()]),
-    /** When the encoding is `binary` this will be used to link to the file */
-    file: xScalarFileValueSchema.optional(),
-});
-// ---------------------------------------------------------------------------
-// Example Schema
-export const requestExampleSchema = z.object({
-    uid: nanoidSchema.brand(),
-    type: z.literal('requestExample').optional().default('requestExample'),
-    requestUid: z.string().brand().optional(),
-    name: z.string().optional().default('Name'),
-    body: exampleRequestBodySchema.optional().default({ activeBody: 'raw' }),
-    parameters: z
-        .object({
-        path: requestExampleParametersSchema.array().default([]),
-        query: requestExampleParametersSchema.array().default([]),
-        headers: requestExampleParametersSchema.array().default([{ key: 'Accept', value: '*/*', enabled: true }]),
-        cookies: requestExampleParametersSchema.array().default([]),
-    })
-        .optional()
-        .default({
-        path: [],
-        query: [],
-        headers: [{ key: 'Accept', value: '*/*', enabled: true }],
-        cookies: [],
-    }),
-    /** TODO: Should this be deprecated? */
-    serverVariables: z.record(z.string(), z.array(z.string())).optional(),
-});
-/** For OAS serialization we just store the simple key/value pairs */
-const xScalarExampleParameterSchema = z.record(z.string(), z.string()).optional();
-/** Schema for the OAS serialization of request examples */
-export const xScalarExampleSchema = z.object({
-    /** TODO: Should this be required? */
-    name: z.string().optional(),
-    body: xScalarExampleBodySchema.optional(),
-    parameters: z.object({
-        path: xScalarExampleParameterSchema,
-        query: xScalarExampleParameterSchema,
-        headers: xScalarExampleParameterSchema,
-        cookies: xScalarExampleParameterSchema,
-    }),
-});
-/**
- * Convert a request example to the xScalar serialized format
- *
- * TODO: The base format should be migrated to align MUCH closer to the serialized format
- */
-export function convertExampleToXScalar(example) {
-    const active = example.body?.activeBody;
-    const xScalarBody = {
-        encoding: 'text/plain',
-        content: '',
-    };
-    if (example.body?.activeBody === 'binary') {
-        xScalarBody.encoding = 'binary';
-        // TODO: Need to allow users to set these properties
-        xScalarBody.file = null;
-    }
-    if (active === 'formData' && example.body?.[active]) {
-        const body = example.body[active];
-        xScalarBody.encoding = body.encoding === 'form-data' ? 'multipart/form-data' : 'application/x-www-form-urlencoded';
-        // TODO: Need to allow users to set these properties
-        xScalarBody.content = body.value.reduce((map, param) => {
-            /** TODO: We need to ensure only file or value is set */
-            map[param.key] = param.file
-                ? {
-                    type: 'file',
-                    file: null,
-                }
-                : {
-                    type: 'string',
-                    value: param.value,
-                };
-            return map;
-        }, {});
-    }
-    if (example.body?.activeBody === 'raw') {
-        xScalarBody.encoding = contentMapping[example.body.raw?.encoding ?? 'text'] ?? 'text/plain';
-        xScalarBody.content = example.body.raw?.value ?? '';
-    }
-    const parameters = {};
-    keysOf(example.parameters ?? {}).forEach((key) => {
-        if (example.parameters?.[key].length) {
-            parameters[key] = parameterArrayToObject(example.parameters[key]);
-        }
-    });
-    return xScalarExampleSchema.parse({
-        /** Only add the body if we have content or the body should be a file */
-        body: xScalarBody.content || xScalarBody.encoding === 'binary' ? xScalarBody : undefined,
-        parameters,
-    });
-}
-// ---------------------------------------------------------------------------
-// Example Helpers
-/** Create new instance parameter from a request parameter */
-export function createParamInstance(param) {
-    const schema = param.schema;
-    const firstExample = (() => {
-        if (param.examples && !Array.isArray(param.examples) && objectKeys(param.examples).length > 0) {
-            const exampleValues = Object.entries(param.examples).map(([_, example]) => {
-                // returns the external value if it exists
-                if (example.externalValue) {
-                    return example.externalValue;
-                }
-                // returns the value if it exists and is defined
-                // e.g. { examples: { foo: { value: 'bar' } } } would return ['bar']
-                return example.value;
-            });
-            // returns the first example as selected value along other examples
-            return { value: exampleValues[0], examples: exampleValues };
-        }
-        // param example e.g. { example: 'foo' }
-        if (isDefined(param.example)) {
-            return { value: param.example };
-        }
-        // param examples e.g. { examples: ['foo', 'bar'] }
-        if (Array.isArray(param.examples) && param.examples.length > 0) {
-            return { value: param.examples[0] };
-        }
-        // schema example e.g. { example: 'foo' } while being discouraged
-        // see https://spec.openapis.org/oas/v3.1.1.html#fixed-fields-20
-        if (isDefined(schema?.example)) {
-            return { value: schema.example };
-        }
-        // schema examples e.g. { examples: ['foo', 'bar'] }
-        if (Array.isArray(schema?.examples) && schema.examples.length > 0) {
-            // For boolean type, default to false when using schema examples
-            if (schema?.type === 'boolean') {
-                return { value: schema.default ?? false };
-            }
-            return { value: schema.examples[0] };
-        }
-        // content examples e.g. { content: { 'application/json': { examples: { foo: { value: 'bar' } } } } }
-        if (param.content) {
-            const firstContentType = objectKeys(param.content)[0];
-            if (firstContentType) {
-                const content = param.content[firstContentType];
-                if (content?.examples) {
-                    const firstExampleKey = Object.keys(content.examples)[0];
-                    if (firstExampleKey) {
-                        const example = content.examples[firstExampleKey];
-                        if (isDefined(example?.value)) {
-                            return { value: example.value };
-                        }
-                    }
-                }
-                // content example e.g. { example: 'foo' }
-                if (isDefined(content?.example)) {
-                    return { value: content.example };
-                }
-            }
-        }
-        return null;
-    })();
-    /**
-     * TODO:
-     * - Need better value defaulting here
-     * - Need to handle non-string parameters much better
-     * - Need to handle unions/array values for schema
-     */
-    const value = String(firstExample?.value ?? schema?.default ?? '');
-    // Handle non-string enums and enums within items for array types
-    const parseEnum = (() => {
-        if (schema?.enum && schema?.type !== 'string') {
-            return schema.enum?.map(String);
-        }
-        if (schema?.items?.enum && schema?.type === 'array') {
-            return schema.items.enum.map(String);
-        }
-        return schema?.enum;
-    })();
-    // Handle parameter examples
-    const examples = firstExample?.examples ||
-        (schema?.examples && schema?.type !== 'string' ? schema.examples?.map(String) : schema?.examples);
-    // safe parse the example
-    const example = schemaModel({
-        ...schema,
-        key: param.name,
-        value,
-        description: param.description,
-        required: param.required,
-        /** Initialized all required properties to enabled */
-        enabled: !!param.required,
-        enum: parseEnum,
-        examples,
-    }, requestExampleParametersSchema, false);
-    if (!example) {
-        console.warn(`Example at ${param.name} is invalid.`);
-        return requestExampleParametersSchema.parse({});
-    }
-    return example;
-}
-/**
- * Create new request example from a request
- * Iterates the name of the example if provided
- */
-export function createExampleFromRequest(request, name, server) {
-    // ---------------------------------------------------------------------------
-    // Populate all parameters with an example value
-    const parameters = {
-        path: [],
-        query: [],
-        cookie: [],
-        // deprecated TODO: add zod transform to remove
-        header: [],
-        headers: [{ key: 'Accept', value: '*/*', enabled: true }],
-    };
-    // Populated the separated params
-    request.parameters?.forEach((p) => parameters[p.in].push(createParamInstance(p)));
-    // TODO: add zod transform to remove header and only support headers
-    if (parameters.header.length > 0) {
-        parameters.headers = parameters.header;
-        parameters.header = [];
-    }
-    // Get content type header
-    const contentTypeHeader = parameters.headers.find((h) => h.key.toLowerCase() === 'content-type');
-    // ---------------------------------------------------------------------------
-    // Handle request body defaulting for various content type encodings
-    const body = {
-        activeBody: 'raw',
-    };
-    // If we have a request body or a content type header
-    // TODO: we don't even handle path parameters here
-    if (request.requestBody || contentTypeHeader?.value) {
-        const requestBody = getRequestBodyFromOperation(request);
-        const contentType = request.requestBody ? requestBody?.mimeType : contentTypeHeader?.value;
-        // Handle JSON and JSON-like mimetypes
-        if (contentType?.includes('/json') || contentType?.endsWith('+json')) {
-            body.activeBody = 'raw';
-            body.raw = {
-                encoding: 'json',
-                mimeType: contentType,
-                value: requestBody?.text ?? JSON.stringify({}),
-            };
-        }
-        if (contentType === 'application/xml') {
-            body.activeBody = 'raw';
-            body.raw = {
-                encoding: 'xml',
-                value: requestBody?.text ?? '',
-            };
-        }
-        /**
-         *  TODO: Are we loading example files from somewhere based on the spec?
-         *  How are we handling the body values
-         */
-        if (contentType === 'application/octet-stream') {
-            body.activeBody = 'binary';
-            body.binary = undefined;
-        }
-        if (contentType === 'application/x-www-form-urlencoded' || contentType === 'multipart/form-data') {
-            body.activeBody = 'formData';
-            body.formData = {
-                encoding: contentType === 'application/x-www-form-urlencoded' ? 'urlencoded' : 'form-data',
-                value: (requestBody?.params || []).map((param) => {
-                    if (param.value instanceof File) {
-                        return {
-                            key: param.name,
-                            value: 'BINARY',
-                            file: param.value,
-                            enabled: true,
-                        };
-                    }
-                    return {
-                        key: param.name,
-                        value: param.value || '',
-                        enabled: true,
-                    };
-                }),
-            };
-        }
-        if (contentType?.startsWith('text/')) {
-            body.activeBody = 'raw';
-            body.raw = {
-                encoding: 'text',
-                value: requestBody?.text ?? '',
-            };
-        }
-        // Add the content-type header if it doesn't exist and if it's not multipart request
-        if (requestBody?.mimeType && !contentTypeHeader && !requestBody.mimeType.startsWith('multipart/')) {
-            parameters.headers.push({
-                key: 'Content-Type',
-                value: requestBody.mimeType,
-                enabled: true,
-            });
-        }
-    }
-    const serverVariables = server ? getServerVariableExamples(server) : {};
-    // safe parse the example
-    const example = schemaModel({
-        requestUid: request.uid,
-        parameters,
-        name,
-        body,
-        serverVariables,
-    }, requestExampleSchema, false);
-    if (!example) {
-        console.warn(`Example at ${request.uid} is invalid.`);
-        return requestExampleSchema.parse({});
-    }
-    return example;
-}

package/dist/entities/spec/requests.d.ts

@@ -1,137 +0,0 @@
-import { XScalarStability } from '@scalar/types/legacy';
-import type { XPostResponse } from '@scalar/workspace-store/schemas/extensions/general/x-post-response';
-import { z } from 'zod';
-import { type RequestExample } from './request-examples.js';
-/** The code to execute */
-declare const postResponseSchema: z.ZodString;
-declare const requestMethods: readonly ["delete", "get", "head", "options", "patch", "post", "put", "trace"];
-export type RequestMethod = (typeof requestMethods)[number];
-/** A single set of populated values for a sent request */
-export type ResponseInstance = Omit<Response, 'headers'> & {
-    /** Store headers as an object to match what we had with axios */
-    headers: Record<string, string>;
-    /** Keys of headers which set cookies */
-    cookieHeaderKeys: string[];
-    /** Time in ms the request took */
-    duration: number;
-    /** The response status */
-    status: number;
-    /** The response status text */
-    statusText: string;
-    /** The response method */
-    method: RequestMethod;
-    /** The request path */
-    path: string;
-} & ({
-    /** The response data */
-    data: string | Blob;
-    /** The response size in bytes */
-    size: number;
-} | {
-    /** A stream reader for a streamable response body */
-    reader: ReadableStreamDefaultReader<Uint8Array>;
-});
-/** A single request/response set to save to the history stack */
-export type RequestEvent = {
-    request: RequestExample;
-    response: ResponseInstance;
-    timestamp: number;
-};
-export type PostResponseScript = z.infer<typeof postResponseSchema>;
-export type PostResponseScripts = XPostResponse['x-post-response'];
-/** Unified request schema for client usage */
-export declare const requestSchema: z.ZodObject<{
-    description: z.ZodOptional<z.ZodString>;
-    summary: z.ZodOptional<z.ZodString>;
-    externalDocs: z.ZodOptional<z.ZodPipe<z.ZodObject<{
-        description: z.ZodCatch<z.ZodOptional<z.ZodString>>;
-        url: z.ZodString;
-    }, z.core.$strip>, z.ZodTransform<{
-        url: string;
-        description?: string | undefined;
-    }, {
-        url: string;
-        description?: string | undefined;
-    }>>>;
-    'x-internal': z.ZodOptional<z.ZodBoolean>;
-    'x-scalar-ignore': z.ZodOptional<z.ZodBoolean>;
-    security: z.ZodOptional<z.ZodArray<z.ZodRecord<z.ZodString, z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodString>>>>>>;
-    tags: z.ZodOptional<z.ZodArray<z.ZodString>>;
-    deprecated: z.ZodOptional<z.ZodBoolean>;
-    operationId: z.ZodOptional<z.ZodString>;
-    requestBody: z.ZodOptional<z.ZodAny>;
-    parameters: z.ZodOptional<z.ZodArray<z.ZodObject<{
-        in: z.ZodEnum<{
-            cookie: "cookie";
-            path: "path";
-            query: "query";
-            header: "header";
-        }>;
-        name: z.ZodString;
-        description: z.ZodOptional<z.ZodString>;
-        required: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
-        deprecated: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
-        schema: z.ZodOptional<z.ZodUnknown>;
-        content: z.ZodOptional<z.ZodUnknown>;
-        style: z.ZodOptional<z.ZodEnum<{
-            matrix: "matrix";
-            label: "label";
-            form: "form";
-            simple: "simple";
-            spaceDelimited: "spaceDelimited";
-            pipeDelimited: "pipeDelimited";
-            deepObject: "deepObject";
-        }>>;
-        explode: z.ZodOptional<z.ZodBoolean>;
-        example: z.ZodOptional<z.ZodUnknown>;
-        examples: z.ZodOptional<z.ZodUnion<readonly [z.ZodRecord<z.ZodString, z.ZodObject<{
-            value: z.ZodOptional<z.ZodUnknown>;
-            summary: z.ZodOptional<z.ZodString>;
-            externalValue: z.ZodOptional<z.ZodString>;
-        }, z.core.$strip>>, z.ZodArray<z.ZodUnknown>]>>;
-    }, z.core.$strip>>>;
-    responses: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
-    callbacks: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodRecord<z.ZodString, z.ZodRecord<z.ZodString, z.ZodAny>>>>;
-    'x-codeSamples': z.ZodCatch<z.ZodOptional<z.ZodArray<z.ZodObject<{
-        lang: z.ZodCatch<z.ZodOptional<z.ZodString>>;
-        label: z.ZodCatch<z.ZodOptional<z.ZodString>>;
-        source: z.ZodString;
-    }, z.core.$strip>>>>;
-    'x-code-samples': z.ZodCatch<z.ZodOptional<z.ZodArray<z.ZodObject<{
-        lang: z.ZodCatch<z.ZodOptional<z.ZodString>>;
-        label: z.ZodCatch<z.ZodOptional<z.ZodString>>;
-        source: z.ZodString;
-    }, z.core.$strip>>>>;
-    'x-custom-examples': z.ZodCatch<z.ZodOptional<z.ZodArray<z.ZodObject<{
-        lang: z.ZodCatch<z.ZodOptional<z.ZodString>>;
-        label: z.ZodCatch<z.ZodOptional<z.ZodString>>;
-        source: z.ZodString;
-    }, z.core.$strip>>>>;
-    'x-scalar-stability': z.ZodCatch<z.ZodOptional<z.ZodEnum<{
-        deprecated: XScalarStability.Deprecated;
-        experimental: XScalarStability.Experimental;
-        stable: XScalarStability.Stable;
-    }>>>;
-    type: z.ZodDefault<z.ZodOptional<z.ZodLiteral<"request">>>;
-    uid: z.core.$ZodBranded<z.ZodDefault<z.ZodString>, "operation", "out">;
-    path: z.ZodDefault<z.ZodOptional<z.ZodString>>;
-    method: z.ZodDefault<z.ZodEnum<{
-        delete: "delete";
-        get: "get";
-        head: "head";
-        options: "options";
-        patch: "patch";
-        post: "post";
-        put: "put";
-        trace: "trace";
-    }>>;
-    servers: z.ZodDefault<z.ZodArray<z.core.$ZodBranded<z.ZodString, "server", "out">>>;
-    selectedServerUid: z.ZodDefault<z.ZodNullable<z.ZodOptional<z.core.$ZodBranded<z.ZodString, "server", "out">>>>;
-    examples: z.ZodDefault<z.ZodArray<z.core.$ZodBranded<z.ZodString, "example", "out">>>;
-    selectedSecuritySchemeUids: z.ZodDefault<z.ZodArray<z.ZodUnion<readonly [z.core.$ZodBranded<z.ZodString, "securityScheme", "out">, z.ZodArray<z.core.$ZodBranded<z.ZodString, "securityScheme", "out">>]>>>;
-    'x-post-response': z.ZodOptional<z.ZodString>;
-}, z.core.$strip>;
-export type Request = z.infer<typeof requestSchema>;
-export type RequestPayload = z.input<typeof requestSchema>;
-export {};
-//# sourceMappingURL=requests.d.ts.map

package/dist/entities/spec/requests.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"requests.d.ts","sourceRoot":"","sources":["../../../src/entities/spec/requests.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,gBAAgB,EAAE,MAAM,sBAAsB,CAAA;AAEvD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,oEAAoE,CAAA;AAGvG,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAKvB,OAAO,EAAE,KAAK,cAAc,EAAwB,MAAM,oBAAoB,CAAA;AAe9E,0BAA0B;AAC1B,QAAA,MAAM,kBAAkB,aAAa,CAAA;AAMrC,QAAA,MAAM,cAAc,gFAAiF,CAAA;AAErG,MAAM,MAAM,aAAa,GAAG,CAAC,OAAO,cAAc,CAAC,CAAC,MAAM,CAAC,CAAA;AAE3D,0DAA0D;AAC1D,MAAM,MAAM,gBAAgB,GAAG,IAAI,CAAC,QAAQ,EAAE,SAAS,CAAC,GAAG;IACzD,iEAAiE;IACjE,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;IAC/B,wCAAwC;IACxC,gBAAgB,EAAE,MAAM,EAAE,CAAA;IAC1B,kCAAkC;IAClC,QAAQ,EAAE,MAAM,CAAA;IAChB,0BAA0B;IAC1B,MAAM,EAAE,MAAM,CAAA;IACd,+BAA+B;IAC/B,UAAU,EAAE,MAAM,CAAA;IAClB,0BAA0B;IAC1B,MAAM,EAAE,aAAa,CAAA;IACrB,uBAAuB;IACvB,IAAI,EAAE,MAAM,CAAA;CACb,GAAG,CACE;IACE,wBAAwB;IACxB,IAAI,EAAE,MAAM,GAAG,IAAI,CAAA;IACnB,iCAAiC;IACjC,IAAI,EAAE,MAAM,CAAA;CACb,GACD;IACE,qDAAqD;IACrD,MAAM,EAAE,2BAA2B,CAAC,UAAU,CAAC,CAAA;CAChD,CACJ,CAAA;AAEH,iEAAiE;AACjE,MAAM,MAAM,YAAY,GAAG;IACzB,OAAO,EAAE,cAAc,CAAA;IACvB,QAAQ,EAAE,gBAAgB,CAAA;IAC1B,SAAS,EAAE,MAAM,CAAA;CAClB,CAAA;AAoGD,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAA;AACnE,MAAM,MAAM,mBAAmB,GAAG,aAAa,CAAC,iBAAiB,CAAC,CAAA;AAElE,8CAA8C;AAC9C,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAKG,CAAA;AAE7B,MAAM,MAAM,OAAO,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,aAAa,CAAC,CAAA;AACnD,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,aAAa,CAAC,CAAA"}