sonamu 0.8.26 → 0.9.0

package/dist/template/implementations/queries.template.js

@@ -1,99 +1,94 @@
+import { Sonamu, init_sonamu } from "../../api/sonamu.js";
+import { ApiParamType, init_types } from "../../types/types.js";
+import { apiParamToTsCode, apiParamTypeToTsType, init_code_converters } from "../../api/code-converters.js";
+import { Template, init_template } from "../template.js";
 import inflection from "inflection";
 import { diff, unique } from "radashi";
-import { apiParamToTsCode, apiParamTypeToTsType } from "../../api/code-converters.js";
-import { Sonamu } from "../../api/sonamu.js";
-import { ApiParamType } from "../../types/types.js";
-import { Template } from "../template.js";
-export class Template__queries extends Template {
-    constructor(){
-        super("queries");
-    }
-    getTargetAndPath() {
-        const { dir } = Sonamu.config.api;
-        return {
-            target: `${dir}/src/application`,
-            path: `queries.generated.ts`
-        };
-    }
-    render({}) {
-        const { apis } = Sonamu.syncer;
-        // tanstack-query를 포함한 API만 필터링
-        const queryApis = apis.filter((api)=>api.options.clients?.includes("tanstack-query"));
-        // 모델별로 그룹화
-        const apisByModel = new Map();
-        for (const api of queryApis){
-            const modelName = api.modelName.replace(/Model$/, "").replace(/Frame$/, "");
-            if (!apisByModel.has(modelName)) {
-                apisByModel.set(modelName, []);
-            }
-            apisByModel.get(modelName)?.push(api);
-        }
-        const namespaces = [];
-        const importKeys = [];
-        let typeParamNames = [];
-        for (const [modelName, modelApis] of apisByModel){
-            const functions = [];
-            for (const api of modelApis){
-                // Context 제외한 파라미터
-                const paramsWithoutContext = api.parameters.filter((param)=>!ApiParamType.isContext(param.type) && !ApiParamType.isRefKnex(param.type) && !(param.optional === true && param.name.startsWith("_")));
-                // 타입 파라미터 이름 수집
-                typeParamNames = typeParamNames.concat(api.typeParameters.map((tp)=>tp.id));
-                // 타입 파라미터 정의
-                const typeParametersAsTsType = api.typeParameters.map((typeParam)=>{
-                    return apiParamTypeToTsType(typeParam, importKeys);
-                }).join(", ");
-                const typeParamsDef = typeParametersAsTsType ? `<${typeParametersAsTsType}>` : "";
-                // 파라미터 정의
-                const paramsDef = apiParamToTsCode(paramsWithoutContext, importKeys);
-                const paramNames = paramsWithoutContext.map((p)=>p.name).join(", ");
-                // serviceMethodName 계산 (services.template.ts와 동일한 로직)
-                const serviceMethodName = api.options.resourceName ? `get${inflection.camelize(api.options.resourceName)}` : api.methodName;
-                // SSRQuery 함수 생성 (함수명도 serviceMethodName 사용)
-                functions.push(`
+
+//#region src/template/implementations/queries.template.ts
+init_code_converters();
+init_sonamu();
+init_types();
+init_template();
+var Template__queries = class extends Template {
+	constructor() {
+		super("queries");
+	}
+	getTargetAndPath() {
+		const { dir } = Sonamu.config.api;
+		return {
+			target: `${dir}/src/application`,
+			path: `queries.generated.ts`
+		};
+	}
+	render({}) {
+		const { apis } = Sonamu.syncer;
+		const queryApis = apis.filter((api) => api.options.clients?.includes("tanstack-query"));
+		const apisByModel = new Map();
+		for (const api of queryApis) {
+			const modelName = api.modelName.replace(/Model$/, "").replace(/Frame$/, "");
+			if (!apisByModel.has(modelName)) {
+				apisByModel.set(modelName, []);
+			}
+			apisByModel.get(modelName)?.push(api);
+		}
+		const namespaces = [];
+		const importKeys = [];
+		let typeParamNames = [];
+		for (const [modelName, modelApis] of apisByModel) {
+			const functions = [];
+			for (const api of modelApis) {
+				const paramsWithoutContext = api.parameters.filter((param) => !ApiParamType.isContext(param.type) && !ApiParamType.isRefKnex(param.type) && !(param.optional && param.name.startsWith("_")));
+				typeParamNames = typeParamNames.concat(api.typeParameters.map((tp) => tp.id));
+				const typeParametersAsTsType = api.typeParameters.map((typeParam) => {
+					return apiParamTypeToTsType(typeParam, importKeys);
+				}).join(", ");
+				const typeParamsDef = typeParametersAsTsType ? `<${typeParametersAsTsType}>` : "";
+				const paramsDef = apiParamToTsCode(paramsWithoutContext, importKeys);
+				const paramNames = paramsWithoutContext.map((p) => p.name).join(", ");
+				const serviceMethodName = api.options.resourceName ? `get${inflection.camelize(api.options.resourceName)}` : api.methodName;
+				functions.push(`
   export const ${serviceMethodName} = ${typeParamsDef}(${paramsDef}): SSRQuery =>
     createSSRQuery('${api.modelName}', '${api.methodName}', [${paramNames}], ['${modelName}', '${serviceMethodName}']);
           `.trim());
-            }
-            namespaces.push(`
+			}
+			namespaces.push(`
 export namespace ${modelName}Service {
 ${functions.join("\n\n")}
 }
       `.trim());
-        }
-        // tanstack-query API가 없으면 헬퍼 함수와 import를 포함하지 않습니다.
-        // 새 프로젝트에서 첫 빌드 시 sync가 아직 안 되어 namespace가 비어있을 수 있고,
-        // 이때 createSSRQuery가 unused로 빌드 에러가 발생하는 것을 방지합니다.
-        const hasQueries = namespaces.length > 0;
-        return {
-            ...this.getTargetAndPath(),
-            body: namespaces.join("\n\n"),
-            importKeys: diff(unique(importKeys), typeParamNames),
-            customHeaders: hasQueries ? [
-                "/**",
-                " * @generated",
-                " * 직접 수정하지 마세요.",
-                " */",
-                "/** biome-ignore-all lint: generated는 무시 */",
-                "/** biome-ignore-all assist: generated는 무시 */",
-                "",
-                `import type { SSRQuery } from 'sonamu/ssr';`,
-                "",
-                `// SSRQuery 헬퍼 함수`,
-                `function createSSRQuery(modelName: string, methodName: string, params: any[], serviceKey: [string, string]): SSRQuery {`,
-                `  return { modelName, methodName, params, serviceKey, __brand: 'SSRQuery' } as SSRQuery;`,
-                `}`,
-                ""
-            ] : [
-                "/**",
-                " * @generated",
-                " * 직접 수정하지 마세요.",
-                " */",
-                "/** biome-ignore-all lint: generated는 무시 */",
-                "/** biome-ignore-all assist: generated는 무시 */",
-                ""
-            ]
-        };
-    }
-}
+		}
+		const hasQueries = namespaces.length > 0;
+		return {
+			...this.getTargetAndPath(),
+			body: namespaces.join("\n\n"),
+			importKeys: diff(unique(importKeys), typeParamNames),
+			customHeaders: hasQueries ? [
+				"/**",
+				" * @generated",
+				" * 직접 수정하지 마세요.",
+				" */",
+				"/* oxlint-disable */",
+				"",
+				`import type { SSRQuery } from 'sonamu/ssr';`,
+				"",
+				`// SSRQuery 헬퍼 함수`,
+				`function createSSRQuery(modelName: string, methodName: string, params: any[], serviceKey: [string, string]): SSRQuery {`,
+				`  return { modelName, methodName, params, serviceKey, __brand: 'SSRQuery' } as SSRQuery;`,
+				`}`,
+				""
+			] : [
+				"/**",
+				" * @generated",
+				" * 직접 수정하지 마세요.",
+				" */",
+				"/* oxlint-disable */",
+				""
+			]
+		};
+	}
+};
 
