@prisma-next/adapter-postgres 0.14.0-dev.9 → 0.14.0-dev.90

package/src/core/control-mutation-defaults.ts

@@ -5,16 +5,18 @@ import type {
   DefaultFunctionLoweringContext,
   LoweredDefaultResult,
   MutationDefaultGeneratorDescriptor,
-  ParsedDefaultFunctionCall,
+  TypedDefaultFunctionCall,
 } from '@prisma-next/framework-components/control';
 import {
   builtinGeneratorRegistryMetadata,
   resolveBuiltinGeneratedColumnDescriptor,
 } from '@prisma-next/ids';
+import type { FuncCallSig } from '@prisma-next/psl-parser';
+import { int, num, oneOf, optional, str } from '@prisma-next/psl-parser';
 
 function invalidArgumentDiagnostic(input: {
   readonly context: DefaultFunctionLoweringContext;
-  readonly span: ParsedDefaultFunctionCall['span'];
+  readonly span: TypedDefaultFunctionCall['span'];
   readonly message: string;
 }): LoweredDefaultResult {
   return {
@@ -45,218 +47,62 @@ function executionGenerator(
   };
 }
 
-function expectNoArgs(input: {
-  readonly call: ParsedDefaultFunctionCall;
-  readonly context: DefaultFunctionLoweringContext;
-  readonly usage: string;
-}): LoweredDefaultResult | undefined {
-  if (input.call.args.length === 0) {
-    return undefined;
-  }
-  return invalidArgumentDiagnostic({
-    context: input.context,
-    span: input.call.span,
-    message: `Default function "${input.call.name}" does not accept arguments. Use ${input.usage}.`,
-  });
-}
-
-function parseIntegerArgument(raw: string): number | undefined {
-  const trimmed = raw.trim();
-  if (!/^-?\d+$/.test(trimmed)) {
-    return undefined;
-  }
-  const value = Number(trimmed);
-  if (!Number.isInteger(value)) {
-    return undefined;
-  }
-  return value;
-}
-
-function parseStringLiteral(raw: string): string | undefined {
-  const match = raw.trim().match(/^(['"])(.*)\1$/s);
-  if (!match) {
-    return undefined;
-  }
-  return match[2] ?? '';
-}
-
-function lowerAutoincrement(input: {
-  readonly call: ParsedDefaultFunctionCall;
-  readonly context: DefaultFunctionLoweringContext;
-}): LoweredDefaultResult {
-  const maybeNoArgs = expectNoArgs({
-    call: input.call,
-    context: input.context,
-    usage: '`autoincrement()`',
-  });
-  if (maybeNoArgs) {
-    return maybeNoArgs;
-  }
+function lowerAutoincrement(): LoweredDefaultResult {
   return {
     ok: true,
     value: {
       kind: 'storage',
-      defaultValue: {
-        kind: 'function',
-        expression: 'autoincrement()',
-      },
+      defaultValue: { kind: 'function', expression: 'autoincrement()' },
     },
   };
 }
 
-function lowerNow(input: {
-  readonly call: ParsedDefaultFunctionCall;
-  readonly context: DefaultFunctionLoweringContext;
-}): LoweredDefaultResult {
-  const maybeNoArgs = expectNoArgs({
-    call: input.call,
-    context: input.context,
-    usage: '`now()`',
-  });
-  if (maybeNoArgs) {
-    return maybeNoArgs;
-  }
+function lowerNow(): LoweredDefaultResult {
   return {
     ok: true,
     value: {
       kind: 'storage',
-      defaultValue: {
-        kind: 'function',
-        expression: 'now()',
-      },
+      defaultValue: { kind: 'function', expression: 'now()' },
     },
   };
 }
 
-function lowerUuid(input: {
-  readonly call: ParsedDefaultFunctionCall;
-  readonly context: DefaultFunctionLoweringContext;
-}): LoweredDefaultResult {
-  if (input.call.args.length === 0) {
-    return executionGenerator('uuidv4');
-  }
-  if (input.call.args.length !== 1) {
-    return invalidArgumentDiagnostic({
-      context: input.context,
-      span: input.call.span,
-      message:
-        'Default function "uuid" accepts at most one version argument: `uuid()`, `uuid(4)`, or `uuid(7)`.',
-    });
-  }
-  const version = parseIntegerArgument(input.call.args[0]?.raw ?? '');
-  if (version === 4) {
-    return executionGenerator('uuidv4');
-  }
-  if (version === 7) {
-    return executionGenerator('uuidv7');
-  }
-  return invalidArgumentDiagnostic({
-    context: input.context,
-    span: input.call.args[0]?.span ?? input.call.span,
-    message:
-      'Default function "uuid" supports only `uuid()`, `uuid(4)`, or `uuid(7)` in SQL PSL provider v1.',
-  });
+function lowerUlid(): LoweredDefaultResult {
+  return executionGenerator('ulid');
 }
 
-function lowerCuid(input: {
-  readonly call: ParsedDefaultFunctionCall;
+function lowerUuid(input: {
+  readonly call: TypedDefaultFunctionCall;
   readonly context: DefaultFunctionLoweringContext;
 }): LoweredDefaultResult {
-  if (input.call.args.length === 0) {
-    return {
-      ok: false,
-      diagnostic: {
-        code: 'PSL_UNKNOWN_DEFAULT_FUNCTION',
-        message:
-          'Default function "cuid()" is not supported in SQL PSL provider v1. Use `cuid(2)` instead.',
-        sourceId: input.context.sourceId,
-        span: input.call.span,
-      },
-    };
-  }
-  if (input.call.args.length !== 1) {
-    return invalidArgumentDiagnostic({
-      context: input.context,
-      span: input.call.span,
-      message: 'Default function "cuid" accepts exactly one version argument: `cuid(2)`.',
-    });
-  }
-  const version = parseIntegerArgument(input.call.args[0]?.raw ?? '');
-  if (version === 2) {
-    return executionGenerator('cuid2');
-  }
-  return invalidArgumentDiagnostic({
-    context: input.context,
-    span: input.call.args[0]?.span ?? input.call.span,
-    message: 'Default function "cuid" supports only `cuid(2)` in SQL PSL provider v1.',
-  });
+  return input.call.args['version'] === 7
+    ? executionGenerator('uuidv7')
+    : executionGenerator('uuidv4');
 }
 
-function lowerUlid(input: {
-  readonly call: ParsedDefaultFunctionCall;
-  readonly context: DefaultFunctionLoweringContext;
-}): LoweredDefaultResult {
-  const maybeNoArgs = expectNoArgs({
-    call: input.call,
-    context: input.context,
-    usage: '`ulid()`',
-  });
-  if (maybeNoArgs) {
-    return maybeNoArgs;
-  }
-  return executionGenerator('ulid');
+function lowerCuid(): LoweredDefaultResult {
+  return executionGenerator('cuid2');
 }
 
 function lowerNanoid(input: {
-  readonly call: ParsedDefaultFunctionCall;
+  readonly call: TypedDefaultFunctionCall;
   readonly context: DefaultFunctionLoweringContext;
 }): LoweredDefaultResult {
-  if (input.call.args.length === 0) {
-    return executionGenerator('nanoid');
-  }
-  if (input.call.args.length !== 1) {
-    return invalidArgumentDiagnostic({
-      context: input.context,
-      span: input.call.span,
-      message:
-        'Default function "nanoid" accepts at most one size argument: `nanoid()` or `nanoid(<2-255>)`.',
-    });
-  }
-  const size = parseIntegerArgument(input.call.args[0]?.raw ?? '');
-  if (size !== undefined && size >= 2 && size <= 255) {
-    return executionGenerator('nanoid', { size });
-  }
-  return invalidArgumentDiagnostic({
-    context: input.context,
-    span: input.call.args[0]?.span ?? input.call.span,
-    message: 'Default function "nanoid" size argument must be an integer between 2 and 255.',
-  });
+  const size = input.call.args['size'];
+  return typeof size === 'number'
+    ? executionGenerator('nanoid', { size })
+    : executionGenerator('nanoid');
 }
 
 function lowerDbgenerated(input: {
-  readonly call: ParsedDefaultFunctionCall;
+  readonly call: TypedDefaultFunctionCall;
   readonly context: DefaultFunctionLoweringContext;
 }): LoweredDefaultResult {
-  if (input.call.args.length !== 1) {
+  const expression = input.call.args['expression'];
+  if (typeof expression !== 'string' || expression.trim().length === 0) {
     return invalidArgumentDiagnostic({
       context: input.context,
       span: input.call.span,
-      message:
-        'Default function "dbgenerated" requires exactly one string argument: `dbgenerated("...")`.',
-    });
-  }
-  const rawExpression = parseStringLiteral(input.call.args[0]?.raw ?? '');
-  if (rawExpression === undefined) {
-    return invalidArgumentDiagnostic({
-      context: input.context,
-      span: input.call.args[0]?.span ?? input.call.span,
-      message: 'Default function "dbgenerated" argument must be a string literal.',
-    });
-  }
-  if (rawExpression.trim().length === 0) {
-    return invalidArgumentDiagnostic({
-      context: input.context,
-      span: input.call.args[0]?.span ?? input.call.span,
       message: 'Default function "dbgenerated" argument cannot be empty.',
     });
   }
@@ -264,22 +110,47 @@ function lowerDbgenerated(input: {
     ok: true,
     value: {
       kind: 'storage',
-      defaultValue: {
-        kind: 'function',
-        expression: rawExpression,
-      },
+      defaultValue: { kind: 'function', expression },
     },
   };
 }
 
+const nowSig: FuncCallSig = {};
+const autoincrementSig: FuncCallSig = {};
+const ulidSig: FuncCallSig = {};
+const uuidSig: FuncCallSig = {
+  positional: [{ key: 'version', type: optional(oneOf(num(4), num(7))) }],
+};
+const cuidSig: FuncCallSig = { positional: [{ key: 'version', type: num(2) }] };
+const nanoidSig: FuncCallSig = {
+  positional: [{ key: 'size', type: optional(int({ min: 2, max: 255 })) }],
+};
+const dbgeneratedSig: FuncCallSig = { positional: [{ key: 'expression', type: str() }] };
+
 const postgresDefaultFunctionRegistryEntries = [
-  ['autoincrement', { lower: lowerAutoincrement, usageSignatures: ['autoincrement()'] }],
-  ['now', { lower: lowerNow, usageSignatures: ['now()'] }],
-  ['uuid', { lower: lowerUuid, usageSignatures: ['uuid()', 'uuid(4)', 'uuid(7)'] }],
-  ['cuid', { lower: lowerCuid, usageSignatures: ['cuid(2)'] }],
-  ['ulid', { lower: lowerUlid, usageSignatures: ['ulid()'] }],
-  ['nanoid', { lower: lowerNanoid, usageSignatures: ['nanoid()', 'nanoid(<2-255>)'] }],
-  ['dbgenerated', { lower: lowerDbgenerated, usageSignatures: ['dbgenerated("...")'] }],
+  [
+    'autoincrement',
+    {
+      signature: autoincrementSig,
+      lower: lowerAutoincrement,
+      usageSignatures: ['autoincrement()'],
+    },
+  ],
+  ['now', { signature: nowSig, lower: lowerNow, usageSignatures: ['now()'] }],
+  [
+    'uuid',
+    { signature: uuidSig, lower: lowerUuid, usageSignatures: ['uuid()', 'uuid(4)', 'uuid(7)'] },
+  ],
+  ['cuid', { signature: cuidSig, lower: lowerCuid, usageSignatures: ['cuid(2)'] }],
+  ['ulid', { signature: ulidSig, lower: lowerUlid, usageSignatures: ['ulid()'] }],
+  [
+    'nanoid',
+    { signature: nanoidSig, lower: lowerNanoid, usageSignatures: ['nanoid()', 'nanoid(<2-255>)'] },
+  ],
+  [
+    'dbgenerated',
+    { signature: dbgeneratedSig, lower: lowerDbgenerated, usageSignatures: ['dbgenerated("...")'] },
+  ],
 ] satisfies ReadonlyArray<readonly [string, ControlMutationDefaultEntry]>;
 
 const postgresScalarTypeDescriptors = new Map<string, string>([

package/src/core/descriptor-meta.ts

@@ -14,6 +14,7 @@ import {
   PG_FLOAT_CODEC_ID,
   PG_FLOAT4_CODEC_ID,
   PG_FLOAT8_CODEC_ID,
+  PG_INET_CODEC_ID,
   PG_INT_CODEC_ID,
   PG_INT2_CODEC_ID,
   PG_INT4_CODEC_ID,
@@ -172,6 +173,7 @@ export const postgresAdapterDescriptorMeta = {
       returning: true,
       defaultInInsert: true,
       lateral: true,
+      scalarList: true,
     },
   },
   types: {
@@ -217,6 +219,7 @@ export const postgresAdapterDescriptorMeta = {
         [PG_JSONB_CODEC_ID]: identityHooks,
         [PG_BYTEA_CODEC_ID]: identityHooks,
         [PG_UUID_CODEC_ID]: identityHooks,
+        [PG_INET_CODEC_ID]: identityHooks,
       },
     },
     storage: [
@@ -284,6 +287,7 @@ export const postgresAdapterDescriptorMeta = {
       { typeId: PG_JSONB_CODEC_ID, familyId: 'sql', targetId: 'postgres', nativeType: 'jsonb' },
       { typeId: PG_BYTEA_CODEC_ID, familyId: 'sql', targetId: 'postgres', nativeType: 'bytea' },
       { typeId: PG_UUID_CODEC_ID, familyId: 'sql', targetId: 'postgres', nativeType: 'uuid' },
+      { typeId: PG_INET_CODEC_ID, familyId: 'sql', targetId: 'postgres', nativeType: 'inet' },
     ],
     queryOperationTypes: {
       import: {

package/src/core/marker-ledger.ts

@@ -48,6 +48,21 @@ export const ledger = pgTable(
   },
 );
 
+/**
+ * Content-addressed contract store: one row per distinct contract, keyed
+ * by its storage hash. The ledger's `origin_core_hash` /
+ * `destination_core_hash` resolve here by hash equality, so both
+ * endpoints of every edge are direct lookups and a contract revisited by
+ * a rollback cycle is stored exactly once (upsert DO NOTHING).
+ */
+export const ledgerContract = pgTable(
+  { name: 'contract', schema: 'prisma_contract' },
+  {
+    core_hash: text(),
+    contract_json: jsonb(),
+  },
+);
+
 /**
  * Read-side handle covering every column of `prisma_contract.ledger`,
  * including the DB-generated `id` (for ORDER BY) and `created_at`.

package/src/core/sql-renderer.ts

@@ -73,11 +73,13 @@ function renderTypedParam(
   index: number,
   codecId: string | undefined,
   codecLookup: CodecLookup,
+  many?: boolean,
+  typeParams?: JsonValue,
 ): string {
   if (codecId === undefined) {
     return `$${index}`;
   }
-  const meta = codecLookup.metaFor(codecId);
+  const meta = codecLookup.metaFor(codecId, typeParams);
   const isRegistered =
     codecLookup.get(codecId) !== undefined ||
     meta !== undefined ||
@@ -92,13 +94,25 @@ function renderTypedParam(
         "if it's a builtin.",
     );
   }
-  // The framework `CodecLookup.metaFor` returns the family-agnostic `CodecMeta` whose `db` is `Record<string, unknown>`. The SQL family populates a narrower shape with `db.sql.<dialect>.nativeType: string`; navigate that path defensively and string-check the leaf.
+  // `typeParams` above already resolved a parameterized codec's per-instance
+  // meta (e.g. a native enum's type name) ahead of its static fallback.
+  //
+  // The framework `CodecLookup.metaFor` returns the family-agnostic
+  // `CodecMeta`, whose `db` is `Record<string, unknown>`. The SQL family
+  // populates a narrower shape with `db.sql.<dialect>.nativeType: string`, so
+  // navigate that path defensively and string-check the leaf.
   const dbRecord = meta?.db;
   const sqlBlock = isRecord(dbRecord) ? dbRecord['sql'] : undefined;
   const dialectBlock = isRecord(sqlBlock) ? sqlBlock['postgres'] : undefined;
   const nativeType = isRecord(dialectBlock) ? dialectBlock['nativeType'] : undefined;
-  if (typeof nativeType === 'string' && !POSTGRES_INFERRABLE_NATIVE_TYPES.has(nativeType)) {
-    return `$${index}::${nativeType}`;
+  if (typeof nativeType === 'string') {
+    const arraySuffix = many ? '[]' : '';
+    if (!POSTGRES_INFERRABLE_NATIVE_TYPES.has(nativeType)) {
+      return `$${index}::${nativeType}${arraySuffix}`;
+    }
+    if (many) {
+      return `$${index}::${nativeType}${arraySuffix}`;
+    }
   }
   return `$${index}`;
 }
@@ -736,7 +750,13 @@ function renderParamRef(ref: AnyParamRef, pim: ParamIndexMap): string {
     throw new Error('ParamRef not found in index map');
   }
   if (ref.kind === 'prepared-param-ref') {
-    return renderTypedParam(index, ref.codec.codecId, pim.codecLookup);
+    return renderTypedParam(
+      index,
+      ref.codec.codecId,
+      pim.codecLookup,
+      ref.codec.many,
+      ref.codec.typeParams,
+    );
   }
   if (ref.codec === undefined) {
     throw runtimeError(
@@ -747,7 +767,13 @@ function renderParamRef(ref: AnyParamRef, pim: ParamIndexMap): string {
       { paramIndex: index, ...ifDefined('name', ref.name) },
     );
   }
-  return renderTypedParam(index, ref.codec.codecId, pim.codecLookup);
+  return renderTypedParam(
+    index,
+    ref.codec.codecId,
+    pim.codecLookup,
+    ref.codec.many,
+    ref.codec.typeParams,
+  );
 }
 
 function renderLiteral(expr: LiteralExpr): string {

package/src/core/types.ts

@@ -1,6 +1,5 @@
-import type { Contract } from '@prisma-next/contract/types';
 import type { CodecRegistry } from '@prisma-next/framework-components/codec';
-import type { SqlStorage, StorageColumn, StorageTable } from '@prisma-next/sql-contract/types';
+import type { StorageColumn, StorageTable } from '@prisma-next/sql-contract/types';
 import type {
   AnyQueryAst,
   BinaryExpr,
@@ -32,7 +31,7 @@ export interface PostgresAdapterOptions {
   readonly codecLookup?: CodecRegistry;
 }
 
-export type PostgresContract = Contract<SqlStorage> & { readonly target: 'postgres' };
+export type { PostgresContract } from '@prisma-next/target-postgres/types';
 
 export type Expr = ColumnRef | ParamRef | DefaultValueExpr;
 

package/src/exports/runtime.ts

@@ -39,11 +39,8 @@ const postgresRuntimeAdapterDescriptor: SqlRuntimeAdapterDescriptor<'postgres',
     create(stack): SqlRuntimeAdapter {
       // The runtime `ExecutionStack` does not (yet) carry a pre-assembled `codecLookup` field the way the control `ControlStack` does, so we derive an equivalent lookup here from the stack's component metadata (target + adapter + extension packs) using the same assembly helper that `createControlStack` uses. This keeps the renderer fed with the same codec set on both planes — including extension-contributed codecs like
       // `pg/vector@1` from `@prisma-next/extension-pgvector`.
-      const codecLookup = extractCodecLookup([
-        stack.target,
-        stack.adapter,
-        ...stack.extensionPacks,
-      ]);
+      const components = [stack.target, stack.adapter, ...stack.extensionPacks];
+      const codecLookup = extractCodecLookup(components);
       return createPostgresAdapter({ codecLookup });
     },
   };

package/dist/adapter-CwkcdpM_.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"adapter-CwkcdpM_.mjs","names":[],"sources":["../src/core/adapter.ts"],"sourcesContent":["import type { CodecRegistry } from '@prisma-next/framework-components/codec';\nimport { APP_SPACE_ID } from '@prisma-next/framework-components/control';\nimport type {\n  Adapter,\n  AdapterProfile,\n  AnyQueryAst,\n  LowererContext,\n  RawSqlLiteral,\n  SqlQueryable,\n} from '@prisma-next/sql-relational-core/ast';\nimport { isDdlNode } from '@prisma-next/sql-relational-core/ast';\nimport type { RawCodecInferer } from '@prisma-next/sql-relational-core/expression';\nimport type { PostgresDdlNode } from '@prisma-next/target-postgres/ddl';\nimport { createPostgresBuiltinCodecLookup } from './codec-lookup';\nimport { PostgresControlAdapter } from './control-adapter';\nimport { renderLoweredSql } from './sql-renderer';\nimport type { PostgresAdapterOptions, PostgresContract, PostgresLoweredStatement } from './types';\n\nconst defaultCapabilities = Object.freeze({\n  postgres: {\n    orderBy: true,\n    limit: true,\n    lateral: true,\n    jsonAgg: true,\n    returning: true,\n    distinctOn: true,\n  },\n  sql: {\n    enums: true,\n    returning: true,\n    defaultInInsert: true,\n    lateral: true,\n  },\n});\n\nclass PostgresAdapterImpl\n  implements Adapter<AnyQueryAst, PostgresContract, PostgresLoweredStatement>\n{\n  // These fields make the adapter instance structurally compatible with RuntimeAdapterInstance<'sql', 'postgres'> without introducing a runtime-plane dependency.\n  readonly familyId = 'sql' as const;\n  readonly targetId = 'postgres' as const;\n\n  readonly profile: AdapterProfile<'postgres'>;\n  private readonly codecLookup: CodecRegistry;\n\n  constructor(options?: PostgresAdapterOptions) {\n    this.codecLookup = options?.codecLookup ?? createPostgresBuiltinCodecLookup();\n    const controlAdapter = new PostgresControlAdapter(this.codecLookup);\n    this.profile = Object.freeze({\n      id: options?.profileId ?? 'postgres/default@1',\n      target: 'postgres',\n      capabilities: defaultCapabilities,\n      readMarker: (queryable: SqlQueryable) =>\n        controlAdapter.readMarkerDiscriminated(\n          {\n            familyId: 'sql',\n            targetId: 'postgres',\n            query: async <Row = Record<string, unknown>>(\n              sql: string,\n              params?: readonly unknown[],\n            ) => {\n              const result = await queryable.query<Row>(sql, params);\n              return { rows: [...result.rows] };\n            },\n            close: async () => {},\n          },\n          APP_SPACE_ID,\n        ),\n    });\n  }\n\n  lower(\n    ast: AnyQueryAst | PostgresDdlNode,\n    context: LowererContext<PostgresContract>,\n  ): PostgresLoweredStatement {\n    if (isDdlNode(ast)) {\n      throw new Error(\n        'lower() does not lower DDL on the runtime adapter — DDL lowering is a control-plane concern handled by the control adapter.',\n      );\n    }\n    return renderLoweredSql(ast, context.contract, this.codecLookup);\n  }\n}\n\n/** Codec-id lookup for bare-literal interpolations used by `fns.raw` on a postgres client. Contributed as the descriptor's static `rawCodecInferer` slot. */\nexport const postgresRawCodecInferer: RawCodecInferer = {\n  inferCodec(value: RawSqlLiteral): string {\n    switch (typeof value) {\n      case 'number':\n        return Number.isSafeInteger(value) && value % 1 === 0 ? 'pg/int4' : 'pg/float8';\n      case 'bigint':\n        return 'pg/int8';\n      case 'string':\n        return 'pg/text';\n      case 'boolean':\n        return 'pg/bool';\n      case 'object':\n        if (value instanceof Uint8Array) return 'pg/bytea';\n    }\n    throw new Error(\n      'unsupported JS value type for raw-SQL interpolation: wrap this value in `param(...)` with an explicit codec',\n    );\n  },\n};\n\nexport function createPostgresAdapter(options?: PostgresAdapterOptions) {\n  return Object.freeze(new PostgresAdapterImpl(options));\n}\n"],"mappings":";;;;AAkBA,MAAM,sBAAsB,OAAO,OAAO;CACxC,UAAU;EACR,SAAS;EACT,OAAO;EACP,SAAS;EACT,SAAS;EACT,WAAW;EACX,YAAY;CACd;CACA,KAAK;EACH,OAAO;EACP,WAAW;EACX,iBAAiB;EACjB,SAAS;CACX;AACF,CAAC;AAED,IAAM,sBAAN,MAEA;CAEE,WAAoB;CACpB,WAAoB;CAEpB;CACA;CAEA,YAAY,SAAkC;EAC5C,KAAK,cAAc,SAAS,eAAe,iCAAiC;EAC5E,MAAM,iBAAiB,IAAI,uBAAuB,KAAK,WAAW;EAClE,KAAK,UAAU,OAAO,OAAO;GAC3B,IAAI,SAAS,aAAa;GAC1B,QAAQ;GACR,cAAc;GACd,aAAa,cACX,eAAe,wBACb;IACE,UAAU;IACV,UAAU;IACV,OAAO,OACL,KACA,WACG;KAEH,OAAO,EAAE,MAAM,CAAC,IAAG,MADE,UAAU,MAAW,KAAK,MAAM,EAAA,CAC3B,IAAI,EAAE;IAClC;IACA,OAAO,YAAY,CAAC;GACtB,GACA,YACF;EACJ,CAAC;CACH;CAEA,MACE,KACA,SAC0B;EAC1B,IAAI,UAAU,GAAG,GACf,MAAM,IAAI,MACR,6HACF;EAEF,OAAO,iBAAiB,KAAK,QAAQ,UAAU,KAAK,WAAW;CACjE;AACF;;AAGA,MAAa,0BAA2C,EACtD,WAAW,OAA8B;CACvC,QAAQ,OAAO,OAAf;EACE,KAAK,UACH,OAAO,OAAO,cAAc,KAAK,KAAK,QAAQ,MAAM,IAAI,YAAY;EACtE,KAAK,UACH,OAAO;EACT,KAAK,UACH,OAAO;EACT,KAAK,WACH,OAAO;EACT,KAAK,UACH,IAAI,iBAAiB,YAAY,OAAO;CAC5C;CACA,MAAM,IAAI,MACR,6GACF;AACF,EACF;AAEA,SAAgB,sBAAsB,SAAkC;CACtE,OAAO,OAAO,OAAO,IAAI,oBAAoB,OAAO,CAAC;AACvD"}