typia 5.0.0-dev.20230827 → 5.0.0-dev.20230829

package/src/transformers/FileTransformer.ts

@@ -2,6 +2,7 @@ import ts from "typescript";
 
 import { IProject } from "./IProject";
 import { NodeTransformer } from "./NodeTransformer";
+import { TransformerError } from "./TransformerError";
 
 export namespace FileTransformer {
     export const transform =
@@ -19,29 +20,40 @@ export namespace FileTransformer {
     const iterate_node =
         (project: IProject) =>
         (context: ts.TransformationContext) =>
-        (node: ts.Node): ts.Node =>
-            ts.visitEachChild(
-                try_transform_node(project)(node),
+        (node: ts.Node): ts.Node => {
+            const changed: ts.Node | null = try_transform_node(project)(node);
+            return ts.visitEachChild(
+                changed ?? node,
                 (child) => iterate_node(project)(context)(child),
                 context,
             );
+        };
 
     const try_transform_node =
         (project: IProject) =>
-        (node: ts.Node): ts.Node => {
+        (node: ts.Node): ts.Node | null => {
             try {
                 return NodeTransformer.transform(project)(node);
             } catch (exp) {
-                if (!(exp instanceof Error)) throw exp;
-
-                const file: ts.SourceFile | undefined = node.getSourceFile();
-                if (file === undefined) throw exp;
+                // ONLY ACCEPT TRANSFORMER-ERROR
+                if (!isTransformerError(exp)) throw exp;
 
-                const { line, character } = file.getLineAndCharacterOfPosition(
-                    node.pos,
-                );
-                console.error(`${file.fileName}:${line}:${character}:`, exp);
-                throw exp;
+                // REPORT DIAGNOSTIC
+                const diagnostic = ts.createDiagnosticForNode(node, {
+                    key: exp.code,
+                    category: ts.DiagnosticCategory.Error,
+                    message: exp.message,
+                    code: `(${exp.code})` as any,
+                });
+                project.extras.addDiagnostic(diagnostic);
+                return null;
             }
         };
 }
+
+const isTransformerError = (error: any): error is TransformerError =>
+    typeof error === "object" &&
+    error !== null &&
+    error.constructor.name === "TransformerError" &&
+    typeof error.code === "string" &&
+    typeof error.message === "string";

package/src/transformers/IProject.ts

@@ -9,4 +9,7 @@ export interface IProject {
     printer: ts.Printer;
     options: ITransformOptions;
     context: ts.TransformationContext;
+    extras: {
+        addDiagnostic: (diag: ts.Diagnostic) => number;
+    };
 }

package/src/transformers/NodeTransformer.ts

@@ -6,7 +6,7 @@ import { IProject } from "./IProject";
 export namespace NodeTransformer {
     export const transform =
         (project: IProject) =>
-        (expression: ts.Node): ts.Node =>
+        (expression: ts.Node): ts.Node | null =>
             ts.isCallExpression(expression)
                 ? CallExpressionTransformer.transform(project)(expression)
                 : expression;

package/src/transformers/TransformerError.ts

@@ -0,0 +1,55 @@
+import { MetadataFactory } from "../factories/MetadataFactory";
+
+import { MetadataObject } from "../schemas/metadata/MetadataObject";
+
+import { Escaper } from "../utils/Escaper";
+
+export class TransformerError extends Error {
+    public readonly code: string;
+
+    public constructor(props: TransformerError.IProps) {
+        super(props.message);
+        this.code = props.code;
+
+        // INHERITANCE POLYFILL
+        const proto = new.target.prototype;
+        if (Object.setPrototypeOf) Object.setPrototypeOf(this, proto);
+        else (this as any).__proto__ = proto;
+    }
+}
+export namespace TransformerError {
+    export interface IProps {
+        code: string;
+        message: string;
+    }
+
+    export const from =
+        (method: string) =>
+        (errors: MetadataFactory.IError[]): TransformerError => {
+            const body: string = errors
+                .map((e) => {
+                    const subject: string =
+                        e.explore.object === null
+                            ? ""
+                            : join(e.explore.object)(e.explore.property);
+                    const type: string = `${
+                        subject.length ? `${subject}: ` : ""
+                    }${e.name}`;
+                    return `- ${type}\n${e.messages
+                        .map((msg) => `  - ${msg}`)
+                        .join("\n")}`;
+                })
+                .join("\n\n");
+            return new TransformerError({
+                code: method,
+                message: `unsupported type detected\n\n${body}`,
+            });
+        };
+
+    const join = (object: MetadataObject) => (key: string | object | null) => {
+        if (key === null) return object.name;
+        else if (typeof key === "object") return `${object.name}[key]`;
+        else if (Escaper.variable(key)) return `${object.name}.${key}`;
+        return `${object.name}[${JSON.stringify(key)}]`;
+    };
+}

package/src/transformers/features/CreateRandomTransformer.ts

@@ -3,6 +3,7 @@ import ts from "typescript";
 import { RandomProgrammer } from "../../programmers/RandomProgrammer";
 
 import { IProject } from "../IProject";
+import { TransformerError } from "../TransformerError";
 
 export namespace CreateRandomTransformer {
     export const transform =
@@ -10,13 +11,21 @@ export namespace CreateRandomTransformer {
         (modulo: ts.LeftHandSideExpression) =>
         (expression: ts.CallExpression): ts.Expression => {
             // CHECK GENERIC ARGUMENT EXISTENCE
-            if (!expression.typeArguments?.[0]) throw new Error(NOT_SPECIFIED);
+            if (!expression.typeArguments?.[0])
+                throw new TransformerError({
+                    code: "typia.createRandom",
+                    message: "generic argument is not specified.",
+                });
 
             // GET TYPE INFO
             const node: ts.TypeNode = expression.typeArguments[0];
             const type: ts.Type = project.checker.getTypeFromTypeNode(node);
 
-            if (type.isTypeParameter()) throw new Error(NO_GENERIC_ARGUMENT);
+            if (type.isTypeParameter())
+                throw new TransformerError({
+                    code: "typia.createRandom",
+                    message: "non-specified generic argument.",
+                });
 
             // DO TRANSFORM
             return RandomProgrammer.write({
@@ -32,8 +41,3 @@ export namespace CreateRandomTransformer {
             );
         };
 }
-
-const NOT_SPECIFIED =
-    "Error on typia.createRandom(): generic argument is not specified.";
-const NO_GENERIC_ARGUMENT =
-    "Error on typia.createRandom(): non-specified generic argument.";

package/src/transformers/features/RandomTransformer.ts

@@ -3,6 +3,7 @@ import ts from "typescript";
 import { RandomProgrammer } from "../../programmers/RandomProgrammer";
 
 import { IProject } from "../IProject";
+import { TransformerError } from "../TransformerError";
 
 export namespace RandomTransformer {
     export const transform =
@@ -10,13 +11,21 @@ export namespace RandomTransformer {
         (modulo: ts.LeftHandSideExpression) =>
         (expression: ts.CallExpression): ts.Expression => {
             // CHECK GENERIC ARGUMENT EXISTENCE
-            if (!expression.typeArguments?.[0]) throw new Error(NOT_SPECIFIED);
+            if (!expression.typeArguments?.[0])
+                throw new TransformerError({
+                    code: `typia.${modulo.getText()}`,
+                    message: "generic argument is not specified.",
+                });
 
             // GET TYPE INFO
             const node: ts.TypeNode = expression.typeArguments[0];
             const type: ts.Type = project.checker.getTypeFromTypeNode(node);
 
-            if (type.isTypeParameter()) throw new Error(NO_GENERIC_ARGUMENT);
+            if (type.isTypeParameter())
+                throw new TransformerError({
+                    code: `typia.${modulo.getText()}`,
+                    message: "non-specified generic argument.",
+                });
 
             // DO TRANSFORM
             return ts.factory.createCallExpression(
@@ -35,8 +44,3 @@ export namespace RandomTransformer {
             );
         };
 }
-
-const NOT_SPECIFIED =
-    "Error on typia.random(): generic argument is not specified.";
-const NO_GENERIC_ARGUMENT =
-    "Error on typia.random(): non-specified generic argument.";

package/src/transformers/features/json/JsonApplicationTransformer.ts

@@ -1,5 +1,6 @@
 import ts from "typescript";
 
+import { JsonMetadataFactory } from "../../../factories/JsonMetadataFactory";
 import { LiteralFactory } from "../../../factories/LiteralFactory";
 import { MetadataCollection } from "../../../factories/MetadataCollection";
 import { MetadataFactory } from "../../../factories/MetadataFactory";
@@ -9,14 +10,20 @@ import { Metadata } from "../../../schemas/metadata/Metadata";
 
 import { JsonApplicationProgrammer } from "../../../programmers/json/JsonApplicationProgrammer";
 
+import { ValidationPipe } from "../../../typings/ValidationPipe";
+
 import { IProject } from "../../IProject";
+import { TransformerError } from "../../TransformerError";
 
 export namespace JsonApplicationTransformer {
     export const transform =
         ({ checker }: IProject) =>
         (expression: ts.CallExpression): ts.Expression => {
             if (!expression.typeArguments?.length)
-                throw new Error(NO_GENERIC_ARGUMENT);
+                throw new TransformerError({
+                    code: "typia.json.application",
+                    message: "no generic argument.",
+                });
 
             //----
             // GET ARGUMENTS
@@ -32,7 +39,10 @@ export namespace JsonApplicationTransformer {
                 checker.getTypeFromTypeNode(child as ts.TypeNode),
             );
             if (types.some((t) => t.isTypeParameter()))
-                throw new Error(GENERIC_ARGUMENT);
+                throw new TransformerError({
+                    code: "typia.json.application",
+                    message: "non-specified generic argument(s).",
+                });
 
             // ADDITIONAL PARAMETERS
             const purpose: "swagger" | "ajv" = get_parameter(
@@ -48,24 +58,25 @@ export namespace JsonApplicationTransformer {
             //----
             // METADATA
             const collection: MetadataCollection = new MetadataCollection();
-            const metadatas: Array<Metadata> = types.map((type) =>
-                MetadataFactory.analyze(checker)({
-                    escape: true,
-                    constant: true,
-                    absorb: false,
-                    validate: (meta) => {
-                        if (meta.atomics.find((atom) => atom.type === "bigint"))
-                            throw new Error(NO_BIGIT);
-                        else if (
-                            meta.arrays.some(
-                                (array) =>
-                                    array.type.value.isRequired() === false,
-                            )
-                        )
-                            throw new Error(NO_UNDEFINED_IN_ARRAY);
-                    },
-                })(collection)(type),
-            );
+            const results: ValidationPipe<Metadata, MetadataFactory.IError>[] =
+                types.map((type) =>
+                    MetadataFactory.analyze(checker)({
+                        escape: true,
+                        constant: true,
+                        absorb: false,
+                        validate: JsonMetadataFactory.validate,
+                    })(collection)(type),
+                );
+
+            // REPORT BUG IF REQUIRED
+            const metadatas: Metadata[] = [];
+            const errors: MetadataFactory.IError[] = [];
+            for (const r of results) {
+                if (r.success === false) errors.push(...r.errors);
+                else metadatas.push(r.data);
+            }
+            if (errors.length)
+                throw TransformerError.from("typia.json.application")(errors);
 
             // APPLICATION
             const app: IJsonApplication = JsonApplicationProgrammer.write({
@@ -88,25 +99,18 @@ export namespace JsonApplicationTransformer {
         // CHECK LITERAL TYPE
         const type: ts.Type = checker.getTypeFromTypeNode(node);
         if (!type.isLiteral())
-            throw new Error(
-                `Error on typia.application(): generic argument "${name}" must be constant.`,
-            );
+            throw new TransformerError({
+                code: "typia.json.application",
+                message: `generic argument "${name}" must be constant.`,
+            });
 
         // GET VALUE AND VALIDATE IT
         const value = type.value;
         if (typeof value !== "string" || predicator(value) === false)
-            throw new Error(
-                `Error on typia.application(): invalid value on generic argument "${name}".`,
-            );
+            throw new TransformerError({
+                code: "typia.json.application",
+                message: `invalid value on generic argument "${name}".`,
+            });
         return value as T;
     };
 }
-
-const NO_GENERIC_ARGUMENT =
-    "Error on typia.json.application(): no generic argument.";
-const GENERIC_ARGUMENT =
-    "Error on typia.json.application(): non-specified generic argument(s).";
-const NO_BIGIT =
-    "Error on typia.json.application(): does not allow bigint type.";
-const NO_UNDEFINED_IN_ARRAY =
-    "Error on typia.json.application(): does not allow undefined type in array.";

package/src/transformers/features/misc/MetadataTransformer.ts

@@ -8,13 +8,17 @@ import { IMetadataApplication } from "../../../schemas/metadata/IMetadataApplica
 import { Metadata } from "../../../schemas/metadata/Metadata";
 
 import { IProject } from "../../IProject";
+import { TransformerError } from "../../TransformerError";
 
 export namespace MetadataTransformer {
     export const transform =
         ({ checker }: IProject) =>
         (expression: ts.CallExpression): ts.Expression => {
             if (!expression.typeArguments?.length)
-                throw new Error(NO_GENERIC_ARGUMENT);
+                throw new TransformerError({
+                    code: "typia.metadata",
+                    message: "no generic argument.",
+                });
 
             // VALIDATE TUPLE ARGUMENTS
             const top: ts.Node = expression.typeArguments[0]!;
@@ -27,17 +31,25 @@ export namespace MetadataTransformer {
                 checker.getTypeFromTypeNode(child as ts.TypeNode),
             );
             if (types.some((t) => t.isTypeParameter()))
-                throw new Error(GENERIC_ARGUMENT);
+                throw new TransformerError({
+                    code: "typia.metadata",
+                    message: "non-specified generic argument(s).",
+                });
 
             // METADATA
             const collection: MetadataCollection = new MetadataCollection();
-            const metadatas: Array<Metadata> = types.map((type) =>
-                MetadataFactory.analyze(checker)({
+            const metadatas: Array<Metadata> = types.map((type) => {
+                const result = MetadataFactory.analyze(checker)({
                     escape: true,
                     constant: true,
                     absorb: true,
-                })(collection)(type),
-            );
+                })(collection)(type);
+                if (result.success === false)
+                    throw TransformerError.from("typia.metadata")(
+                        result.errors,
+                    );
+                return result.data;
+            });
 
             // CONVERT TO PRIMITIVE TYPE
             const app: IMetadataApplication = {
@@ -47,7 +59,3 @@ export namespace MetadataTransformer {
             return LiteralFactory.generate(app);
         };
 }
-
-const NO_GENERIC_ARGUMENT = "Error on typia.metadata(): no generic argument.";
-const GENERIC_ARGUMENT =
-    "Error on typia.metadata(): non-specified generic argument(s).";

package/src/transformers/features/misc/MiscLiteralsTransformer.ts

@@ -3,26 +3,30 @@ import ts from "typescript";
 import { MiscLiteralsProgrammer } from "../../../programmers/misc/MiscLiteralsProgrammer";
 
 import { IProject } from "../../IProject";
+import { TransformerError } from "../../TransformerError";
 
 export namespace MiscLiteralsTransformer {
     export const transform =
         (project: IProject) =>
         (expression: ts.CallExpression): ts.Expression => {
             // CHECK GENERIC ARGUMENT EXISTENCE
-            if (!expression.typeArguments?.[0]) throw new Error(NOT_SPECIFIED);
+            if (!expression.typeArguments?.[0])
+                throw new TransformerError({
+                    code: "typia.misc.literals",
+                    message: "generic argument is not specified.",
+                });
 
             // GET TYPE INFO
             const node: ts.TypeNode = expression.typeArguments[0];
             const type: ts.Type = project.checker.getTypeFromTypeNode(node);
 
-            if (type.isTypeParameter()) throw new Error(NO_GENERIC_ARGUMENT);
+            if (type.isTypeParameter())
+                throw new TransformerError({
+                    code: "typia.misc.literals",
+                    message: "non-specified generic argument.",
+                });
 
             // DO TRANSFORM
             return MiscLiteralsProgrammer.write(project)(type);
         };
 }
-
-const NOT_SPECIFIED =
-    "Error on typia.literals(): generic argument is not specified.";
-const NO_GENERIC_ARGUMENT =
-    "Error on typia.literals(): non-specified generic argument.";

package/src/transformers/features/protobuf/ProtobufMessageTransformer.ts

@@ -3,6 +3,7 @@ import ts from "typescript";
 import { ProtobufMessageProgrammer } from "../../../programmers/protobuf/ProtobufMessageProgrammer";
 
 import { IProject } from "../../IProject";
+import { TransformerError } from "../../TransformerError";
 
 export namespace ProtobufMessageTransformer {
     export const transform =
@@ -11,21 +12,22 @@ export namespace ProtobufMessageTransformer {
         (expression: ts.CallExpression): ts.Expression => {
             // CHECK GENERIC ARGUMENT EXISTENCE
             if (!expression.typeArguments || !expression.typeArguments[0])
-                throw new Error(ErrorMessages.NOT_SPECIFIED);
+                throw new TransformerError({
+                    code: "typia.protobuf.message",
+                    message: "generic argument is not specified.",
+                });
 
             // GET TYPE INFO
             const type: ts.Type = project.checker.getTypeFromTypeNode(
                 expression.typeArguments[0],
             );
             if (type.isTypeParameter())
-                throw new Error(ErrorMessages.GENERIC_ARGUMENT);
+                throw new TransformerError({
+                    code: "tyipa.protobuf.message",
+                    message: "non-specified generic argument.",
+                });
 
             // DO TRANSFORM
             return ProtobufMessageProgrammer.write(project)(type);
         };
 }
-
-const enum ErrorMessages {
-    NOT_SPECIFIED = "Error on typia.protobuf.message(): generic argument is not specified.",
-    GENERIC_ARGUMENT = "Error on typia.protobuf.message(): non-specified generic argument.",
-}

package/src/transformers/internal/GenericTransformer.ts

@@ -1,6 +1,7 @@
 import ts from "typescript";
 
 import { IProject } from "../IProject";
+import { TransformerError } from "../TransformerError";
 
 export namespace GenericTransformer {
     export const scalar =
@@ -17,7 +18,10 @@ export namespace GenericTransformer {
         (expression: ts.CallExpression) => {
             // CHECK PARAMETER
             if (expression.arguments.length !== 1)
-                throw new Error(`Error on typia.${method}(): no input value.`);
+                throw new TransformerError({
+                    code: `typia.${method}`,
+                    message: `no input value.`,
+                });
 
             // GET TYPE INFO
             const [type, node, generic]: [ts.Type, ts.Node, boolean] =
@@ -37,9 +41,10 @@ export namespace GenericTransformer {
                           false,
                       ];
             if (type.isTypeParameter())
-                throw new Error(
-                    `Error on typia.${method}(): non-specified generic argument.`,
-                );
+                throw new TransformerError({
+                    code: `typia.${method}`,
+                    message: `non-specified generic argument.`,
+                });
 
             // DO TRANSFORM
             return ts.factory.createCallExpression(
@@ -68,18 +73,20 @@ export namespace GenericTransformer {
         (expression: ts.CallExpression) => {
             // CHECK GENERIC ARGUMENT EXISTENCE
             if (!expression.typeArguments?.[0])
-                throw new Error(
-                    `Error on typia.${method}(): generic argument is not specified.`,
-                );
+                throw new TransformerError({
+                    code: `typia.${method}`,
+                    message: `generic argument is not specified.`,
+                });
 
             // GET TYPE INFO
             const node: ts.TypeNode = expression.typeArguments[0];
             const type: ts.Type = project.checker.getTypeFromTypeNode(node);
 
             if (type.isTypeParameter())
-                throw new Error(
-                    `Error on typia.${method}(): non-specified generic argument.`,
-                );
+                throw new TransformerError({
+                    code: `typia.${method}`,
+                    message: `non-specified generic argument.`,
+                });
 
             // DO TRANSFORM
             return programmer(project)(modulo)(type, node.getFullText().trim());

package/src/typings/ValidationPipe.ts

@@ -0,0 +1,9 @@
+export type ValidationPipe<T, E> =
+    | {
+          success: true;
+          data: T;
+      }
+    | {
+          success: false;
+          errors: E[];
+      };

package/lib/programmers/internal/application_resolved.d.ts

@@ -1,4 +0,0 @@
-import { MetadataEscaped } from "../../schemas/metadata/MetadataEscaped";
-import { IJsonComponents, IJsonSchema } from "../../module";
-import { JsonApplicationProgrammer } from "../json/JsonApplicationProgrammer";
-export declare const application_resolved: (options: JsonApplicationProgrammer.IOptions) => <BlockNever extends boolean>(blockNever: BlockNever) => (components: IJsonComponents) => (resolved: MetadataEscaped) => (attribute: IJsonSchema.IAttribute) => IJsonSchema[];

package/lib/programmers/internal/application_resolved.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"application_resolved.js","sourceRoot":"","sources":["../../../src/programmers/internal/application_resolved.ts"],"names":[],"mappings":";;;AAKA,2DAA0D;AAEnD,IAAM,oBAAoB,GAC7B,UAAC,OAA2C;IAC5C,OAAA,UAA6B,UAAsB;QACnD,OAAA,UAAC,UAA2B;YAC5B,OAAA,UAAC,QAAyB;gBAC1B,OAAA,UAAC,SAAiC;oBAC9B,IAAM,MAAM,GAAG,IAAA,uCAAkB,EAAC,OAAO,CAAC,CAAC,UAAU,CAAC,CAAC,UAAU,CAAC,CAC9D,QAAQ,CAAC,OAAO,CACnB,CAAC,SAAS,CAAC,CAAC;oBACb,IAAI,MAAM,KAAK,IAAI;wBAAE,OAAO,EAAE,CAAC;oBAE/B,IAAI,OAAO,CAAC,IAAI,GAAG,EAAE,CAAC,CAAC,QAAQ,CAAC,QAAQ,CAAC,EAAE;wBACvC,IAAM,MAAM,GAAoC,SAAS,CAAC,MAAM,CAAC;4BAC7D,CAAC,CAAC,MAAM;4BACR,CAAC,CAAC,SAAS,CAAC,MAAM,CAAC;gCACnB,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC,IAAI,CAAC,SAAS,CAAC;gCAC9B,CAAC,CAAC,SAAS,CAAC;wBAChB,IACI,MAAM,KAAK,SAAS;4BACpB,MAAM,CAAC,MAAM,KAAK,MAAM;4BACxB,MAAM,CAAC,MAAM,KAAK,WAAW;4BAE7B,MAAM,CAAC,MAAM,GAAG,WAAW,CAAC;qBACnC;oBACD,OAAO,SAAS,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC;gBACvD,CAAC;YApBD,CAoBC;QArBD,CAqBC;IAtBD,CAsBC;AAvBD,CAuBC,CAAC;AAzBO,QAAA,oBAAoB,wBAyB3B;AAEN,IAAM,SAAS,GAAG,UAAC,IAAiB;IAChC,OAAC,IAA4B,CAAC,IAAI,KAAK,QAAQ;AAA/C,CAA+C,CAAC;AAEpD,IAAM,SAAS,GAAG,UAAC,IAAiB;IAChC,OAAA,KAAK,CAAC,OAAO,CAAE,IAA2B,CAAC,KAAK,CAAC;AAAjD,CAAiD,CAAC;AAEtD,IAAM,OAAO,GACT,UAAC,OAAsB;IACvB,OAAA,UAAC,IAAc;QACX,IAAI,OAAO,CAAC,GAAG,CAAC,IAAI,CAAC;YAAE,OAAO,KAAK,CAAC;QACpC,OAAO,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;QAElB,OAAO,CACH,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,UAAC,IAAI,IAAK,OAAA,IAAI,KAAK,MAAM,EAAf,CAAe,CAAC;YAC5C,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,UAAC,KAAK,IAAK,OAAA,OAAO,CAAC,OAAO,CAAC,CAAC,KAAK,CAAC,IAAI,CAAC,KAAK,CAAC,EAAlC,CAAkC,CAAC;YAC/D,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,UAAC,KAAK;gBACnB,OAAA,KAAK,CAAC,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,OAAO,CAAC,OAAO,CAAC,CAAC;YAA1C,CAA0C,CAC7C;YACD,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,UAAC,KAAK,IAAK,OAAA,OAAO,CAAC,OAAO,CAAC,CAAC,KAAK,CAAC,KAAK,CAAC,EAA7B,CAA6B,CAAC,CAC9D,CAAC;IACN,CAAC;AAZD,CAYC,CAAC"}