-//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../src/template/implementations/queries.template.ts"],"sourcesContent":["import inflection from \"inflection\";\nimport { diff, unique } from \"radashi\";\nimport { apiParamToTsCode, apiParamTypeToTsType } from \"../../api/code-converters\";\nimport type { ExtendedApi } from \"../../api/decorators\";\nimport { Sonamu } from \"../../api/sonamu\";\nimport type { TemplateOptions } from \"../../types/types\";\nimport { ApiParamType } from \"../../types/types\";\nimport { Template } from \"../template\";\n\nexport class Template__queries extends Template {\n  constructor() {\n    super(\"queries\");\n  }\n\n  getTargetAndPath() {\n    const { dir } = Sonamu.config.api;\n    return {\n      target: `${dir}/src/application`,\n      path: `queries.generated.ts`,\n    };\n  }\n\n  render({}: TemplateOptions[\"queries\"]) {\n    const { apis } = Sonamu.syncer;\n\n    // tanstack-query를 포함한 API만 필터링\n    const queryApis = apis.filter((api) => api.options.clients?.includes(\"tanstack-query\"));\n\n    // 모델별로 그룹화\n    const apisByModel = new Map<string, ExtendedApi[]>();\n    for (const api of queryApis) {\n      const modelName = api.modelName.replace(/Model$/, \"\").replace(/Frame$/, \"\");\n      if (!apisByModel.has(modelName)) {\n        apisByModel.set(modelName, []);\n      }\n      apisByModel.get(modelName)?.push(api);\n    }\n\n    const namespaces: string[] = [];\n    const importKeys: string[] = [];\n    let typeParamNames: string[] = [];\n\n    for (const [modelName, modelApis] of apisByModel) {\n      const functions: string[] = [];\n\n      for (const api of modelApis) {\n        // Context 제외한 파라미터\n        const paramsWithoutContext = api.parameters.filter(\n          (param) =>\n            !ApiParamType.isContext(param.type) &&\n            !ApiParamType.isRefKnex(param.type) &&\n            !(param.optional === true && param.name.startsWith(\"_\")),\n        );\n\n        // 타입 파라미터 이름 수집\n        typeParamNames = typeParamNames.concat(api.typeParameters.map((tp) => tp.id));\n\n        // 타입 파라미터 정의\n        const typeParametersAsTsType = api.typeParameters\n          .map((typeParam) => {\n            return apiParamTypeToTsType(typeParam, importKeys);\n          })\n          .join(\", \");\n        const typeParamsDef = typeParametersAsTsType ? `<${typeParametersAsTsType}>` : \"\";\n\n        // 파라미터 정의\n        const paramsDef = apiParamToTsCode(paramsWithoutContext, importKeys);\n        const paramNames = paramsWithoutContext.map((p) => p.name).join(\", \");\n\n        // serviceMethodName 계산 (services.template.ts와 동일한 로직)\n        const serviceMethodName = api.options.resourceName\n          ? `get${inflection.camelize(api.options.resourceName)}`\n          : api.methodName;\n\n        // SSRQuery 함수 생성 (함수명도 serviceMethodName 사용)\n        functions.push(\n          `\n  export const ${serviceMethodName} = ${typeParamsDef}(${paramsDef}): SSRQuery =>\n    createSSRQuery('${api.modelName}', '${api.methodName}', [${paramNames}], ['${modelName}', '${serviceMethodName}']);\n          `.trim(),\n        );\n      }\n\n      namespaces.push(\n        `\nexport namespace ${modelName}Service {\n${functions.join(\"\\n\\n\")}\n}\n      `.trim(),\n      );\n    }\n\n    // tanstack-query API가 없으면 헬퍼 함수와 import를 포함하지 않습니다.\n    // 새 프로젝트에서 첫 빌드 시 sync가 아직 안 되어 namespace가 비어있을 수 있고,\n    // 이때 createSSRQuery가 unused로 빌드 에러가 발생하는 것을 방지합니다.\n    const hasQueries = namespaces.length > 0;\n\n    return {\n      ...this.getTargetAndPath(),\n      body: namespaces.join(\"\\n\\n\"),\n      importKeys: diff(unique(importKeys), typeParamNames),\n      customHeaders: hasQueries\n        ? [\n            \"/**\",\n            \" * @generated\",\n            \" * 직접 수정하지 마세요.\",\n            \" */\",\n            \"/** biome-ignore-all lint: generated는 무시 */\",\n            \"/** biome-ignore-all assist: generated는 무시 */\",\n            \"\",\n            `import type { SSRQuery } from 'sonamu/ssr';`,\n            \"\",\n            `// SSRQuery 헬퍼 함수`,\n            `function createSSRQuery(modelName: string, methodName: string, params: any[], serviceKey: [string, string]): SSRQuery {`,\n            `  return { modelName, methodName, params, serviceKey, __brand: 'SSRQuery' } as SSRQuery;`,\n            `}`,\n            \"\",\n          ]\n        : [\n            \"/**\",\n            \" * @generated\",\n            \" * 직접 수정하지 마세요.\",\n            \" */\",\n            \"/** biome-ignore-all lint: generated는 무시 */\",\n            \"/** biome-ignore-all assist: generated는 무시 */\",\n            \"\",\n          ],\n    };\n  }\n}\n"],"names":["inflection","diff","unique","apiParamToTsCode","apiParamTypeToTsType","Sonamu","ApiParamType","Template","Template__queries","getTargetAndPath","dir","config","api","target","path","render","apis","syncer","queryApis","filter","options","clients","includes","apisByModel","Map","modelName","replace","has","set","get","push","namespaces","importKeys","typeParamNames","modelApis","functions","paramsWithoutContext","parameters","param","isContext","type","isRefKnex","optional","name","startsWith","concat","typeParameters","map","tp","id","typeParametersAsTsType","typeParam","join","typeParamsDef","paramsDef","paramNames","p","serviceMethodName","resourceName","camelize","methodName","trim","hasQueries","length","body","customHeaders"],"mappings":"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"}
+//#endregion
+export { Template__queries };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"queries.template.js","names":["namespaces: string[]","importKeys: string[]","typeParamNames: string[]","functions: string[]"],"sources":["../../../src/template/implementations/queries.template.ts"],"sourcesContent":["import inflection from \"inflection\";\nimport { diff, unique } from \"radashi\";\n\nimport { apiParamToTsCode, apiParamTypeToTsType } from \"../../api/code-converters\";\nimport { type ExtendedApi } from \"../../api/decorators\";\nimport { Sonamu } from \"../../api/sonamu\";\nimport { type TemplateOptions } from \"../../types/types\";\nimport { ApiParamType } from \"../../types/types\";\nimport { Template } from \"../template\";\n\nexport class Template__queries extends Template {\n  constructor() {\n    super(\"queries\");\n  }\n\n  getTargetAndPath() {\n    const { dir } = Sonamu.config.api;\n    return {\n      target: `${dir}/src/application`,\n      path: `queries.generated.ts`,\n    };\n  }\n\n  render({}: TemplateOptions[\"queries\"]) {\n    const { apis } = Sonamu.syncer;\n\n    // tanstack-query를 포함한 API만 필터링\n    const queryApis = apis.filter((api) => api.options.clients?.includes(\"tanstack-query\"));\n\n    // 모델별로 그룹화\n    const apisByModel = new Map<string, ExtendedApi[]>();\n    for (const api of queryApis) {\n      const modelName = api.modelName.replace(/Model$/, \"\").replace(/Frame$/, \"\");\n      if (!apisByModel.has(modelName)) {\n        apisByModel.set(modelName, []);\n      }\n      apisByModel.get(modelName)?.push(api);\n    }\n\n    const namespaces: string[] = [];\n    const importKeys: string[] = [];\n    let typeParamNames: string[] = [];\n\n    for (const [modelName, modelApis] of apisByModel) {\n      const functions: string[] = [];\n\n      for (const api of modelApis) {\n        // Context 제외한 파라미터\n        const paramsWithoutContext = api.parameters.filter(\n          (param) =>\n            !ApiParamType.isContext(param.type) &&\n            !ApiParamType.isRefKnex(param.type) &&\n            !(param.optional && param.name.startsWith(\"_\")),\n        );\n\n        // 타입 파라미터 이름 수집\n        typeParamNames = typeParamNames.concat(api.typeParameters.map((tp) => tp.id));\n\n        // 타입 파라미터 정의\n        const typeParametersAsTsType = api.typeParameters\n          .map((typeParam) => {\n            return apiParamTypeToTsType(typeParam, importKeys);\n          })\n          .join(\", \");\n        const typeParamsDef = typeParametersAsTsType ? `<${typeParametersAsTsType}>` : \"\";\n\n        // 파라미터 정의\n        const paramsDef = apiParamToTsCode(paramsWithoutContext, importKeys);\n        const paramNames = paramsWithoutContext.map((p) => p.name).join(\", \");\n\n        // serviceMethodName 계산 (services.template.ts와 동일한 로직)\n        const serviceMethodName = api.options.resourceName\n          ? `get${inflection.camelize(api.options.resourceName)}`\n          : api.methodName;\n\n        // SSRQuery 함수 생성 (함수명도 serviceMethodName 사용)\n        functions.push(\n          `\n  export const ${serviceMethodName} = ${typeParamsDef}(${paramsDef}): SSRQuery =>\n    createSSRQuery('${api.modelName}', '${api.methodName}', [${paramNames}], ['${modelName}', '${serviceMethodName}']);\n          `.trim(),\n        );\n      }\n\n      namespaces.push(\n        `\nexport namespace ${modelName}Service {\n${functions.join(\"\\n\\n\")}\n}\n      `.trim(),\n      );\n    }\n\n    // tanstack-query API가 없으면 헬퍼 함수와 import를 포함하지 않습니다.\n    // 새 프로젝트에서 첫 빌드 시 sync가 아직 안 되어 namespace가 비어있을 수 있고,\n    // 이때 createSSRQuery가 unused로 빌드 에러가 발생하는 것을 방지합니다.\n    const hasQueries = namespaces.length > 0;\n\n    return {\n      ...this.getTargetAndPath(),\n      body: namespaces.join(\"\\n\\n\"),\n      importKeys: diff(unique(importKeys), typeParamNames),\n      customHeaders: hasQueries\n        ? [\n            \"/**\",\n            \" * @generated\",\n            \" * 직접 수정하지 마세요.\",\n            \" */\",\n            \"/* oxlint-disable */\",\n            \"\",\n            `import type { SSRQuery } from 'sonamu/ssr';`,\n            \"\",\n            `// SSRQuery 헬퍼 함수`,\n            `function createSSRQuery(modelName: string, methodName: string, params: any[], serviceKey: [string, string]): SSRQuery {`,\n            `  return { modelName, methodName, params, serviceKey, __brand: 'SSRQuery' } as SSRQuery;`,\n            `}`,\n            \"\",\n          ]\n        : [\"/**\", \" * @generated\", \" * 직접 수정하지 마세요.\", \" */\", \"/* oxlint-disable */\", \"\"],\n    };\n  }\n}\n"],"mappings":";;;;;;;;sBAGmF;aAEzC;YAEO;eACV;AAEvC,IAAa,oBAAb,cAAuC,SAAS;CAC9C,cAAc;AACZ,QAAM,UAAU;;CAGlB,mBAAmB;EACjB,MAAM,EAAE,QAAQ,OAAO,OAAO;AAC9B,SAAO;GACL,QAAQ,GAAG,IAAI;GACf,MAAM;GACP;;CAGH,OAAO,IAAgC;EACrC,MAAM,EAAE,SAAS,OAAO;EAGxB,MAAM,YAAY,KAAK,QAAQ,QAAQ,IAAI,QAAQ,SAAS,SAAS,iBAAiB,CAAC;EAGvF,MAAM,cAAc,IAAI,KAA4B;AACpD,OAAK,MAAM,OAAO,WAAW;GAC3B,MAAM,YAAY,IAAI,UAAU,QAAQ,UAAU,GAAG,CAAC,QAAQ,UAAU,GAAG;AAC3E,OAAI,CAAC,YAAY,IAAI,UAAU,EAAE;AAC/B,gBAAY,IAAI,WAAW,EAAE,CAAC;;AAEhC,eAAY,IAAI,UAAU,EAAE,KAAK,IAAI;;EAGvC,MAAMA,aAAuB,EAAE;EAC/B,MAAMC,aAAuB,EAAE;EAC/B,IAAIC,iBAA2B,EAAE;AAEjC,OAAK,MAAM,CAAC,WAAW,cAAc,aAAa;GAChD,MAAMC,YAAsB,EAAE;AAE9B,QAAK,MAAM,OAAO,WAAW;IAE3B,MAAM,uBAAuB,IAAI,WAAW,QACzC,UACC,CAAC,aAAa,UAAU,MAAM,KAAK,IACnC,CAAC,aAAa,UAAU,MAAM,KAAK,IACnC,EAAE,MAAM,YAAY,MAAM,KAAK,WAAW,IAAI,EACjD;AAGD,qBAAiB,eAAe,OAAO,IAAI,eAAe,KAAK,OAAO,GAAG,GAAG,CAAC;IAG7E,MAAM,yBAAyB,IAAI,eAChC,KAAK,cAAc;AAClB,YAAO,qBAAqB,WAAW,WAAW;MAClD,CACD,KAAK,KAAK;IACb,MAAM,gBAAgB,yBAAyB,IAAI,uBAAuB,KAAK;IAG/E,MAAM,YAAY,iBAAiB,sBAAsB,WAAW;IACpE,MAAM,aAAa,qBAAqB,KAAK,MAAM,EAAE,KAAK,CAAC,KAAK,KAAK;IAGrE,MAAM,oBAAoB,IAAI,QAAQ,eAClC,MAAM,WAAW,SAAS,IAAI,QAAQ,aAAa,KACnD,IAAI;AAGR,cAAU,KACR;iBACO,kBAAkB,KAAK,cAAc,GAAG,UAAU;sBAC7C,IAAI,UAAU,MAAM,IAAI,WAAW,MAAM,WAAW,OAAO,UAAU,MAAM,kBAAkB;YACvG,MAAM,CACT;;AAGH,cAAW,KACT;mBACW,UAAU;EAC3B,UAAU,KAAK,OAAO,CAAC;;QAEjB,MAAM,CACP;;EAMH,MAAM,aAAa,WAAW,SAAS;AAEvC,SAAO;GACL,GAAG,KAAK,kBAAkB;GAC1B,MAAM,WAAW,KAAK,OAAO;GAC7B,YAAY,KAAK,OAAO,WAAW,EAAE,eAAe;GACpD,eAAe,aACX;IACE;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACD,GACD;IAAC;IAAO;IAAiB;IAAmB;IAAO;IAAwB;IAAG;GACnF"}

