@skmtc/core 0.0.808 → 0.0.810

package/esm/oas/header/Header.js

@@ -1,15 +1,3 @@
-var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
-    if (kind === "m") throw new TypeError("Private method is not writable");
-    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
-    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
-    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
-};
-var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
-    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
-    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
-    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
-};
-var _OasHeader_fields;
 /**
  * Represents a Header Object in the OpenAPI Specification.
  *
@@ -21,15 +9,6 @@ var _OasHeader_fields;
  * This class provides comprehensive support for header definitions with typed
  * values, validation schemas, examples, and documentation.
  *
- * ## Key Features
- *
- * - **Schema Validation**: Typed header values through schema definitions
- * - **Examples**: Multiple example values for documentation and testing
- * - **Content Types**: Support for complex header values with media types
- * - **Deprecation Support**: Mark headers as deprecated with proper warnings
- * - **Required/Optional**: Control whether headers are mandatory
- * - **Documentation**: Rich description support for API documentation
- *
  * @example Basic authentication header
  * ```typescript
  * import { OasHeader, OasString } from '@skmtc/core';
@@ -49,173 +28,6 @@ var _OasHeader_fields;
  *   }
  * });
  * ```
- *
- * @example Pagination headers
- * ```typescript
- * const totalCountHeader = new OasHeader({
- *   description: 'Total number of items available',
- *   required: false,
- *   schema: new OasInteger({
- *     minimum: 0,
- *     description: 'Non-negative integer count'
- *   }),
- *   examples: {
- *     empty: new OasExample({ value: 0, description: 'No items' }),
- *     normal: new OasExample({ value: 150, description: 'Normal case' }),
- *     large: new OasExample({ value: 10000, description: 'Large dataset' })
- *   }
- * });
- *
- * const linkHeader = new OasHeader({
- *   description: 'Pagination links (RFC 5988)',
- *   required: false,
- *   schema: new OasString({
- *     description: 'Comma-separated list of link relations'
- *   }),
- *   examples: {
- *     withNext: new OasExample({
- *       value: '</api/users?page=2>; rel="next", </api/users?page=10>; rel="last"'
- *     }),
- *     lastPage: new OasExample({
- *       value: '</api/users?page=9>; rel="prev", </api/users?page=1>; rel="first"'
- *     })
- *   }
- * });
- * ```
- *
- * @example Content type and encoding headers
- * ```typescript
- * const contentTypeHeader = new OasHeader({
- *   description: 'MIME type of the response content',
- *   required: true,
- *   schema: new OasString({
- *     enum: [
- *       'application/json',
- *       'application/xml',
- *       'text/csv',
- *       'application/pdf',
- *       'application/octet-stream'
- *     ]
- *   }),
- *   examples: {
- *     json: new OasExample({ value: 'application/json' }),
- *     xml: new OasExample({ value: 'application/xml' }),
- *     csv: new OasExample({ value: 'text/csv' })
- *   }
- * });
- *
- * const contentLengthHeader = new OasHeader({
- *   description: 'Size of the response body in bytes',
- *   required: false,
- *   schema: new OasInteger({
- *     minimum: 0,
- *     description: 'Content size in bytes'
- *   })
- * });
- * ```
- *
- * @example Rate limiting headers
- * ```typescript
- * const rateLimitHeader = new OasHeader({
- *   description: 'Number of requests remaining in the current window',
- *   required: false,
- *   schema: new OasInteger({
- *     minimum: 0,
- *     description: 'Remaining request count'
- *   }),
- *   examples: {
- *     available: new OasExample({ value: 95, description: '95 requests remaining' }),
- *     depleted: new OasExample({ value: 0, description: 'Rate limit reached' })
- *   }
- * });
- *
- * const rateLimitResetHeader = new OasHeader({
- *   description: 'Unix timestamp when the rate limit window resets',
- *   required: false,
- *   schema: new OasInteger({
- *     minimum: 0,
- *     description: 'Unix timestamp in seconds'
- *   }),
- *   examples: {
- *     reset: new OasExample({
- *       value: 1634567890,
- *       description: 'Reset at 2021-10-18 12:31:30 UTC'
- *     })
- *   }
- * });
- * ```
- *
- * @example Custom application headers
- * ```typescript
- * const requestIdHeader = new OasHeader({
- *   description: 'Unique identifier for request tracing',
- *   required: false,
- *   schema: new OasString({
- *     format: 'uuid',
- *     description: 'UUID v4 request identifier'
- *   }),
- *   examples: {
- *     uuid: new OasExample({
- *       value: '123e4567-e89b-12d3-a456-426614174000',
- *       description: 'Request tracking ID'
- *     })
- *   }
- * });
- *
- * const serverTimingHeader = new OasHeader({
- *   description: 'Server-side performance metrics',
- *   required: false,
- *   schema: new OasString({
- *     description: 'Server-Timing header format (RFC 8760)'
- *   }),
- *   examples: {
- *     timing: new OasExample({
- *       value: 'db;dur=53, app;dur=47.2',
- *       description: 'Database took 53ms, app logic 47.2ms'
- *     })
- *   }
- * });
- * ```
- *
- * @example Deprecated header
- * ```typescript
- * const deprecatedHeader = new OasHeader({
- *   description: 'Legacy API version header (deprecated)',
- *   required: false,
- *   deprecated: true,
- *   schema: new OasString({
- *     enum: ['v1', 'v2'],
- *     description: 'Use Accept or Content-Type header instead'
- *   }),
- *   examples: {
- *     legacy: new OasExample({
- *       value: 'v1',
- *       description: 'Legacy version (use Accept header instead)'
- *     })
- *   }
- * });
- * ```
- *
- * @example Using in response definitions
- * ```typescript
- * const successResponse = new OasResponse({
- *   description: 'Paginated user list',
- *   headers: {
- *     'X-Total-Count': totalCountHeader,
- *     'Link': linkHeader,
- *     'X-Rate-Limit-Remaining': rateLimitHeader,
- *     'X-Rate-Limit-Reset': rateLimitResetHeader,
- *     'X-Request-ID': requestIdHeader
- *   },
- *   content: {
- *     'application/json': new OasMediaType({
- *       schema: new OasArray({
- *         items: new OasRef({ $ref: '#/components/schemas/User' })
- *       })
- *     })
- *   }
- * });
- * ```
  */
 export class OasHeader {
     constructor(fields) {
@@ -225,36 +37,62 @@ export class OasHeader {
             writable: true,
             value: 'header'
         });
-        _OasHeader_fields.set(this, void 0);
-        __classPrivateFieldSet(this, _OasHeader_fields, fields, "f");
-    }
-    /** Brief description of header */
-    get description() {
-        return __classPrivateFieldGet(this, _OasHeader_fields, "f").description;
-    }
-    /** Indicates if header is mandatory. Default value is `false` */
-    get required() {
-        return __classPrivateFieldGet(this, _OasHeader_fields, "f").required;
-    }
-    /** Indicates if header is deprecated and should no longer be used. Default value is false */
-    get deprecated() {
-        return __classPrivateFieldGet(this, _OasHeader_fields, "f").deprecated;
-    }
-    /** Schema for the header */
-    get schema() {
-        return __classPrivateFieldGet(this, _OasHeader_fields, "f").schema;
-    }
-    /** Examples of the header */
-    get examples() {
-        return __classPrivateFieldGet(this, _OasHeader_fields, "f").examples;
-    }
-    /** Content of the header */
-    get content() {
-        return __classPrivateFieldGet(this, _OasHeader_fields, "f").content;
-    }
-    /** Specification Extension fields */
-    get extensionFields() {
-        return __classPrivateFieldGet(this, _OasHeader_fields, "f").extensionFields;
+        /** Brief description of header */
+        Object.defineProperty(this, "description", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        /** Indicates if header is mandatory. Default value is `false` */
+        Object.defineProperty(this, "required", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        /** Indicates if header is deprecated and should no longer be used. Default value is false */
+        Object.defineProperty(this, "deprecated", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        /** Schema for the header */
+        Object.defineProperty(this, "schema", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        /** Examples of the header */
+        Object.defineProperty(this, "examples", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        /** Content of the header */
+        Object.defineProperty(this, "content", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        /** Specification Extension fields */
+        Object.defineProperty(this, "extensionFields", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.description = fields.description;
+        this.required = fields.required;
+        this.deprecated = fields.deprecated;
+        this.schema = fields.schema;
+        this.examples = fields.examples;
+        this.content = fields.content;
+        this.extensionFields = fields.extensionFields;
     }
     /** Returns true if object is a reference */
     isRef() {
@@ -276,7 +114,7 @@ export class OasHeader {
         if (this.schema) {
             return this.schema;
         }
-        const schema = __classPrivateFieldGet(this, _OasHeader_fields, "f").content?.[mediaType]?.schema;
+        const schema = this.content?.[mediaType]?.schema;
         if (!schema) {
             throw new Error(`Schema not found for media type ${mediaType}`);
         }
@@ -292,4 +130,3 @@ export class OasHeader {
         };
     }
 }
-_OasHeader_fields = new WeakMap();

package/esm/oas/mediaType/toMediaTypeItemV3.d.ts

@@ -1,21 +1,309 @@
 import type { OpenAPIV3 } from 'openapi-types';
 import type { ParseContext } from '../../context/ParseContext.js';
 import { OasMediaType } from './MediaType.js';
+/**
+ * Arguments for transforming an OpenAPI v3 media type item into an OAS media type.
+ */
 type ToMediaTypeItemV3Args = {
+    /** The OpenAPI v3 media type object to transform */
     mediaTypeItem: OpenAPIV3.MediaTypeObject;
+    /** The media type string (e.g., 'application/json', 'text/plain') */
     mediaType: string;
+    /** The parsing context for tracing and processing */
     context: ParseContext;
 };
+/**
+ * Transforms an OpenAPI v3 media type object into an internal OAS media type representation.
+ *
+ * This function processes OpenAPI v3 MediaType objects, extracting schema definitions,
+ * examples, encoding information, and specification extensions. It creates a structured
+ * internal representation that can be used by the SKMTC pipeline for code generation
+ * and validation.
+ *
+ * The transformation handles all standard OpenAPI v3 MediaType properties including
+ * schema references, inline schemas, examples, encoding specifications, and custom
+ * extension fields that begin with 'x-'.
+ *
+ * @param args - Transformation arguments
+ * @param args.mediaTypeItem - The OpenAPI v3 media type object to process
+ * @param args.mediaType - The media type identifier (MIME type)
+ * @param args.context - Parsing context for tracing and error handling
+ * @returns Structured OAS media type object for internal processing
+ *
+ * @example Transforming JSON media type
+ * ```typescript
+ * import { toMediaTypeItemV3 } from '@skmtc/core/oas/mediaType';
+ *
+ * const jsonMediaType = {
+ *   schema: {
+ *     type: 'object',
+ *     properties: {
+ *       name: { type: 'string' },
+ *       email: { type: 'string', format: 'email' }
+ *     }
+ *   },
+ *   example: {
+ *     name: 'John Doe',
+ *     email: 'john@example.com'
+ *   }
+ * };
+ *
+ * const result = toMediaTypeItemV3({
+ *   mediaTypeItem: jsonMediaType,
+ *   mediaType: 'application/json',
+ *   context: parseContext
+ * });
+ *
+ * console.log(result.mediaType); // 'application/json'
+ * console.log(result.schema); // Processed schema object
+ * ```
+ *
+ * @example Processing form data with encoding
+ * ```typescript
+ * const formMediaType = {
+ *   schema: {
+ *     type: 'object',
+ *     properties: {
+ *       file: { type: 'string', format: 'binary' },
+ *       metadata: { type: 'string' }
+ *     }
+ *   },
+ *   encoding: {
+ *     file: {
+ *       contentType: 'image/png',
+ *       headers: {
+ *         'X-Rate-Limit': {
+ *           schema: { type: 'integer' }
+ *         }
+ *       }
+ *     }
+ *   }
+ * };
+ *
+ * const result = toMediaTypeItemV3({
+ *   mediaTypeItem: formMediaType,
+ *   mediaType: 'multipart/form-data',
+ *   context: parseContext
+ * });
+ *
+ * console.log(result.encoding); // Processed encoding configuration
+ * ```
+ *
+ * @example Handling multiple examples
+ * ```typescript
+ * const mediaTypeWithExamples = {
+ *   schema: { type: 'string' },
+ *   examples: {
+ *     success: {
+ *       summary: 'Successful response',
+ *       value: 'Operation completed'
+ *     },
+ *     error: {
+ *       summary: 'Error response',
+ *       value: 'Operation failed'
+ *     }
+ *   }
+ * };
+ *
+ * const result = toMediaTypeItemV3({
+ *   mediaTypeItem: mediaTypeWithExamples,
+ *   mediaType: 'text/plain',
+ *   context: parseContext
+ * });
+ *
+ * console.log(Object.keys(result.examples)); // ['success', 'error']
+ * ```
+ */
 export declare const toMediaTypeItemV3: ({ mediaTypeItem, mediaType, context }: ToMediaTypeItemV3Args) => OasMediaType;
+/**
+ * Arguments for transforming multiple OpenAPI v3 media type items.
+ */
 type ToMediaTypeItemsV3Args = {
+    /** Map of media type strings to OpenAPI v3 MediaType objects */
     content: Record<string, OpenAPIV3.MediaTypeObject>;
+    /** The parsing context for tracing and processing */
     context: ParseContext;
 };
+/**
+ * Transforms multiple OpenAPI v3 media type objects into internal OAS representations.
+ *
+ * This function processes a complete content map from OpenAPI v3, transforming each
+ * media type entry into its internal OAS representation. It's commonly used to process
+ * the `content` property of request bodies, responses, and parameters that support
+ * multiple media types.
+ *
+ * The function maintains the original media type keys while transforming the values
+ * into structured OAS media type objects. Each transformation is traced for debugging
+ * and error tracking purposes.
+ *
+ * @param args - Transformation arguments
+ * @param args.content - Map of media types to OpenAPI MediaType objects
+ * @param args.context - Parsing context for tracing and error handling
+ * @returns Map of media type strings to processed OAS media type objects
+ *
+ * @example Processing multiple content types
+ * ```typescript
+ * import { toMediaTypeItemsV3 } from '@skmtc/core/oas/mediaType';
+ *
+ * const content = {
+ *   'application/json': {
+ *     schema: {
+ *       type: 'object',
+ *       properties: { message: { type: 'string' } }
+ *     }
+ *   },
+ *   'application/xml': {
+ *     schema: {
+ *       type: 'string'
+ *     }
+ *   },
+ *   'text/plain': {
+ *     schema: {
+ *       type: 'string'
+ *     },
+ *     example: 'Plain text response'
+ *   }
+ * };
+ *
+ * const result = toMediaTypeItemsV3({
+ *   content,
+ *   context: parseContext
+ * });
+ *
+ * console.log(Object.keys(result)); // ['application/json', 'application/xml', 'text/plain']
+ * console.log(result['application/json'].mediaType); // 'application/json'
+ * ```
+ *
+ * @example Processing request body content types
+ * ```typescript
+ * const requestBodyContent = {
+ *   'application/json': {
+ *     schema: { $ref: '#/components/schemas/CreateUserRequest' }
+ *   },
+ *   'application/x-www-form-urlencoded': {
+ *     schema: {
+ *       type: 'object',
+ *       properties: {
+ *         name: { type: 'string' },
+ *         email: { type: 'string' }
+ *       }
+ *     },
+ *     encoding: {
+ *       email: {
+ *         style: 'form',
+ *         explode: false
+ *       }
+ *     }
+ *   }
+ * };
+ *
+ * const processed = toMediaTypeItemsV3({
+ *   content: requestBodyContent,
+ *   context: parseContext
+ * });
+ *
+ * // Each media type is processed with its specific configuration
+ * console.log(processed['application/json'].schema); // Reference object
+ * console.log(processed['application/x-www-form-urlencoded'].encoding); // Form encoding config
+ * ```
+ */
 export declare const toMediaTypeItemsV3: ({ content, context }: ToMediaTypeItemsV3Args) => Record<string, OasMediaType>;
+/**
+ * Arguments for optionally transforming OpenAPI v3 media type items.
+ */
 type ToOptionalMediaTypeItemsV3Args = {
+    /** Optional map of media type strings to OpenAPI v3 MediaType objects */
     content: Record<string, OpenAPIV3.MediaTypeObject> | undefined;
+    /** The parsing context for tracing and processing */
     context: ParseContext;
 };
+/**
+ * Optionally transforms OpenAPI v3 media type objects when content is provided.
+ *
+ * This function provides a safe way to process media type content that may or may not
+ * be present in the OpenAPI specification. It handles the common pattern where content
+ * properties are optional in OpenAPI objects (like responses without bodies or
+ * operations without request bodies).
+ *
+ * When content is undefined, the function returns undefined without processing.
+ * When content is provided, it delegates to `toMediaTypeItemsV3` for full processing.
+ *
+ * @param args - Transformation arguments
+ * @param args.content - Optional map of media types to OpenAPI MediaType objects
+ * @param args.context - Parsing context for tracing and error handling
+ * @returns Map of processed media types if content exists, undefined otherwise
+ *
+ * @example Handling optional response content
+ * ```typescript
+ * import { toOptionalMediaTypeItemsV3 } from '@skmtc/core/oas/mediaType';
+ *
+ * // Response with content
+ * const responseWithContent = {
+ *   description: 'Successful response',
+ *   content: {
+ *     'application/json': {
+ *       schema: { type: 'object' }
+ *     }
+ *   }
+ * };
+ *
+ * const withContent = toOptionalMediaTypeItemsV3({
+ *   content: responseWithContent.content,
+ *   context: parseContext
+ * });
+ * console.log(withContent); // { 'application/json': OasMediaType }
+ *
+ * // Response without content (like 204 No Content)
+ * const responseNoContent = {
+ *   description: 'No content response'
+ * };
+ *
+ * const noContent = toOptionalMediaTypeItemsV3({
+ *   content: responseNoContent.content, // undefined
+ *   context: parseContext
+ * });
+ * console.log(noContent); // undefined
+ * ```
+ *
+ * @example Processing operations with optional request bodies
+ * ```typescript
+ * function processOperation(operation: OpenAPIV3.OperationObject) {
+ *   const requestBodyContent = toOptionalMediaTypeItemsV3({
+ *     content: operation.requestBody?.content,
+ *     context: parseContext
+ *   });
+ *
+ *   if (requestBodyContent) {
+ *     console.log('Operation has request body with media types:');
+ *     console.log(Object.keys(requestBodyContent));
+ *   } else {
+ *     console.log('Operation has no request body');
+ *   }
+ * }
+ * ```
+ *
+ * @example Safe processing in response handlers
+ * ```typescript
+ * class ResponseProcessor {
+ *   processResponse(response: OpenAPIV3.ResponseObject) {
+ *     const mediaTypes = toOptionalMediaTypeItemsV3({
+ *       content: response.content,
+ *       context: this.context
+ *     });
+ *
+ *     // Safe to check without worrying about undefined content
+ *     const hasJsonResponse = mediaTypes && 'application/json' in mediaTypes;
+ *
+ *     if (hasJsonResponse) {
+ *       const jsonMediaType = mediaTypes['application/json'];
+ *       return this.generateJsonResponseHandler(jsonMediaType);
+ *     }
+ *
+ *     return this.generateEmptyResponseHandler();
+ *   }
+ * }
+ * ```
+ */
 export declare const toOptionalMediaTypeItemsV3: ({ content, context }: ToOptionalMediaTypeItemsV3Args) => Record<string, OasMediaType> | undefined;
 export {};
 //# sourceMappingURL=toMediaTypeItemV3.d.ts.map

package/esm/oas/mediaType/toMediaTypeItemV3.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"toMediaTypeItemV3.d.ts","sourceRoot":"","sources":["../../../src/oas/mediaType/toMediaTypeItemV3.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,eAAe,CAAA;AAC9C,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,+BAA+B,CAAA;AAGjE,OAAO,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAA;AAI7C,KAAK,qBAAqB,GAAG;IAC3B,aAAa,EAAE,SAAS,CAAC,eAAe,CAAA;IACxC,SAAS,EAAE,MAAM,CAAA;IACjB,OAAO,EAAE,YAAY,CAAA;CACtB,CAAA;AAED,eAAO,MAAM,iBAAiB,GAAI,uCAI/B,qBAAqB,KAAG,YA0B1B,CAAA;AAED,KAAK,sBAAsB,GAAG;IAC5B,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,SAAS,CAAC,eAAe,CAAC,CAAA;IAClD,OAAO,EAAE,YAAY,CAAA;CACtB,CAAA;AAED,eAAO,MAAM,kBAAkB,GAAI,sBAGhC,sBAAsB,KAAG,MAAM,CAAC,MAAM,EAAE,YAAY,CAatD,CAAA;AAED,KAAK,8BAA8B,GAAG;IACpC,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,SAAS,CAAC,eAAe,CAAC,GAAG,SAAS,CAAA;IAC9D,OAAO,EAAE,YAAY,CAAA;CACtB,CAAA;AAED,eAAO,MAAM,0BAA0B,GAAI,sBAGxC,8BAA8B,KAAG,MAAM,CAAC,MAAM,EAAE,YAAY,CAAC,GAAG,SAMlE,CAAA"}
+{"version":3,"file":"toMediaTypeItemV3.d.ts","sourceRoot":"","sources":["../../../src/oas/mediaType/toMediaTypeItemV3.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,eAAe,CAAA;AAC9C,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,+BAA+B,CAAA;AAGjE,OAAO,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAA;AAI7C;;GAEG;AACH,KAAK,qBAAqB,GAAG;IAC3B,oDAAoD;IACpD,aAAa,EAAE,SAAS,CAAC,eAAe,CAAA;IACxC,qEAAqE;IACrE,SAAS,EAAE,MAAM,CAAA;IACjB,qDAAqD;IACrD,OAAO,EAAE,YAAY,CAAA;CACtB,CAAA;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqGG;AACH,eAAO,MAAM,iBAAiB,GAAI,uCAI/B,qBAAqB,KAAG,YA0B1B,CAAA;AAED;;GAEG;AACH,KAAK,sBAAsB,GAAG;IAC5B,gEAAgE;IAChE,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,SAAS,CAAC,eAAe,CAAC,CAAA;IAClD,qDAAqD;IACrD,OAAO,EAAE,YAAY,CAAA;CACtB,CAAA;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkFG;AACH,eAAO,MAAM,kBAAkB,GAAI,sBAGhC,sBAAsB,KAAG,MAAM,CAAC,MAAM,EAAE,YAAY,CAatD,CAAA;AAED;;GAEG;AACH,KAAK,8BAA8B,GAAG;IACpC,yEAAyE;IACzE,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,SAAS,CAAC,eAAe,CAAC,GAAG,SAAS,CAAA;IAC9D,qDAAqD;IACrD,OAAO,EAAE,YAAY,CAAA;CACtB,CAAA;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsFG;AACH,eAAO,MAAM,0BAA0B,GAAI,sBAGxC,8BAA8B,KAAG,MAAM,CAAC,MAAM,EAAE,YAAY,CAAC,GAAG,SAMlE,CAAA"}