@query-doctor/core 0.8.9 → 0.10.0

package/dist/schema.d.mts

@@ -0,0 +1,352 @@
+'use client';
+
+import { PgIdentifier } from "./sql/pg-identifier.mjs";
+import { Postgres } from "./sql/database.mjs";
+import { z } from "zod";
+
+//#region src/schema.d.ts
+declare const FullSchemaKeyColumn: z.ZodObject<{
+  type: z.ZodLiteral<"indexColumn">;
+  name: z.ZodCodec<z.ZodString, z.ZodCustom<PgIdentifier, PgIdentifier>>;
+  order: z.ZodOptional<z.ZodEnum<{
+    ASC: "ASC";
+    DESC: "DESC";
+  }>>;
+  nulls: z.ZodOptional<z.ZodEnum<{
+    FIRST: "FIRST";
+    LAST: "LAST";
+  }>>;
+  opclass: z.ZodOptional<z.ZodString>;
+  collation: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+type FullSchemaKeyColumn = z.infer<typeof FullSchemaKeyColumn>;
+declare const FullSchemaIncludedColumn: z.ZodObject<{
+  name: z.ZodCodec<z.ZodString, z.ZodCustom<PgIdentifier, PgIdentifier>>;
+}, z.core.$strip>;
+type FullSchemaIncludedColumn = z.infer<typeof FullSchemaIncludedColumn>;
+declare const FullSchemaIndex: z.ZodObject<{
+  type: z.ZodLiteral<"index">;
+  oid: z.ZodNumber;
+  schemaName: z.ZodCodec<z.ZodString, z.ZodCustom<PgIdentifier, PgIdentifier>>;
+  tableName: z.ZodCodec<z.ZodString, z.ZodCustom<PgIdentifier, PgIdentifier>>;
+  indexName: z.ZodCodec<z.ZodString, z.ZodCustom<PgIdentifier, PgIdentifier>>;
+  indexType: z.ZodString;
+  isUnique: z.ZodBoolean;
+  isPrimary: z.ZodBoolean;
+  isClustered: z.ZodBoolean;
+  wherePredicate: z.ZodOptional<z.ZodString>;
+  tablespace: z.ZodOptional<z.ZodString>;
+  keyColumns: z.ZodArray<z.ZodObject<{
+    type: z.ZodLiteral<"indexColumn">;
+    name: z.ZodCodec<z.ZodString, z.ZodCustom<PgIdentifier, PgIdentifier>>;
+    order: z.ZodOptional<z.ZodEnum<{
+      ASC: "ASC";
+      DESC: "DESC";
+    }>>;
+    nulls: z.ZodOptional<z.ZodEnum<{
+      FIRST: "FIRST";
+      LAST: "LAST";
+    }>>;
+    opclass: z.ZodOptional<z.ZodString>;
+    collation: z.ZodOptional<z.ZodString>;
+  }, z.core.$strip>>;
+  includedColumns: z.ZodOptional<z.ZodArray<z.ZodObject<{
+    name: z.ZodCodec<z.ZodString, z.ZodCustom<PgIdentifier, PgIdentifier>>;
+  }, z.core.$strip>>>;
+}, z.core.$strip>;
+type FullSchemaIndex = z.infer<typeof FullSchemaIndex>;
+declare const FullSchemaColumn: z.ZodObject<{
+  type: z.ZodLiteral<"column">;
+  name: z.ZodCodec<z.ZodString, z.ZodCustom<PgIdentifier, PgIdentifier>>;
+  order: z.ZodNumber;
+  columnType: z.ZodString;
+  isNullable: z.ZodBoolean;
+  defaultValue: z.ZodOptional<z.ZodString>;
+  dropped: z.ZodBoolean;
+  collation: z.ZodOptional<z.ZodString>;
+  storage: z.ZodOptional<z.ZodEnum<{
+    plain: "plain";
+    main: "main";
+    external: "external";
+    extended: "extended";
+  }>>;
+  isIdentity: z.ZodOptional<z.ZodEnum<{
+    always: "always";
+    "by default": "by default";
+  }>>;
+}, z.core.$strip>;
+type FullSchemaColumn = z.infer<typeof FullSchemaColumn>;
+declare const FullSchemaTable: z.ZodObject<{
+  type: z.ZodLiteral<"table">;
+  oid: z.ZodNumber;
+  schemaName: z.ZodCodec<z.ZodString, z.ZodCustom<PgIdentifier, PgIdentifier>>;
+  tableName: z.ZodCodec<z.ZodString, z.ZodCustom<PgIdentifier, PgIdentifier>>;
+  tablespace: z.ZodOptional<z.ZodString>;
+  partitionKeyDef: z.ZodOptional<z.ZodString>;
+  columns: z.ZodDefault<z.ZodArray<z.ZodObject<{
+    type: z.ZodLiteral<"column">;
+    name: z.ZodCodec<z.ZodString, z.ZodCustom<PgIdentifier, PgIdentifier>>;
+    order: z.ZodNumber;
+    columnType: z.ZodString;
+    isNullable: z.ZodBoolean;
+    defaultValue: z.ZodOptional<z.ZodString>;
+    dropped: z.ZodBoolean;
+    collation: z.ZodOptional<z.ZodString>;
+    storage: z.ZodOptional<z.ZodEnum<{
+      plain: "plain";
+      main: "main";
+      external: "external";
+      extended: "extended";
+    }>>;
+    isIdentity: z.ZodOptional<z.ZodEnum<{
+      always: "always";
+      "by default": "by default";
+    }>>;
+  }, z.core.$strip>>>;
+}, z.core.$strip>;
+type FullSchemaTable = z.infer<typeof FullSchemaTable>;
+declare const FullSchemaConstraint: z.ZodObject<{
+  type: z.ZodLiteral<"constraint">;
+  oid: z.ZodNumber;
+  schemaName: z.ZodCodec<z.ZodString, z.ZodCustom<PgIdentifier, PgIdentifier>>;
+  tableName: z.ZodCodec<z.ZodString, z.ZodCustom<PgIdentifier, PgIdentifier>>;
+  constraintName: z.ZodCodec<z.ZodString, z.ZodCustom<PgIdentifier, PgIdentifier>>;
+  constraintType: z.ZodUnion<[z.ZodEnum<{
+    check: "check";
+    foreign_key: "foreign_key";
+    not_null: "not_null";
+    primary_key: "primary_key";
+    unique: "unique";
+    trigger: "trigger";
+    exclusion: "exclusion";
+  }>, z.ZodString]>;
+  definition: z.ZodString;
+  isDeferrable: z.ZodOptional<z.ZodBoolean>;
+  isInitiallyDeferred: z.ZodOptional<z.ZodBoolean>;
+  isValidated: z.ZodOptional<z.ZodBoolean>;
+  backingIndexOid: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+type FullSchemaConstraint = z.infer<typeof FullSchemaConstraint>;
+declare const FullSchemaFunction: z.ZodObject<{
+  type: z.ZodLiteral<"function">;
+  schemaName: z.ZodCodec<z.ZodString, z.ZodCustom<PgIdentifier, PgIdentifier>>;
+  objectName: z.ZodCodec<z.ZodString, z.ZodCustom<PgIdentifier, PgIdentifier>>;
+  objectType: z.ZodEnum<{
+    function: "function";
+    procedure: "procedure";
+    aggregate: "aggregate";
+    "window function": "window function";
+  }>;
+  identityArguments: z.ZodOptional<z.ZodString>;
+  definition: z.ZodString;
+}, z.core.$strip>;
+type FullSchemaFunction = z.infer<typeof FullSchemaFunction>;
+declare const FullSchemaExtension: z.ZodObject<{
+  extensionName: z.ZodString;
+  version: z.ZodString;
+  schemaName: z.ZodCodec<z.ZodString, z.ZodCustom<PgIdentifier, PgIdentifier>>;
+}, z.core.$strip>;
+type FullSchemaExtension = z.infer<typeof FullSchemaExtension>;
+declare const FullSchemaView: z.ZodObject<{
+  type: z.ZodLiteral<"view">;
+  schemaName: z.ZodCodec<z.ZodString, z.ZodCustom<PgIdentifier, PgIdentifier>>;
+  viewName: z.ZodCodec<z.ZodString, z.ZodCustom<PgIdentifier, PgIdentifier>>;
+  objectType: z.ZodEnum<{
+    view: "view";
+    materialized_view: "materialized_view";
+  }>;
+  definition: z.ZodString;
+  tablespace: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+type FullSchemaView = z.infer<typeof FullSchemaView>;
+declare const FullSchemaTypeConstraint: z.ZodObject<{
+  name: z.ZodCodec<z.ZodString, z.ZodCustom<PgIdentifier, PgIdentifier>>;
+  definition: z.ZodString;
+}, z.core.$strip>;
+type FullSchemaTypeConstraint = z.infer<typeof FullSchemaTypeConstraint>;
+declare const FullSchemaCompositeAttribute: z.ZodObject<{
+  type: z.ZodLiteral<"compositeAttribute">;
+  name: z.ZodCodec<z.ZodString, z.ZodCustom<PgIdentifier, PgIdentifier>>;
+  attributeType: z.ZodString;
+  collation: z.ZodOptional<z.ZodCodec<z.ZodString, z.ZodCustom<PgIdentifier, PgIdentifier>>>;
+}, z.core.$strip>;
+type FullSchemaCompositeAttribute = z.infer<typeof FullSchemaCompositeAttribute>;
+declare const FullSchemaType: z.ZodObject<{
+  type: z.ZodLiteral<"type">;
+  schemaName: z.ZodCodec<z.ZodString, z.ZodCustom<PgIdentifier, PgIdentifier>>;
+  typeName: z.ZodCodec<z.ZodString, z.ZodCustom<PgIdentifier, PgIdentifier>>;
+  typeCategory: z.ZodEnum<{
+    enum: "enum";
+    domain: "domain";
+    composite: "composite";
+  }>;
+  enumLabels: z.ZodOptional<z.ZodArray<z.ZodString>>;
+  domainBaseType: z.ZodOptional<z.ZodString>;
+  domainIsNotNull: z.ZodOptional<z.ZodBoolean>;
+  domainDefault: z.ZodOptional<z.ZodString>;
+  domainConstraints: z.ZodOptional<z.ZodArray<z.ZodObject<{
+    name: z.ZodCodec<z.ZodString, z.ZodCustom<PgIdentifier, PgIdentifier>>;
+    definition: z.ZodString;
+  }, z.core.$strip>>>;
+  compositeAttributes: z.ZodOptional<z.ZodArray<z.ZodObject<{
+    type: z.ZodLiteral<"compositeAttribute">;
+    name: z.ZodCodec<z.ZodString, z.ZodCustom<PgIdentifier, PgIdentifier>>;
+    attributeType: z.ZodString;
+    collation: z.ZodOptional<z.ZodCodec<z.ZodString, z.ZodCustom<PgIdentifier, PgIdentifier>>>;
+  }, z.core.$strip>>>;
+}, z.core.$strip>;
+type FullSchemaType = z.infer<typeof FullSchemaType>;
+declare const FullSchemaTrigger: z.ZodObject<{
+  schemaName: z.ZodCodec<z.ZodString, z.ZodCustom<PgIdentifier, PgIdentifier>>;
+  tableName: z.ZodCodec<z.ZodString, z.ZodCustom<PgIdentifier, PgIdentifier>>;
+  triggerName: z.ZodCodec<z.ZodString, z.ZodCustom<PgIdentifier, PgIdentifier>>;
+  definition: z.ZodString;
+  enabledMode: z.ZodString;
+}, z.core.$strip>;
+type FullSchemaTrigger = z.infer<typeof FullSchemaTrigger>;
+declare const FullSchema: z.ZodObject<{
+  indexes: z.ZodDefault<z.ZodArray<z.ZodObject<{
+    type: z.ZodLiteral<"index">;
+    oid: z.ZodNumber;
+    schemaName: z.ZodCodec<z.ZodString, z.ZodCustom<PgIdentifier, PgIdentifier>>;
+    tableName: z.ZodCodec<z.ZodString, z.ZodCustom<PgIdentifier, PgIdentifier>>;
+    indexName: z.ZodCodec<z.ZodString, z.ZodCustom<PgIdentifier, PgIdentifier>>;
+    indexType: z.ZodString;
+    isUnique: z.ZodBoolean;
+    isPrimary: z.ZodBoolean;
+    isClustered: z.ZodBoolean;
+    wherePredicate: z.ZodOptional<z.ZodString>;
+    tablespace: z.ZodOptional<z.ZodString>;
+    keyColumns: z.ZodArray<z.ZodObject<{
+      type: z.ZodLiteral<"indexColumn">;
+      name: z.ZodCodec<z.ZodString, z.ZodCustom<PgIdentifier, PgIdentifier>>;
+      order: z.ZodOptional<z.ZodEnum<{
+        ASC: "ASC";
+        DESC: "DESC";
+      }>>;
+      nulls: z.ZodOptional<z.ZodEnum<{
+        FIRST: "FIRST";
+        LAST: "LAST";
+      }>>;
+      opclass: z.ZodOptional<z.ZodString>;
+      collation: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    includedColumns: z.ZodOptional<z.ZodArray<z.ZodObject<{
+      name: z.ZodCodec<z.ZodString, z.ZodCustom<PgIdentifier, PgIdentifier>>;
+    }, z.core.$strip>>>;
+  }, z.core.$strip>>>;
+  tables: z.ZodDefault<z.ZodArray<z.ZodObject<{
+    type: z.ZodLiteral<"table">;
+    oid: z.ZodNumber;
+    schemaName: z.ZodCodec<z.ZodString, z.ZodCustom<PgIdentifier, PgIdentifier>>;
+    tableName: z.ZodCodec<z.ZodString, z.ZodCustom<PgIdentifier, PgIdentifier>>;
+    tablespace: z.ZodOptional<z.ZodString>;
+    partitionKeyDef: z.ZodOptional<z.ZodString>;
+    columns: z.ZodDefault<z.ZodArray<z.ZodObject<{
+      type: z.ZodLiteral<"column">;
+      name: z.ZodCodec<z.ZodString, z.ZodCustom<PgIdentifier, PgIdentifier>>;
+      order: z.ZodNumber;
+      columnType: z.ZodString;
+      isNullable: z.ZodBoolean;
+      defaultValue: z.ZodOptional<z.ZodString>;
+      dropped: z.ZodBoolean;
+      collation: z.ZodOptional<z.ZodString>;
+      storage: z.ZodOptional<z.ZodEnum<{
+        plain: "plain";
+        main: "main";
+        external: "external";
+        extended: "extended";
+      }>>;
+      isIdentity: z.ZodOptional<z.ZodEnum<{
+        always: "always";
+        "by default": "by default";
+      }>>;
+    }, z.core.$strip>>>;
+  }, z.core.$strip>>>;
+  constraints: z.ZodDefault<z.ZodArray<z.ZodObject<{
+    type: z.ZodLiteral<"constraint">;
+    oid: z.ZodNumber;
+    schemaName: z.ZodCodec<z.ZodString, z.ZodCustom<PgIdentifier, PgIdentifier>>;
+    tableName: z.ZodCodec<z.ZodString, z.ZodCustom<PgIdentifier, PgIdentifier>>;
+    constraintName: z.ZodCodec<z.ZodString, z.ZodCustom<PgIdentifier, PgIdentifier>>;
+    constraintType: z.ZodUnion<[z.ZodEnum<{
+      check: "check";
+      foreign_key: "foreign_key";
+      not_null: "not_null";
+      primary_key: "primary_key";
+      unique: "unique";
+      trigger: "trigger";
+      exclusion: "exclusion";
+    }>, z.ZodString]>;
+    definition: z.ZodString;
+    isDeferrable: z.ZodOptional<z.ZodBoolean>;
+    isInitiallyDeferred: z.ZodOptional<z.ZodBoolean>;
+    isValidated: z.ZodOptional<z.ZodBoolean>;
+    backingIndexOid: z.ZodOptional<z.ZodNumber>;
+  }, z.core.$strip>>>;
+  functions: z.ZodDefault<z.ZodArray<z.ZodObject<{
+    type: z.ZodLiteral<"function">;
+    schemaName: z.ZodCodec<z.ZodString, z.ZodCustom<PgIdentifier, PgIdentifier>>;
+    objectName: z.ZodCodec<z.ZodString, z.ZodCustom<PgIdentifier, PgIdentifier>>;
+    objectType: z.ZodEnum<{
+      function: "function";
+      procedure: "procedure";
+      aggregate: "aggregate";
+      "window function": "window function";
+    }>;
+    identityArguments: z.ZodOptional<z.ZodString>;
+    definition: z.ZodString;
+  }, z.core.$strip>>>;
+  extensions: z.ZodDefault<z.ZodArray<z.ZodObject<{
+    extensionName: z.ZodString;
+    version: z.ZodString;
+    schemaName: z.ZodCodec<z.ZodString, z.ZodCustom<PgIdentifier, PgIdentifier>>;
+  }, z.core.$strip>>>;
+  views: z.ZodDefault<z.ZodArray<z.ZodObject<{
+    type: z.ZodLiteral<"view">;
+    schemaName: z.ZodCodec<z.ZodString, z.ZodCustom<PgIdentifier, PgIdentifier>>;
+    viewName: z.ZodCodec<z.ZodString, z.ZodCustom<PgIdentifier, PgIdentifier>>;
+    objectType: z.ZodEnum<{
+      view: "view";
+      materialized_view: "materialized_view";
+    }>;
+    definition: z.ZodString;
+    tablespace: z.ZodOptional<z.ZodString>;
+  }, z.core.$strip>>>;
+  types: z.ZodDefault<z.ZodArray<z.ZodObject<{
+    type: z.ZodLiteral<"type">;
+    schemaName: z.ZodCodec<z.ZodString, z.ZodCustom<PgIdentifier, PgIdentifier>>;
+    typeName: z.ZodCodec<z.ZodString, z.ZodCustom<PgIdentifier, PgIdentifier>>;
+    typeCategory: z.ZodEnum<{
+      enum: "enum";
+      domain: "domain";
+      composite: "composite";
+    }>;
+    enumLabels: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    domainBaseType: z.ZodOptional<z.ZodString>;
+    domainIsNotNull: z.ZodOptional<z.ZodBoolean>;
+    domainDefault: z.ZodOptional<z.ZodString>;
+    domainConstraints: z.ZodOptional<z.ZodArray<z.ZodObject<{
+      name: z.ZodCodec<z.ZodString, z.ZodCustom<PgIdentifier, PgIdentifier>>;
+      definition: z.ZodString;
+    }, z.core.$strip>>>;
+    compositeAttributes: z.ZodOptional<z.ZodArray<z.ZodObject<{
+      type: z.ZodLiteral<"compositeAttribute">;
+      name: z.ZodCodec<z.ZodString, z.ZodCustom<PgIdentifier, PgIdentifier>>;
+      attributeType: z.ZodString;
+      collation: z.ZodOptional<z.ZodCodec<z.ZodString, z.ZodCustom<PgIdentifier, PgIdentifier>>>;
+    }, z.core.$strip>>>;
+  }, z.core.$strip>>>;
+  triggers: z.ZodDefault<z.ZodArray<z.ZodObject<{
+    schemaName: z.ZodCodec<z.ZodString, z.ZodCustom<PgIdentifier, PgIdentifier>>;
+    tableName: z.ZodCodec<z.ZodString, z.ZodCustom<PgIdentifier, PgIdentifier>>;
+    triggerName: z.ZodCodec<z.ZodString, z.ZodCustom<PgIdentifier, PgIdentifier>>;
+    definition: z.ZodString;
+    enabledMode: z.ZodString;
+  }, z.core.$strip>>>;
+}, z.core.$strip>;
+type FullSchema = z.infer<typeof FullSchema>;
+declare function dumpSchema(db: Postgres): Promise<FullSchema>;
+//#endregion
+export { FullSchema, FullSchemaColumn, FullSchemaCompositeAttribute, FullSchemaConstraint, FullSchemaExtension, FullSchemaFunction, FullSchemaIncludedColumn, FullSchemaIndex, FullSchemaKeyColumn, FullSchemaTable, FullSchemaTrigger, FullSchemaType, FullSchemaTypeConstraint, FullSchemaView, dumpSchema };
+//# sourceMappingURL=schema.d.mts.map

package/dist/schema.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema.d.mts","names":[],"sources":["../src/schema.ts"],"mappings":";;;;;;;cAUa,mBAAA,EAAmB,CAAA,CAAA,SAAA;;;;;;;;;;;;;;KASpB,mBAAA,GAAsB,CAAA,CAAE,KAAA,QAAa,mBAAA;AAAA,cAEpC,wBAAA,EAAwB,CAAA,CAAA,SAAA;;;KAIzB,wBAAA,GAA2B,CAAA,CAAE,KAAA,QAAa,wBAAA;AAAA,cAEzC,eAAA,EAAe,CAAA,CAAA,SAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAgBhB,eAAA,GAAkB,CAAA,CAAE,KAAA,QAAa,eAAA;AAAA,cAEhC,gBAAA,EAAgB,CAAA,CAAA,SAAA;;;;;;;;;;;;;;;;;;;;KAajB,gBAAA,GAAmB,CAAA,CAAE,KAAA,QAAa,gBAAA;AAAA,cAEjC,eAAA,EAAe,CAAA,CAAA,SAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAUhB,eAAA,GAAkB,CAAA,CAAE,KAAA,QAAa,eAAA;AAAA,cAEhC,oBAAA,EAAoB,CAAA,CAAA,SAAA;;;;;;;;;;;;;;;;;;;;;KAwBrB,oBAAA,GAAuB,CAAA,CAAE,KAAA,QAAa,oBAAA;AAAA,cAErC,kBAAA,EAAkB,CAAA,CAAA,SAAA;;;;;;;;;;;;;KASnB,kBAAA,GAAqB,CAAA,CAAE,KAAA,QAAa,kBAAA;AAAA,cAEnC,mBAAA,EAAmB,CAAA,CAAA,SAAA;;;;;KAMpB,mBAAA,GAAsB,CAAA,CAAE,KAAA,QAAa,mBAAA;AAAA,cAEpC,cAAA,EAAc,CAAA,CAAA,SAAA;;;;;;;;;;;KASf,cAAA,GAAiB,CAAA,CAAE,KAAA,QAAa,cAAA;AAAA,cAE/B,wBAAA,EAAwB,CAAA,CAAA,SAAA;;;;KAKzB,wBAAA,GAA2B,CAAA,CAAE,KAAA,QAAa,wBAAA;AAAA,cAEzC,4BAAA,EAA4B,CAAA,CAAA,SAAA;;;;;;KAO7B,4BAAA,GAA+B,CAAA,CAAE,KAAA,QACpC,4BAAA;AAAA,cAGI,cAAA,EAAc,CAAA,CAAA,SAAA;;;;;;;;;;;;;;;;;;;;;;;;KAaf,cAAA,GAAiB,CAAA,CAAE,KAAA,QAAa,cAAA;AAAA,cAE/B,iBAAA,EAAiB,CAAA,CAAA,SAAA;;;;;;;KAQlB,iBAAA,GAAoB,CAAA,CAAE,KAAA,QAAa,iBAAA;AAAA,cAElC,UAAA,EAAU,CAAA,CAAA,SAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAWX,UAAA,GAAa,CAAA,CAAE,KAAA,QAAa,UAAA;AAAA,iBAElB,UAAA,CAAW,EAAA,EAAI,QAAA,GAAW,OAAA,CAAQ,UAAA"}

package/dist/schema.mjs

@@ -0,0 +1,157 @@
+"use client";
+import { SCHEMA_DUMP_SQL } from "./schema-dump.mjs";
+import { PgIdentifier } from "./sql/pg-identifier.mjs";
+import { z } from "zod";
+//#region src/schema.ts
+const Identifier = z.codec(z.string(), z.custom(), {
+	encode: (v) => v.toString(),
+	decode: (v) => PgIdentifier.fromString(v)
+});
+const FullSchemaKeyColumn = z.object({
+	type: z.literal("indexColumn"),
+	name: Identifier,
+	order: z.enum(["ASC", "DESC"]).optional(),
+	nulls: z.enum(["FIRST", "LAST"]).optional(),
+	opclass: z.string().optional(),
+	collation: z.string().optional()
+});
+const FullSchemaIncludedColumn = z.object({ name: Identifier });
+const FullSchemaIndex = z.object({
+	type: z.literal("index"),
+	oid: z.number(),
+	schemaName: Identifier,
+	tableName: Identifier,
+	indexName: Identifier,
+	indexType: z.string(),
+	isUnique: z.boolean(),
+	isPrimary: z.boolean(),
+	isClustered: z.boolean(),
+	wherePredicate: z.string().optional(),
+	tablespace: z.string().optional(),
+	keyColumns: z.array(FullSchemaKeyColumn),
+	includedColumns: z.array(FullSchemaIncludedColumn).optional()
+});
+const FullSchemaColumn = z.object({
+	type: z.literal("column"),
+	name: Identifier,
+	order: z.number(),
+	columnType: z.string(),
+	isNullable: z.boolean(),
+	defaultValue: z.string().optional(),
+	dropped: z.boolean(),
+	collation: z.string().optional(),
+	storage: z.enum([
+		"plain",
+		"main",
+		"external",
+		"extended"
+	]).optional(),
+	isIdentity: z.enum(["always", "by default"]).optional()
+});
+const FullSchemaTable = z.object({
+	type: z.literal("table"),
+	oid: z.number(),
+	schemaName: Identifier,
+	tableName: Identifier,
+	tablespace: z.string().optional(),
+	partitionKeyDef: z.string().optional(),
+	columns: z.array(FullSchemaColumn).default([])
+});
+const FullSchemaConstraint = z.object({
+	type: z.literal("constraint"),
+	oid: z.number(),
+	schemaName: Identifier,
+	tableName: Identifier,
+	constraintName: Identifier,
+	constraintType: z.enum([
+		"check",
+		"foreign_key",
+		"not_null",
+		"primary_key",
+		"unique",
+		"trigger",
+		"exclusion"
+	]).or(z.string()),
+	definition: z.string(),
+	isDeferrable: z.boolean().optional(),
+	isInitiallyDeferred: z.boolean().optional(),
+	isValidated: z.boolean().optional(),
+	backingIndexOid: z.number().optional()
+});
+const FullSchemaFunction = z.object({
+	type: z.literal("function"),
+	schemaName: Identifier,
+	objectName: Identifier,
+	objectType: z.enum([
+		"function",
+		"procedure",
+		"aggregate",
+		"window function"
+	]),
+	identityArguments: z.string().optional(),
+	definition: z.string()
+});
+const FullSchemaExtension = z.object({
+	extensionName: z.string(),
+	version: z.string(),
+	schemaName: Identifier
+});
+const FullSchemaView = z.object({
+	type: z.literal("view"),
+	schemaName: Identifier,
+	viewName: Identifier,
+	objectType: z.enum(["view", "materialized_view"]),
+	definition: z.string(),
+	tablespace: z.string().optional()
+});
+const FullSchemaTypeConstraint = z.object({
+	name: Identifier,
+	definition: z.string()
+});
+const FullSchemaCompositeAttribute = z.object({
+	type: z.literal("compositeAttribute"),
+	name: Identifier,
+	attributeType: z.string(),
+	collation: Identifier.optional()
+});
+const FullSchemaType = z.object({
+	type: z.literal("type"),
+	schemaName: Identifier,
+	typeName: Identifier,
+	typeCategory: z.enum([
+		"enum",
+		"domain",
+		"composite"
+	]),
+	enumLabels: z.array(z.string()).optional(),
+	domainBaseType: z.string().optional(),
+	domainIsNotNull: z.boolean().optional(),
+	domainDefault: z.string().optional(),
+	domainConstraints: z.array(FullSchemaTypeConstraint).optional(),
+	compositeAttributes: z.array(FullSchemaCompositeAttribute).optional()
+});
+const FullSchemaTrigger = z.object({
+	schemaName: Identifier,
+	tableName: Identifier,
+	triggerName: Identifier,
+	definition: z.string(),
+	enabledMode: z.string()
+});
+const FullSchema = z.object({
+	indexes: z.array(FullSchemaIndex).default([]),
+	tables: z.array(FullSchemaTable).default([]),
+	constraints: z.array(FullSchemaConstraint).default([]),
+	functions: z.array(FullSchemaFunction).default([]),
+	extensions: z.array(FullSchemaExtension).default([]),
+	views: z.array(FullSchemaView).default([]),
+	types: z.array(FullSchemaType).default([]),
+	triggers: z.array(FullSchemaTrigger).default([])
+});
+async function dumpSchema(db) {
+	const rows = await db.exec(SCHEMA_DUMP_SQL);
+	return FullSchema.parse(rows[0]?.result ?? {});
+}
+//#endregion
+export { FullSchema, FullSchemaColumn, FullSchemaCompositeAttribute, FullSchemaConstraint, FullSchemaExtension, FullSchemaFunction, FullSchemaIncludedColumn, FullSchemaIndex, FullSchemaKeyColumn, FullSchemaTable, FullSchemaTrigger, FullSchemaType, FullSchemaTypeConstraint, FullSchemaView, dumpSchema };
+
+//# sourceMappingURL=schema.mjs.map

package/dist/schema.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema.mjs","names":[],"sources":["../src/schema.ts"],"sourcesContent":["import { z } from \"zod\";\nimport { SCHEMA_DUMP_SQL } from \"./schema-dump.js\";\nimport type { Postgres } from \"./sql/database.js\";\nimport { PgIdentifier } from \"./sql/pg-identifier.js\";\n\nconst Identifier = z.codec(z.string(), z.custom<PgIdentifier>(), {\n  encode: (v) => v.toString(),\n  decode: (v) => PgIdentifier.fromString(v),\n});\n\nexport const FullSchemaKeyColumn = z.object({\n  type: z.literal(\"indexColumn\"),\n  name: Identifier,\n  order: z.enum([\"ASC\", \"DESC\"]).optional(),\n  nulls: z.enum([\"FIRST\", \"LAST\"]).optional(),\n  opclass: z.string().optional(),\n  collation: z.string().optional(),\n});\n\nexport type FullSchemaKeyColumn = z.infer<typeof FullSchemaKeyColumn>;\n\nexport const FullSchemaIncludedColumn = z.object({\n  name: Identifier,\n});\n\nexport type FullSchemaIncludedColumn = z.infer<typeof FullSchemaIncludedColumn>;\n\nexport const FullSchemaIndex = z.object({\n  type: z.literal(\"index\"),\n  oid: z.number(),\n  schemaName: Identifier,\n  tableName: Identifier,\n  indexName: Identifier,\n  indexType: z.string(),\n  isUnique: z.boolean(),\n  isPrimary: z.boolean(),\n  isClustered: z.boolean(),\n  wherePredicate: z.string().optional(),\n  tablespace: z.string().optional(),\n  keyColumns: z.array(FullSchemaKeyColumn),\n  includedColumns: z.array(FullSchemaIncludedColumn).optional(),\n});\n\nexport type FullSchemaIndex = z.infer<typeof FullSchemaIndex>;\n\nexport const FullSchemaColumn = z.object({\n  type: z.literal(\"column\"),\n  name: Identifier,\n  order: z.number(),\n  columnType: z.string(),\n  isNullable: z.boolean(),\n  defaultValue: z.string().optional(),\n  dropped: z.boolean(),\n  collation: z.string().optional(),\n  storage: z.enum([\"plain\", \"main\", \"external\", \"extended\"]).optional(),\n  isIdentity: z.enum([\"always\", \"by default\"]).optional(),\n});\n\nexport type FullSchemaColumn = z.infer<typeof FullSchemaColumn>;\n\nexport const FullSchemaTable = z.object({\n  type: z.literal(\"table\"),\n  oid: z.number(),\n  schemaName: Identifier,\n  tableName: Identifier,\n  tablespace: z.string().optional(),\n  partitionKeyDef: z.string().optional(),\n  columns: z.array(FullSchemaColumn).default([]),\n});\n\nexport type FullSchemaTable = z.infer<typeof FullSchemaTable>;\n\nexport const FullSchemaConstraint = z.object({\n  type: z.literal(\"constraint\"),\n  oid: z.number(),\n  schemaName: Identifier,\n  tableName: Identifier,\n  constraintName: Identifier,\n  constraintType: z\n    .enum([\n      \"check\",\n      \"foreign_key\",\n      \"not_null\",\n      \"primary_key\",\n      \"unique\",\n      \"trigger\",\n      \"exclusion\",\n    ])\n    .or(z.string()),\n  definition: z.string(),\n  isDeferrable: z.boolean().optional(),\n  isInitiallyDeferred: z.boolean().optional(),\n  isValidated: z.boolean().optional(),\n  backingIndexOid: z.number().optional(),\n});\n\nexport type FullSchemaConstraint = z.infer<typeof FullSchemaConstraint>;\n\nexport const FullSchemaFunction = z.object({\n  type: z.literal(\"function\"),\n  schemaName: Identifier,\n  objectName: Identifier,\n  objectType: z.enum([\"function\", \"procedure\", \"aggregate\", \"window function\"]),\n  identityArguments: z.string().optional(),\n  definition: z.string(),\n});\n\nexport type FullSchemaFunction = z.infer<typeof FullSchemaFunction>;\n\nexport const FullSchemaExtension = z.object({\n  extensionName: z.string(),\n  version: z.string(),\n  schemaName: Identifier,\n});\n\nexport type FullSchemaExtension = z.infer<typeof FullSchemaExtension>;\n\nexport const FullSchemaView = z.object({\n  type: z.literal(\"view\"),\n  schemaName: Identifier,\n  viewName: Identifier,\n  objectType: z.enum([\"view\", \"materialized_view\"]),\n  definition: z.string(),\n  tablespace: z.string().optional(),\n});\n\nexport type FullSchemaView = z.infer<typeof FullSchemaView>;\n\nexport const FullSchemaTypeConstraint = z.object({\n  name: Identifier,\n  definition: z.string(),\n});\n\nexport type FullSchemaTypeConstraint = z.infer<typeof FullSchemaTypeConstraint>;\n\nexport const FullSchemaCompositeAttribute = z.object({\n  type: z.literal(\"compositeAttribute\"),\n  name: Identifier,\n  attributeType: z.string(),\n  collation: Identifier.optional(),\n});\n\nexport type FullSchemaCompositeAttribute = z.infer<\n  typeof FullSchemaCompositeAttribute\n>;\n\nexport const FullSchemaType = z.object({\n  type: z.literal(\"type\"),\n  schemaName: Identifier,\n  typeName: Identifier,\n  typeCategory: z.enum([\"enum\", \"domain\", \"composite\"]),\n  enumLabels: z.array(z.string()).optional(),\n  domainBaseType: z.string().optional(),\n  domainIsNotNull: z.boolean().optional(),\n  domainDefault: z.string().optional(),\n  domainConstraints: z.array(FullSchemaTypeConstraint).optional(),\n  compositeAttributes: z.array(FullSchemaCompositeAttribute).optional(),\n});\n\nexport type FullSchemaType = z.infer<typeof FullSchemaType>;\n\nexport const FullSchemaTrigger = z.object({\n  schemaName: Identifier,\n  tableName: Identifier,\n  triggerName: Identifier,\n  definition: z.string(),\n  enabledMode: z.string(),\n});\n\nexport type FullSchemaTrigger = z.infer<typeof FullSchemaTrigger>;\n\nexport const FullSchema = z.object({\n  indexes: z.array(FullSchemaIndex).default([]),\n  tables: z.array(FullSchemaTable).default([]),\n  constraints: z.array(FullSchemaConstraint).default([]),\n  functions: z.array(FullSchemaFunction).default([]),\n  extensions: z.array(FullSchemaExtension).default([]),\n  views: z.array(FullSchemaView).default([]),\n  types: z.array(FullSchemaType).default([]),\n  triggers: z.array(FullSchemaTrigger).default([]),\n});\n\nexport type FullSchema = z.infer<typeof FullSchema>;\n\nexport async function dumpSchema(db: Postgres): Promise<FullSchema> {\n  const rows = await db.exec<{ result: FullSchema }>(SCHEMA_DUMP_SQL);\n  return FullSchema.parse(rows[0]?.result ?? {});\n}\n"],"mappings":"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"}

package/dist/sql/database.d.cts

@@ -4,7 +4,7 @@ import { PgIdentifier } from "./pg-identifier.cjs";
 import { z } from "zod";
 
 //#region src/sql/database.d.ts
-declare const PostgresVersion: z.core.$ZodBranded<z.ZodString, "PostgresVersion">;
+declare const PostgresVersion: z.core.$ZodBranded<z.ZodString, "PostgresVersion", "out">;
 type PostgresVersion = z.infer<typeof PostgresVersion>;
 interface PostgresTransaction {
   /**

package/dist/sql/database.d.mts

@@ -4,7 +4,7 @@ import { PgIdentifier } from "./pg-identifier.mjs";
 import { z } from "zod";
 
 //#region src/sql/database.d.ts
-declare const PostgresVersion: z.core.$ZodBranded<z.ZodString, "PostgresVersion">;
+declare const PostgresVersion: z.core.$ZodBranded<z.ZodString, "PostgresVersion", "out">;
 type PostgresVersion = z.infer<typeof PostgresVersion>;
 interface PostgresTransaction {
   /**

package/dist/sql/indexes.cjs

@@ -1,16 +1,65 @@
 "use client";
 //#region src/sql/indexes.ts
 function isIndexSupported(index) {
-	return index.index_type === "btree" || index.index_type === "gin";
+	return index.indexType === "btree" || index.indexType === "gin";
 }
 /**
 * Doesn't necessarily decide whether the index can be dropped but can be
 * used to not even try dropping indexes that _definitely_ cannot be dropped
 */
 function isIndexProbablyDroppable(index) {
-	return !index.is_primary && !index.is_unique;
+	return !index.isPrimary && !index.isUnique;
+}
+function columnsEqual(a, b) {
+	if (a.length !== b.length) return false;
+	for (let i = 0; i < a.length; i++) if (a[i].name.toString() !== b[i].name.toString() || (a[i].order ?? null) !== (b[i].order ?? null) || (a[i].opclass ?? null) !== (b[i].opclass ?? null)) return false;
+	return true;
+}
+function indexesAreEqual(a, b) {
+	return a.schemaName.toString() === b.schemaName.toString() && a.tableName.toString() === b.tableName.toString() && a.indexType === b.indexType && (a.wherePredicate ?? null) === (b.wherePredicate ?? null) && columnsEqual(a.keyColumns, b.keyColumns);
+}
+function sharedPrefixColumns(shorter, longer) {
+	if (shorter.schemaName.toString() !== longer.schemaName.toString() || shorter.tableName.toString() !== longer.tableName.toString() || shorter.indexType !== longer.indexType || shorter.indexType !== "btree" || shorter.wherePredicate !== void 0 || longer.wherePredicate !== void 0 || shorter.keyColumns.length >= longer.keyColumns.length) return null;
+	for (let i = 0; i < shorter.keyColumns.length; i++) {
+		const s = shorter.keyColumns[i];
+		const l = longer.keyColumns[i];
+		if (s.name.toString() !== l.name.toString() || (s.order ?? null) !== (l.order ?? null) || (s.opclass ?? null) !== (l.opclass ?? null)) return null;
+	}
+	return shorter.keyColumns;
+}
+function groupDuplicateIndexes(indexes) {
+	const groups = [];
+	for (const index of indexes) {
+		const existing = groups.find((g) => g.kind === "exact" && indexesAreEqual(g.indexes[0], index));
+		if (existing) existing.indexes.push(index);
+		else groups.push({
+			kind: "exact",
+			indexes: [index]
+		});
+	}
+	const exactGroups = groups.filter((g) => g.indexes.length > 1);
+	const representatives = groups.filter((g) => g.indexes.length === 1).map((g) => g.indexes[0]);
+	const prefixGroups = [];
+	for (const shorter of representatives) {
+		const existing = prefixGroups.find((g) => g.indexes.some((idx) => sharedPrefixColumns(shorter, idx) !== null || sharedPrefixColumns(idx, shorter) !== null));
+		if (existing) {
+			if (!existing.indexes.includes(shorter)) existing.indexes.push(shorter);
+		} else {
+			const longer = representatives.find((idx) => idx !== shorter && sharedPrefixColumns(shorter, idx) !== null);
+			if (longer) {
+				const sharedPrefix = sharedPrefixColumns(shorter, longer);
+				prefixGroups.push({
+					kind: "prefix",
+					indexes: [longer, shorter],
+					sharedPrefix
+				});
+			}
+		}
+	}
+	return [...exactGroups, ...prefixGroups];
 }
 //#endregion
+exports.groupDuplicateIndexes = groupDuplicateIndexes;
 exports.isIndexProbablyDroppable = isIndexProbablyDroppable;
 exports.isIndexSupported = isIndexSupported;
 

package/dist/sql/indexes.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"indexes.cjs","names":[],"sources":["../../src/sql/indexes.ts"],"sourcesContent":["import type { IndexedTable } from \"../optimizer/statistics.js\";\n\nexport function isIndexSupported(index: IndexedTable) {\n  return index.index_type === \"btree\" || index.index_type === \"gin\";\n}\n\n/**\n * Doesn't necessarily decide whether the index can be dropped but can be\n * used to not even try dropping indexes that _definitely_ cannot be dropped\n */\nexport function isIndexProbablyDroppable(index: IndexedTable) {\n  /* TODO: until we have a better solution, this is the best we have */\n  /* The is_unique check is problematic only if the column is declared as unique */\n  return !index.is_primary && !index.is_unique;\n}\n"],"mappings":";;AAEA,SAAgB,iBAAiB,OAAqB;AACpD,QAAO,MAAM,eAAe,WAAW,MAAM,eAAe;;;;;;AAO9D,SAAgB,yBAAyB,OAAqB;AAG5D,QAAO,CAAC,MAAM,cAAc,CAAC,MAAM"}
+{"version":3,"file":"indexes.cjs","names":[],"sources":["../../src/sql/indexes.ts"],"sourcesContent":["import type { FullSchemaIndex } from \"../schema.js\";\n\ntype IndexTypeHint = { indexType: string };\ntype IndexDropHint = { isPrimary: boolean; isUnique: boolean };\n\nexport function isIndexSupported(index: IndexTypeHint) {\n  return index.indexType === \"btree\" || index.indexType === \"gin\";\n}\n\n/**\n * Doesn't necessarily decide whether the index can be dropped but can be\n * used to not even try dropping indexes that _definitely_ cannot be dropped\n */\nexport function isIndexProbablyDroppable(index: IndexDropHint) {\n  /* TODO: until we have a better solution, this is the best we have */\n  /* The is_unique check is problematic only if the column is declared as unique */\n  return !index.isPrimary && !index.isUnique;\n}\n\nexport type DuplicateIndexGroup =\n  | { kind: \"exact\"; indexes: FullSchemaIndex[] }\n  | {\n      kind: \"prefix\";\n      indexes: FullSchemaIndex[];\n      sharedPrefix: FullSchemaIndex[\"keyColumns\"];\n    };\n\nfunction columnsEqual(\n  a: FullSchemaIndex[\"keyColumns\"],\n  b: FullSchemaIndex[\"keyColumns\"],\n): boolean {\n  if (a.length !== b.length) return false;\n  for (let i = 0; i < a.length; i++) {\n    if (\n      a[i].name.toString() !== b[i].name.toString() ||\n      (a[i].order ?? null) !== (b[i].order ?? null) ||\n      (a[i].opclass ?? null) !== (b[i].opclass ?? null)\n    ) {\n      return false;\n    }\n  }\n  return true;\n}\n\nfunction indexesAreEqual(a: FullSchemaIndex, b: FullSchemaIndex): boolean {\n  return (\n    a.schemaName.toString() === b.schemaName.toString() &&\n    a.tableName.toString() === b.tableName.toString() &&\n    a.indexType === b.indexType &&\n    (a.wherePredicate ?? null) === (b.wherePredicate ?? null) &&\n    columnsEqual(a.keyColumns, b.keyColumns)\n  );\n}\n\nfunction sharedPrefixColumns(\n  shorter: FullSchemaIndex,\n  longer: FullSchemaIndex,\n): FullSchemaIndex[\"keyColumns\"] | null {\n  if (\n    shorter.schemaName.toString() !== longer.schemaName.toString() ||\n    shorter.tableName.toString() !== longer.tableName.toString() ||\n    shorter.indexType !== longer.indexType ||\n    shorter.indexType !== \"btree\" ||\n    shorter.wherePredicate !== undefined ||\n    longer.wherePredicate !== undefined ||\n    shorter.keyColumns.length >= longer.keyColumns.length\n  ) {\n    return null;\n  }\n  for (let i = 0; i < shorter.keyColumns.length; i++) {\n    const s = shorter.keyColumns[i];\n    const l = longer.keyColumns[i];\n    if (\n      s.name.toString() !== l.name.toString() ||\n      (s.order ?? null) !== (l.order ?? null) ||\n      (s.opclass ?? null) !== (l.opclass ?? null)\n    ) {\n      return null;\n    }\n  }\n  return shorter.keyColumns;\n}\n\nexport function groupDuplicateIndexes(\n  indexes: FullSchemaIndex[],\n): DuplicateIndexGroup[] {\n  const groups: DuplicateIndexGroup[] = [];\n\n  for (const index of indexes) {\n    const existing = groups.find(\n      (g) => g.kind === \"exact\" && indexesAreEqual(g.indexes[0], index),\n    );\n    if (existing) {\n      existing.indexes.push(index);\n    } else {\n      groups.push({ kind: \"exact\", indexes: [index] });\n    }\n  }\n\n  const exactGroups = groups.filter((g) => g.indexes.length > 1);\n\n  const representatives = groups\n    .filter((g) => g.indexes.length === 1)\n    .map((g) => g.indexes[0]);\n\n  const prefixGroups: Extract<DuplicateIndexGroup, { kind: \"prefix\" }>[] = [];\n\n  for (const shorter of representatives) {\n    const existing = prefixGroups.find((g) =>\n      g.indexes.some(\n        (idx) =>\n          sharedPrefixColumns(shorter, idx) !== null ||\n          sharedPrefixColumns(idx, shorter) !== null,\n      ),\n    );\n    if (existing) {\n      if (!existing.indexes.includes(shorter)) {\n        existing.indexes.push(shorter);\n      }\n    } else {\n      const longer = representatives.find(\n        (idx) => idx !== shorter && sharedPrefixColumns(shorter, idx) !== null,\n      );\n      if (longer) {\n        const sharedPrefix = sharedPrefixColumns(shorter, longer)!;\n        prefixGroups.push({\n          kind: \"prefix\",\n          indexes: [longer, shorter],\n          sharedPrefix,\n        });\n      }\n    }\n  }\n\n  return [...exactGroups, ...prefixGroups];\n}\n"],"mappings":";;AAKA,SAAgB,iBAAiB,OAAsB;AACrD,QAAO,MAAM,cAAc,WAAW,MAAM,cAAc;;;;;;AAO5D,SAAgB,yBAAyB,OAAsB;AAG7D,QAAO,CAAC,MAAM,aAAa,CAAC,MAAM;;AAWpC,SAAS,aACP,GACA,GACS;AACT,KAAI,EAAE,WAAW,EAAE,OAAQ,QAAO;AAClC,MAAK,IAAI,IAAI,GAAG,IAAI,EAAE,QAAQ,IAC5B,KACE,EAAE,GAAG,KAAK,UAAU,KAAK,EAAE,GAAG,KAAK,UAAU,KAC5C,EAAE,GAAG,SAAS,WAAW,EAAE,GAAG,SAAS,UACvC,EAAE,GAAG,WAAW,WAAW,EAAE,GAAG,WAAW,MAE5C,QAAO;AAGX,QAAO;;AAGT,SAAS,gBAAgB,GAAoB,GAA6B;AACxE,QACE,EAAE,WAAW,UAAU,KAAK,EAAE,WAAW,UAAU,IACnD,EAAE,UAAU,UAAU,KAAK,EAAE,UAAU,UAAU,IACjD,EAAE,cAAc,EAAE,cACjB,EAAE,kBAAkB,WAAW,EAAE,kBAAkB,SACpD,aAAa,EAAE,YAAY,EAAE,WAAW;;AAI5C,SAAS,oBACP,SACA,QACsC;AACtC,KACE,QAAQ,WAAW,UAAU,KAAK,OAAO,WAAW,UAAU,IAC9D,QAAQ,UAAU,UAAU,KAAK,OAAO,UAAU,UAAU,IAC5D,QAAQ,cAAc,OAAO,aAC7B,QAAQ,cAAc,WACtB,QAAQ,mBAAmB,KAAA,KAC3B,OAAO,mBAAmB,KAAA,KAC1B,QAAQ,WAAW,UAAU,OAAO,WAAW,OAE/C,QAAO;AAET,MAAK,IAAI,IAAI,GAAG,IAAI,QAAQ,WAAW,QAAQ,KAAK;EAClD,MAAM,IAAI,QAAQ,WAAW;EAC7B,MAAM,IAAI,OAAO,WAAW;AAC5B,MACE,EAAE,KAAK,UAAU,KAAK,EAAE,KAAK,UAAU,KACtC,EAAE,SAAS,WAAW,EAAE,SAAS,UACjC,EAAE,WAAW,WAAW,EAAE,WAAW,MAEtC,QAAO;;AAGX,QAAO,QAAQ;;AAGjB,SAAgB,sBACd,SACuB;CACvB,MAAM,SAAgC,EAAE;AAExC,MAAK,MAAM,SAAS,SAAS;EAC3B,MAAM,WAAW,OAAO,MACrB,MAAM,EAAE,SAAS,WAAW,gBAAgB,EAAE,QAAQ,IAAI,MAAM,CAClE;AACD,MAAI,SACF,UAAS,QAAQ,KAAK,MAAM;MAE5B,QAAO,KAAK;GAAE,MAAM;GAAS,SAAS,CAAC,MAAM;GAAE,CAAC;;CAIpD,MAAM,cAAc,OAAO,QAAQ,MAAM,EAAE,QAAQ,SAAS,EAAE;CAE9D,MAAM,kBAAkB,OACrB,QAAQ,MAAM,EAAE,QAAQ,WAAW,EAAE,CACrC,KAAK,MAAM,EAAE,QAAQ,GAAG;CAE3B,MAAM,eAAmE,EAAE;AAE3E,MAAK,MAAM,WAAW,iBAAiB;EACrC,MAAM,WAAW,aAAa,MAAM,MAClC,EAAE,QAAQ,MACP,QACC,oBAAoB,SAAS,IAAI,KAAK,QACtC,oBAAoB,KAAK,QAAQ,KAAK,KACzC,CACF;AACD,MAAI;OACE,CAAC,SAAS,QAAQ,SAAS,QAAQ,CACrC,UAAS,QAAQ,KAAK,QAAQ;SAE3B;GACL,MAAM,SAAS,gBAAgB,MAC5B,QAAQ,QAAQ,WAAW,oBAAoB,SAAS,IAAI,KAAK,KACnE;AACD,OAAI,QAAQ;IACV,MAAM,eAAe,oBAAoB,SAAS,OAAO;AACzD,iBAAa,KAAK;KAChB,MAAM;KACN,SAAS,CAAC,QAAQ,QAAQ;KAC1B;KACD,CAAC;;;;AAKR,QAAO,CAAC,GAAG,aAAa,GAAG,aAAa"}