package/dist/template/implementations/sd.template.d.ts

@@ -1,5 +1,5 @@
 import { type EntityNamesRecord } from "../../entity/entity-manager";
-import type { TemplateOptions } from "../../types/types";
+import { type TemplateOptions } from "../../types/types";
 import { Template } from "../template";
 /**
  * Sonamu Dictionary (SD) 템플릿

package/dist/template/implementations/sd.template.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"sd.template.d.ts","sourceRoot":"","sources":["../../../src/template/implementations/sd.template.ts"],"names":[],"mappings":"AAIA,OAAO,EAAiB,KAAK,iBAAiB,EAAE,MAAM,6BAA6B,CAAC;AACpF,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAC;AAEzD,OAAO,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;AAEvC;;;GAGG;AACH,qBAAa,YAAa,SAAQ,QAAQ;;IAKxC,gBAAgB,CAAC,MAAM,CAAC,EAAE,iBAAiB,EAAE,QAAQ,CAAC,EAAE,KAAK,GAAG,KAAK,GAAG,KAAK;;;;IAW7E,MAAM,CAAC,OAAO,EAAE,eAAe,CAAC,IAAI,CAAC;;;;;;;IAiOrC;;;OAGG;IACH,OAAO,CAAC,uBAAuB;IAoC/B;;;;;;OAMG;IACH,OAAO,CAAC,mBAAmB;IAiC3B;;OAEG;IACH,OAAO,CAAC,wBAAwB;IAYhC,OAAO,CAAC,YAAY;CAGrB"}
+{"version":3,"file":"sd.template.d.ts","sourceRoot":"","sources":["../../../src/template/implementations/sd.template.ts"],"names":[],"mappings":"AAMA,OAAO,EAAE,KAAK,iBAAiB,EAAE,MAAM,6BAA6B,CAAC;AACrE,OAAO,EAAE,KAAK,eAAe,EAAE,MAAM,mBAAmB,CAAC;AAEzD,OAAO,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;AAEvC;;;GAGG;AACH,qBAAa,YAAa,SAAQ,QAAQ;;IAKxC,gBAAgB,CAAC,MAAM,CAAC,EAAE,iBAAiB,EAAE,QAAQ,CAAC,EAAE,KAAK,GAAG,KAAK,GAAG,KAAK;;;;IAW7E,MAAM,CAAC,OAAO,EAAE,eAAe,CAAC,IAAI,CAAC;;;;;;;IAiOrC;;;OAGG;IACH,OAAO,CAAC,uBAAuB;IAoC/B;;;;;;OAMG;IACH,OAAO,CAAC,mBAAmB;IAiC3B;;OAEG;IACH,OAAO,CAAC,wBAAwB;IAYhC,OAAO,CAAC,YAAY;CAGrB"}