@prisma-next/sql-contract-emitter 0.3.0-dev.15 → 0.3.0-dev.162

package/src/index.ts

@@ -1,23 +1,38 @@
-import type { ContractIR } from '@prisma-next/contract/ir';
-import type { TypesImportSpec, ValidationContext } from '@prisma-next/contract/types';
+import type { Contract, ContractModel } from '@prisma-next/contract/types';
+import {
+  generateCodecTypeIntersection,
+  serializeObjectKey,
+  serializeValue,
+} from '@prisma-next/emitter/domain-type-generation';
 import type {
-  ModelDefinition,
-  ModelField,
-  SqlStorage,
-  StorageTable,
-} from '@prisma-next/sql-contract/types';
-
-export const sqlTargetFamilyHook = {
+  GenerateContractTypesOptions,
+  ValidationContext,
+} from '@prisma-next/framework-components/emission';
+import type { SqlModelStorage, SqlStorage, StorageTable } from '@prisma-next/sql-contract/types';
+import { assertDefined } from '@prisma-next/utils/assertions';
+
+function serializeTypeParamsLiteral(params: Record<string, unknown> | undefined): string {
+  if (!params || Object.keys(params).length === 0) {
+    return 'Record<string, never>';
+  }
+
+  const entries: string[] = [];
+  for (const [key, value] of Object.entries(params)) {
+    entries.push(`readonly ${serializeObjectKey(key)}: ${serializeValue(value)}`);
+  }
+
+  return `{ ${entries.join('; ')} }`;
+}
+
+export const sqlEmission = {
   id: 'sql',
 
-  validateTypes(ir: ContractIR, _ctx: ValidationContext): void {
-    const storage = ir.storage as SqlStorage | undefined;
+  validateTypes(contract: Contract, _ctx: ValidationContext): void {
+    const storage = contract.storage as unknown as SqlStorage | undefined;
     if (!storage || !storage.tables) {
       return;
     }
 
-    // Validate codec ID format (ns/name@version). Adapter-provided codecs are available regardless of contract.extensionPacks (which is for framework extensions); TypeScript prevents invalid usage and runtime validates availability.
-
     const typeIdRegex = /^([^/]+)\/([^@]+)@(\d+)$/;
 
     for (const [tableName, tableUnknown] of Object.entries(storage.tables)) {
@@ -39,22 +54,21 @@ export const sqlTargetFamilyHook = {
     }
   },
 
-  validateStructure(ir: ContractIR): void {
-    if (ir.targetFamily !== 'sql') {
-      throw new Error(`Expected targetFamily "sql", got "${ir.targetFamily}"`);
+  validateStructure(contract: Contract): void {
+    if (contract.targetFamily !== 'sql') {
+      throw new Error(`Expected targetFamily "sql", got "${contract.targetFamily}"`);
     }
 
-    const storage = ir.storage as SqlStorage | undefined;
+    const storage = contract.storage as unknown as SqlStorage | undefined;
     if (!storage || !storage.tables) {
       throw new Error('SQL contract must have storage.tables');
     }
 
-    const models = ir.models as Record<string, ModelDefinition> | undefined;
+    const models = contract.models as Record<string, ContractModel<SqlModelStorage>>;
     const tableNames = new Set(Object.keys(storage.tables));
 
     if (models) {
-      for (const [modelName, modelUnknown] of Object.entries(models)) {
-        const model = modelUnknown as ModelDefinition;
+      for (const [modelName, model] of Object.entries(models)) {
         if (!model.storage?.table) {
           throw new Error(`Model "${modelName}" is missing storage.table`);
         }
@@ -64,22 +78,20 @@ export const sqlTargetFamilyHook = {
           throw new Error(`Model "${modelName}" references non-existent table "${tableName}"`);
         }
 
-        const table = storage.tables[tableName];
-        if (!table) {
-          throw new Error(`Model "${modelName}" references non-existent table "${tableName}"`);
-        }
+        const table: StorageTable | undefined = storage.tables[tableName];
+        assertDefined(table, `Model "${modelName}" references non-existent table "${tableName}"`);
 
         if (!table.primaryKey) {
           throw new Error(`Model "${modelName}" table "${tableName}" is missing a primary key`);
         }
 
         const columnNames = new Set(Object.keys(table.columns));
-        if (!model.fields || Object.keys(model.fields).length === 0) {
-          throw new Error(`Model "${modelName}" is missing fields`);
+        const storageFields = model.storage.fields;
+        if (!storageFields || Object.keys(storageFields).length === 0) {
+          throw new Error(`Model "${modelName}" is missing storage.fields`);
         }
 
-        for (const [fieldName, fieldUnknown] of Object.entries(model.fields)) {
-          const field = fieldUnknown as ModelField;
+        for (const [fieldName, field] of Object.entries(storageFields)) {
           if (!field.column) {
             throw new Error(`Model "${modelName}" field "${fieldName}" is missing column property`);
           }
@@ -103,10 +115,6 @@ export const sqlTargetFamilyHook = {
       const table = tableUnknown as StorageTable;
       const columnNames = new Set(Object.keys(table.columns));
 
-      // Column structure (nullable, nativeType, codecId) and table arrays (uniques, indexes, foreignKeys)
-      // are validated by Arktype schema validation - no need to re-check here.
-      // We only validate logical consistency (foreign key references, model references, etc.)
-
       if (!Array.isArray(table.uniques)) {
         throw new Error(
           `Table "${tableName}" is missing required field "uniques" (must be an array)`,
@@ -168,12 +176,11 @@ export const sqlTargetFamilyHook = {
           );
         }
 
-        const referencedTable = storage.tables[fk.references.table];
-        if (!referencedTable) {
-          throw new Error(
-            `Table "${tableName}" foreignKey references non-existent table "${fk.references.table}"`,
-          );
-        }
+        const referencedTable: StorageTable | undefined = storage.tables[fk.references.table];
+        assertDefined(
+          referencedTable,
+          `Table "${tableName}" foreignKey references non-existent table "${fk.references.table}"`,
+        );
 
         const referencedColumnNames = new Set(Object.keys(referencedTable.columns));
         for (const colName of fk.references.columns) {
@@ -193,76 +200,50 @@ export const sqlTargetFamilyHook = {
     }
   },
 
-  generateContractTypes(
-    ir: ContractIR,
-    codecTypeImports: ReadonlyArray<TypesImportSpec>,
-    operationTypeImports: ReadonlyArray<TypesImportSpec>,
-  ): string {
-    const allImports = [...codecTypeImports, ...operationTypeImports];
-    const importLines = allImports.map(
-      (imp) => `import type { ${imp.named} as ${imp.alias} } from '${imp.package}';`,
-    );
-
-    const codecTypes = codecTypeImports.map((imp) => imp.alias).join(' & ');
-    const operationTypes = operationTypeImports.map((imp) => imp.alias).join(' & ');
-
-    const storage = ir.storage as SqlStorage;
-    const models = ir.models as Record<string, ModelDefinition>;
-
-    const storageType = this.generateStorageType(storage);
-    const modelsType = this.generateModelsType(models, storage);
-    const relationsType = this.generateRelationsType(ir.relations);
-    const mappingsType = this.generateMappingsType(models, storage, codecTypes, operationTypes);
-
-    return `// ⚠️  GENERATED FILE - DO NOT EDIT
-// This file is automatically generated by 'prisma-next contract emit'.
-// To regenerate, run: prisma-next contract emit
-${importLines.join('\n')}
-
-import type { SqlContract, SqlStorage, SqlMappings, ModelDefinition } from '@prisma-next/sql-contract/types';
-
-export type CodecTypes = ${codecTypes || 'Record<string, never>'};
-export type LaneCodecTypes = CodecTypes;
-export type OperationTypes = ${operationTypes || 'Record<string, never>'};
-
-export type Contract = SqlContract<
-  ${storageType},
-  ${modelsType},
-  ${relationsType},
-  ${mappingsType}
->;
-
-export type Tables = Contract['storage']['tables'];
-export type Models = Contract['models'];
-export type Relations = Contract['relations'];
-`;
-  },
-
-  generateStorageType(storage: SqlStorage): string {
+  generateStorageType(contract: Contract, storageHashTypeName: string): string {
+    const storage = contract.storage as unknown as SqlStorage;
     const tables: string[] = [];
-    for (const [tableName, table] of Object.entries(storage.tables)) {
+    for (const [tableName, table] of Object.entries(storage.tables).sort(([a], [b]) =>
+      a.localeCompare(b),
+    )) {
       const columns: string[] = [];
       for (const [colName, col] of Object.entries(table.columns)) {
         const nullable = col.nullable ? 'true' : 'false';
-        const nativeType = `'${col.nativeType}'`;
-        const codecId = `'${col.codecId}'`;
+        const nativeType = serializeValue(col.nativeType);
+        const codecId = serializeValue(col.codecId);
+        const defaultSpec = col.default
+          ? col.default.kind === 'literal'
+            ? `; readonly default: { readonly kind: 'literal'; readonly value: DefaultLiteralValue<${codecId}, ${serializeValue(
+                col.default.value,
+              )}> }`
+            : `; readonly default: { readonly kind: 'function'; readonly expression: ${serializeValue(
+                col.default.expression,
+              )} }`
+          : '';
+        const typeParamsSpec =
+          col.typeParams && Object.keys(col.typeParams).length > 0
+            ? `; readonly typeParams: ${serializeTypeParamsLiteral(col.typeParams)}`
+            : '';
+        const typeRefSpec = col.typeRef ? `; readonly typeRef: ${serializeValue(col.typeRef)}` : '';
         columns.push(
-          `readonly ${colName}: { readonly nativeType: ${nativeType}; readonly codecId: ${codecId}; readonly nullable: ${nullable} }`,
+          `readonly ${colName}: { readonly nativeType: ${nativeType}; readonly codecId: ${codecId}; readonly nullable: ${nullable}${defaultSpec}${typeParamsSpec}${typeRefSpec} }`,
         );
       }
 
       const tableParts: string[] = [`columns: { ${columns.join('; ')} }`];
 
       if (table.primaryKey) {
-        const pkCols = table.primaryKey.columns.map((c) => `'${c}'`).join(', ');
-        const pkName = table.primaryKey.name ? `; readonly name: '${table.primaryKey.name}'` : '';
+        const pkCols = table.primaryKey.columns.map((c) => serializeValue(c)).join(', ');
+        const pkName = table.primaryKey.name
+          ? `; readonly name: ${serializeValue(table.primaryKey.name)}`
+          : '';
         tableParts.push(`primaryKey: { readonly columns: readonly [${pkCols}]${pkName} }`);
       }
 
       const uniques = table.uniques
         .map((u) => {
-          const cols = u.columns.map((c: string) => `'${c}'`).join(', ');
-          const name = u.name ? `; readonly name: '${u.name}'` : '';
+          const cols = u.columns.map((c: string) => serializeValue(c)).join(', ');
+          const name = u.name ? `; readonly name: ${serializeValue(u.name)}` : '';
           return `{ readonly columns: readonly [${cols}]${name} }`;
         })
         .join(', ');
@@ -270,19 +251,22 @@ export type Relations = Contract['relations'];
 
       const indexes = table.indexes
         .map((i) => {
-          const cols = i.columns.map((c: string) => `'${c}'`).join(', ');
-          const name = i.name ? `; readonly name: '${i.name}'` : '';
-          return `{ readonly columns: readonly [${cols}]${name} }`;
+          const cols = i.columns.map((c: string) => serializeValue(c)).join(', ');
+          const name = i.name ? `; readonly name: ${serializeValue(i.name)}` : '';
+          const using = i.using !== undefined ? `; readonly using: ${serializeValue(i.using)}` : '';
+          const config =
+            i.config !== undefined ? `; readonly config: ${serializeValue(i.config)}` : '';
+          return `{ readonly columns: readonly [${cols}]${name}${using}${config} }`;
         })
         .join(', ');
       tableParts.push(`indexes: readonly [${indexes}]`);
 
       const fks = table.foreignKeys
         .map((fk) => {
-          const cols = fk.columns.map((c: string) => `'${c}'`).join(', ');
-          const refCols = fk.references.columns.map((c: string) => `'${c}'`).join(', ');
-          const name = fk.name ? `; readonly name: '${fk.name}'` : '';
-          return `{ readonly columns: readonly [${cols}]; readonly references: { readonly table: '${fk.references.table}'; readonly columns: readonly [${refCols}] }${name} }`;
+          const cols = fk.columns.map((c: string) => serializeValue(c)).join(', ');
+          const refCols = fk.references.columns.map((c: string) => serializeValue(c)).join(', ');
+          const name = fk.name ? `; readonly name: ${serializeValue(fk.name)}` : '';
+          return `{ readonly columns: readonly [${cols}]; readonly references: { readonly table: ${serializeValue(fk.references.table)}; readonly columns: readonly [${refCols}] }${name}; readonly constraint: ${fk.constraint}; readonly index: ${fk.index} }`;
         })
         .join(', ');
       tableParts.push(`foreignKeys: readonly [${fks}]`);
@@ -290,196 +274,84 @@ export type Relations = Contract['relations'];
       tables.push(`readonly ${tableName}: { ${tableParts.join('; ')} }`);
     }
 
-    return `{ readonly tables: { ${tables.join('; ')} } }`;
-  },
-
-  generateModelsType(
-    models: Record<string, ModelDefinition> | undefined,
-    storage: SqlStorage,
-  ): string {
-    if (!models) {
-      return 'Record<string, never>';
-    }
-
-    const modelTypes: string[] = [];
-    for (const [modelName, model] of Object.entries(models)) {
-      const fields: string[] = [];
-      const tableName = model.storage.table;
-      const table = storage.tables[tableName];
-
-      if (table) {
-        for (const [fieldName, field] of Object.entries(model.fields)) {
-          const column = table.columns[field.column];
-          if (!column) {
-            fields.push(`readonly ${fieldName}: { readonly column: '${field.column}' }`);
-            continue;
-          }
-
-          const typeId = column.codecId;
-          const nullable = column.nullable ?? false;
-          const jsType = nullable
-            ? `CodecTypes['${typeId}']['output'] | null`
-            : `CodecTypes['${typeId}']['output']`;
-
-          fields.push(`readonly ${fieldName}: ${jsType}`);
-        }
-      } else {
-        for (const [fieldName, field] of Object.entries(model.fields)) {
-          fields.push(`readonly ${fieldName}: { readonly column: '${field.column}' }`);
-        }
-      }
-
-      const relations: string[] = [];
-      for (const [relName, rel] of Object.entries(model.relations)) {
-        if (typeof rel === 'object' && rel !== null && 'on' in rel) {
-          const on = rel.on as { parentCols?: string[]; childCols?: string[] };
-          if (on.parentCols && on.childCols) {
-            const parentCols = on.parentCols.map((c) => `'${c}'`).join(', ');
-            const childCols = on.childCols.map((c) => `'${c}'`).join(', ');
-            relations.push(
-              `readonly ${relName}: { readonly on: { readonly parentCols: readonly [${parentCols}]; readonly childCols: readonly [${childCols}] } }`,
-            );
-          }
-        }
-      }
-
-      const modelParts: string[] = [
-        `storage: { readonly table: '${tableName}' }`,
-        `fields: { ${fields.join('; ')} }`,
-      ];
+    const typesType = generateStorageTypesType(storage.types);
 
-      if (relations.length > 0) {
-        modelParts.push(`relations: { ${relations.join('; ')} }`);
-      }
-
-      modelTypes.push(`readonly ${modelName}: { ${modelParts.join('; ')} }`);
-    }
-
-    return `{ ${modelTypes.join('; ')} }`;
+    return `{ readonly tables: { ${tables.join('; ')} }; readonly types: ${typesType}; readonly storageHash: ${storageHashTypeName} }`;
   },
 
-  generateRelationsType(relations: Record<string, unknown> | undefined): string {
-    if (!relations || Object.keys(relations).length === 0) {
-      return 'Record<string, never>';
-    }
-
-    const tableEntries: string[] = [];
-    for (const [tableName, relsValue] of Object.entries(relations)) {
-      if (typeof relsValue !== 'object' || relsValue === null) {
-        continue;
-      }
-      const rels = relsValue as Record<string, unknown>;
-      const relationEntries: string[] = [];
-      for (const [relName, relValue] of Object.entries(rels)) {
-        if (typeof relValue !== 'object' || relValue === null) {
-          relationEntries.push(`readonly ${relName}: unknown`);
-          continue;
-        }
-        const { to, cardinality, on, through } = relValue as {
-          readonly to?: string;
-          readonly cardinality?: string;
-          readonly on?: {
-            readonly parentCols?: readonly string[];
-            readonly childCols?: readonly string[];
-          };
-          readonly through?: {
-            readonly table: string;
-            readonly parentCols: readonly string[];
-            readonly childCols: readonly string[];
-          };
-        };
-
-        const parts: string[] = [];
-        if (to) {
-          parts.push(`readonly to: '${to}'`);
-        }
-        if (cardinality) {
-          parts.push(`readonly cardinality: '${cardinality}'`);
-        }
-        if (on?.parentCols && on.childCols) {
-          const parentCols = on.parentCols.map((c) => `'${c}'`).join(', ');
-          const childCols = on.childCols.map((c) => `'${c}'`).join(', ');
-          parts.push(
-            `readonly on: { readonly parentCols: readonly [${parentCols}]; readonly childCols: readonly [${childCols}] }`,
-          );
-        }
-        if (through) {
-          const parentCols = through.parentCols.map((c) => `'${c}'`).join(', ');
-          const childCols = through.childCols.map((c) => `'${c}'`).join(', ');
-          parts.push(
-            `readonly through: { readonly table: '${through.table}'; readonly parentCols: readonly [${parentCols}]; readonly childCols: readonly [${childCols}] }`,
-          );
-        }
-
-        relationEntries.push(
-          parts.length > 0
-            ? `readonly ${relName}: { ${parts.join('; ')} }`
-            : `readonly ${relName}: unknown`,
+  generateModelStorageType(_modelName: string, model: ContractModel): string {
+    const sqlModel = model as ContractModel<SqlModelStorage>;
+    const tableName = sqlModel.storage.table;
+    const storageFields = sqlModel.storage.fields;
+
+    const storageParts = [`readonly table: ${serializeValue(tableName)}`];
+    if (Object.keys(storageFields).length > 0) {
+      const fieldParts: string[] = [];
+      for (const [fieldName, field] of Object.entries(storageFields)) {
+        fieldParts.push(
+          `readonly ${serializeObjectKey(fieldName)}: { readonly column: ${serializeValue(field.column)} }`,
         );
       }
-      tableEntries.push(`readonly ${tableName}: { ${relationEntries.join('; ')} }`);
+      storageParts.push(`readonly fields: { ${fieldParts.join('; ')} }`);
     }
 
-    return `{ ${tableEntries.join('; ')} }`;
+    return `{ ${storageParts.join('; ')} }`;
   },
 
-  generateMappingsType(
-    models: Record<string, ModelDefinition> | undefined,
-    storage: SqlStorage,
-    codecTypes: string,
-    operationTypes: string,
-  ): string {
-    if (!models) {
-      return `SqlMappings & { readonly codecTypes: ${codecTypes || 'Record<string, never>'}; readonly operationTypes: ${operationTypes || 'Record<string, never>'}; }`;
-    }
-
-    const modelToTable: string[] = [];
-    const tableToModel: string[] = [];
-    const fieldToColumn: string[] = [];
-    const columnToField: string[] = [];
-
-    for (const [modelName, model] of Object.entries(models)) {
-      const tableName = model.storage.table;
-      modelToTable.push(`readonly ${modelName}: '${tableName}'`);
-      tableToModel.push(`readonly ${tableName}: '${modelName}'`);
-
-      const fieldMap: string[] = [];
-      for (const [fieldName, field] of Object.entries(model.fields)) {
-        fieldMap.push(`readonly ${fieldName}: '${field.column}'`);
-      }
-
-      if (fieldMap.length > 0) {
-        fieldToColumn.push(`readonly ${modelName}: { ${fieldMap.join('; ')} }`);
-      }
+  getFamilyImports(): string[] {
+    return [
+      'import type {',
+      '  ContractWithTypeMaps,',
+      '  TypeMaps as TypeMapsType,',
+      "} from '@prisma-next/sql-contract/types';",
+    ];
+  },
 
-      if (storage.tables[tableName]) {
-        const colMap: string[] = [];
-        for (const [fieldName, field] of Object.entries(model.fields)) {
-          colMap.push(`readonly ${field.column}: '${fieldName}'`);
-        }
+  getFamilyTypeAliases(options?: GenerateContractTypesOptions): string {
+    const queryOperationTypeImports = options?.queryOperationTypeImports ?? [];
+    const queryOperationTypes = generateCodecTypeIntersection(
+      queryOperationTypeImports,
+      'QueryOperationTypes',
+    );
 
-        if (colMap.length > 0) {
-          columnToField.push(`readonly ${tableName}: { ${colMap.join('; ')} }`);
-        }
-      }
-    }
+    return [
+      'export type LaneCodecTypes = CodecTypes;',
+      `export type QueryOperationTypes = ${queryOperationTypes};`,
+      'type DefaultLiteralValue<CodecId extends string, _Encoded> =',
+      '  CodecId extends keyof CodecTypes',
+      "    ? CodecTypes[CodecId]['output']",
+      '    : _Encoded;',
+    ].join('\n');
+  },
 
-    const parts: string[] = [];
-    if (modelToTable.length > 0) {
-      parts.push(`modelToTable: { ${modelToTable.join('; ')} }`);
-    }
-    if (tableToModel.length > 0) {
-      parts.push(`tableToModel: { ${tableToModel.join('; ')} }`);
-    }
-    if (fieldToColumn.length > 0) {
-      parts.push(`fieldToColumn: { ${fieldToColumn.join('; ')} }`);
-    }
-    if (columnToField.length > 0) {
-      parts.push(`columnToField: { ${columnToField.join('; ')} }`);
-    }
-    parts.push(`codecTypes: ${codecTypes || 'Record<string, never>'}`);
-    parts.push(`operationTypes: ${operationTypes || 'Record<string, never>'}`);
+  getTypeMapsExpression(): string {
+    return 'TypeMapsType<CodecTypes, OperationTypes, QueryOperationTypes, FieldOutputTypes, FieldInputTypes>';
+  },
 
-    return `{ ${parts.join('; ')} }`;
+  getContractWrapper(contractBaseName: string, typeMapsName: string): string {
+    return [
+      `export type Contract = ContractWithTypeMaps<${contractBaseName}, ${typeMapsName}>;`,
+      '',
+      "export type Tables = Contract['storage']['tables'];",
+      "export type Models = Contract['models'];",
+    ].join('\n');
   },
 } as const;
+
+function generateStorageTypesType(types: SqlStorage['types']): string {
+  if (!types || Object.keys(types).length === 0) {
+    return 'Record<string, never>';
+  }
+
+  const typeEntries: string[] = [];
+  for (const [typeName, typeInstance] of Object.entries(types)) {
+    const codecId = serializeValue(typeInstance.codecId);
+    const nativeType = serializeValue(typeInstance.nativeType);
+    const typeParamsStr = serializeTypeParamsLiteral(typeInstance.typeParams);
+    typeEntries.push(
+      `readonly ${typeName}: { readonly codecId: ${codecId}; readonly nativeType: ${nativeType}; readonly typeParams: ${typeParamsStr} }`,
+    );
+  }
+
+  return `{ ${typeEntries.join('; ')} }`;
+}

package/dist/index.d.ts

@@ -1,14 +0,0 @@
-import type { ContractIR } from '@prisma-next/contract/ir';
-import type { TypesImportSpec, ValidationContext } from '@prisma-next/contract/types';
-import type { ModelDefinition, SqlStorage } from '@prisma-next/sql-contract/types';
-export declare const sqlTargetFamilyHook: {
-    readonly id: "sql";
-    readonly validateTypes: (ir: ContractIR, _ctx: ValidationContext) => void;
-    readonly validateStructure: (ir: ContractIR) => void;
-    readonly generateContractTypes: (ir: ContractIR, codecTypeImports: ReadonlyArray<TypesImportSpec>, operationTypeImports: ReadonlyArray<TypesImportSpec>) => string;
-    readonly generateStorageType: (storage: SqlStorage) => string;
-    readonly generateModelsType: (models: Record<string, ModelDefinition> | undefined, storage: SqlStorage) => string;
-    readonly generateRelationsType: (relations: Record<string, unknown> | undefined) => string;
-    readonly generateMappingsType: (models: Record<string, ModelDefinition> | undefined, storage: SqlStorage, codecTypes: string, operationTypes: string) => string;
-};
-//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,0BAA0B,CAAC;AAC3D,OAAO,KAAK,EAAE,eAAe,EAAE,iBAAiB,EAAE,MAAM,6BAA6B,CAAC;AACtF,OAAO,KAAK,EACV,eAAe,EAEf,UAAU,EAEX,MAAM,iCAAiC,CAAC;AAEzC,eAAO,MAAM,mBAAmB;;iCAGZ,UAAU,QAAQ,iBAAiB,KAAG,IAAI;qCA6BtC,UAAU,KAAG,IAAI;yCA2JjC,UAAU,oBACI,aAAa,CAAC,eAAe,CAAC,wBAC1B,aAAa,CAAC,eAAe,CAAC,KACnD,MAAM;4CAyCoB,UAAU,KAAG,MAAM;0CAwDtC,MAAM,CAAC,MAAM,EAAE,eAAe,CAAC,GAAG,SAAS,WAC1C,UAAU,KAClB,MAAM;gDA8DwB,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,SAAS,KAAG,MAAM;4CAkEnE,MAAM,CAAC,MAAM,EAAE,eAAe,CAAC,GAAG,SAAS,WAC1C,UAAU,cACP,MAAM,kBACF,MAAM,KACrB,MAAM;CAsDD,CAAC"}