@proofkit/fmodata 0.1.0-alpha.13 → 0.1.0-alpha.15

package/dist/esm/client/base-table.d.ts

@@ -1,128 +0,0 @@
-import { StandardSchemaV1 } from '@standard-schema/spec';
-/**
- * BaseTable defines the schema and configuration for a table.
- * Use `defineBaseTable()` to create instances with proper type inference.
- *
- * @template Schema - Record of field names to StandardSchemaV1 validators
- * @template IdField - The name of the primary key field (optional, automatically read-only)
- * @template Required - Additional field names to require on insert (beyond auto-inferred required fields)
- * @template ReadOnly - Field names that cannot be modified via insert/update (idField is automatically read-only)
- *
- * @example Basic table with auto-inferred required fields
- * ```ts
- * import { z } from "zod";
- * import { defineBaseTable } from "@proofkit/fmodata";
- *
- * const usersTable = defineBaseTable({
- *   schema: {
- *     id: z.string(),               // Auto-required (not nullable), auto-readOnly (idField)
- *     name: z.string(),             // Auto-required (not nullable)
- *     email: z.string().nullable(), // Optional (nullable)
- *   },
- *   idField: "id",
- * });
- * // On insert: name is required, email is optional (id is excluded - readOnly)
- * // On update: name and email available (id is excluded - readOnly)
- * ```
- *
- * @example Table with additional required and readOnly fields
- * ```ts
- * import { z } from "zod";
- * import { defineBaseTable } from "@proofkit/fmodata";
- *
- * const usersTable = defineBaseTable({
- *   schema: {
- *     id: z.string(),                    // Auto-required, auto-readOnly (idField)
- *     createdAt: z.string(),             // Read-only system field
- *     name: z.string(),                  // Auto-required
- *     email: z.string().nullable(),      // Optional by default...
- *     legacyField: z.string().nullable(), // Optional by default...
- *   },
- *   idField: "id",
- *   required: ["legacyField"],  // Make legacyField required for new inserts
- *   readOnly: ["createdAt"],    // Exclude from insert/update
- * });
- * // On insert: name and legacyField required; email optional (id and createdAt excluded)
- * // On update: all fields optional (id and createdAt excluded)
- * ```
- *
- * @example Table with multiple read-only fields
- * ```ts
- * import { z } from "zod";
- * import { defineBaseTable } from "@proofkit/fmodata";
- *
- * const usersTable = defineBaseTable({
- *   schema: {
- *     id: z.string(),
- *     createdAt: z.string(),
- *     modifiedAt: z.string(),
- *     createdBy: z.string(),
- *     notes: z.string().nullable(),
- *   },
- *   idField: "id",
- *   readOnly: ["createdAt", "modifiedAt", "createdBy"],
- * });
- * // On insert/update: only notes is available (id and system fields excluded)
- * ```
- */
-export declare class BaseTable<Schema extends Record<string, StandardSchemaV1> = any, IdField extends keyof Schema | undefined = undefined, Required extends readonly (keyof Schema | (string & {}))[] = readonly [], ReadOnly extends readonly (keyof Schema | (string & {}))[] = readonly []> {
-    readonly schema: Schema;
-    readonly idField?: IdField;
-    readonly required?: Required;
-    readonly readOnly?: ReadOnly;
-    readonly fmfIds?: Record<keyof Schema | (string & {}), `FMFID:${string}`>;
-    constructor(config: {
-        schema: Schema;
-        idField?: IdField;
-        required?: Required;
-        readOnly?: ReadOnly;
-        fmfIds?: Record<string, `FMFID:${string}`>;
-    });
-    /**
-     * Returns the FileMaker field ID (FMFID) for a given field name, or the field name itself if not using IDs.
-     * @param fieldName - The field name to get the ID for
-     * @returns The FMFID string or the original field name
-     */
-    getFieldId(fieldName: keyof Schema): string;
-    /**
-     * Returns the field name for a given FileMaker field ID (FMFID), or the ID itself if not found.
-     * @param fieldId - The FMFID to get the field name for
-     * @returns The field name or the original ID
-     */
-    getFieldName(fieldId: string): string;
-    /**
-     * Returns true if this BaseTable is using FileMaker field IDs.
-     */
-    isUsingFieldIds(): boolean;
-}
-/**
- * Creates a BaseTable with proper TypeScript type inference.
- *
- * Use this function to create BaseTable instances with full type safety.
- *
- * @example Without entity IDs
- * ```ts
- * const users = defineBaseTable({
- *   schema: { id: z.string(), name: z.string() },
- *   idField: "id",
- * });
- * ```
- *
- * @example With entity IDs (FileMaker field IDs)
- * ```ts
- * const products = defineBaseTable({
- *   schema: { id: z.string(), name: z.string() },
- *   idField: "id",
- *   fmfIds: { id: "FMFID:1", name: "FMFID:2" },
- * });
- * ```
- */
-export declare function defineBaseTable<const Schema extends Record<string, StandardSchemaV1>, IdField extends keyof Schema | undefined = undefined, const Required extends readonly (keyof Schema | (string & {}))[] = readonly [], const ReadOnly extends readonly (keyof Schema | (string & {}))[] = readonly []>(config: {
-    schema: Schema;
-    idField?: IdField;
-    required?: Required;
-    readOnly?: ReadOnly;
-    fmfIds?: {
-        [K in keyof Schema | (string & {})]: `FMFID:${string}`;
-    };
-}): BaseTable<Schema, IdField, Required, ReadOnly>;

package/dist/esm/client/base-table.js

@@ -1,57 +0,0 @@
-var __defProp = Object.defineProperty;
-var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
-class BaseTable {
-  constructor(config) {
-    __publicField(this, "schema");
-    __publicField(this, "idField");
-    __publicField(this, "required");
-    __publicField(this, "readOnly");
-    __publicField(this, "fmfIds");
-    this.schema = config.schema;
-    this.idField = config.idField;
-    this.required = config.required;
-    this.readOnly = config.readOnly;
-    this.fmfIds = config.fmfIds;
-  }
-  /**
-   * Returns the FileMaker field ID (FMFID) for a given field name, or the field name itself if not using IDs.
-   * @param fieldName - The field name to get the ID for
-   * @returns The FMFID string or the original field name
-   */
-  getFieldId(fieldName) {
-    if (this.fmfIds && fieldName in this.fmfIds) {
-      return this.fmfIds[fieldName];
-    }
-    return String(fieldName);
-  }
-  /**
-   * Returns the field name for a given FileMaker field ID (FMFID), or the ID itself if not found.
-   * @param fieldId - The FMFID to get the field name for
-   * @returns The field name or the original ID
-   */
-  getFieldName(fieldId) {
-    if (this.fmfIds) {
-      for (const [fieldName, fmfId] of Object.entries(this.fmfIds)) {
-        if (fmfId === fieldId) {
-          return fieldName;
-        }
-      }
-    }
-    return fieldId;
-  }
-  /**
-   * Returns true if this BaseTable is using FileMaker field IDs.
-   */
-  isUsingFieldIds() {
-    return this.fmfIds !== void 0;
-  }
-}
-function defineBaseTable(config) {
-  return new BaseTable(config);
-}
-export {
-  BaseTable,
-  defineBaseTable
-};
-//# sourceMappingURL=base-table.js.map

package/dist/esm/client/base-table.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"base-table.js","sources":["../../../src/client/base-table.ts"],"sourcesContent":["import { StandardSchemaV1 } from \"@standard-schema/spec\";\n\n/**\n * BaseTable defines the schema and configuration for a table.\n * Use `defineBaseTable()` to create instances with proper type inference.\n *\n * @template Schema - Record of field names to StandardSchemaV1 validators\n * @template IdField - The name of the primary key field (optional, automatically read-only)\n * @template Required - Additional field names to require on insert (beyond auto-inferred required fields)\n * @template ReadOnly - Field names that cannot be modified via insert/update (idField is automatically read-only)\n *\n * @example Basic table with auto-inferred required fields\n * ```ts\n * import { z } from \"zod\";\n * import { defineBaseTable } from \"@proofkit/fmodata\";\n *\n * const usersTable = defineBaseTable({\n *   schema: {\n *     id: z.string(),               // Auto-required (not nullable), auto-readOnly (idField)\n *     name: z.string(),             // Auto-required (not nullable)\n *     email: z.string().nullable(), // Optional (nullable)\n *   },\n *   idField: \"id\",\n * });\n * // On insert: name is required, email is optional (id is excluded - readOnly)\n * // On update: name and email available (id is excluded - readOnly)\n * ```\n *\n * @example Table with additional required and readOnly fields\n * ```ts\n * import { z } from \"zod\";\n * import { defineBaseTable } from \"@proofkit/fmodata\";\n *\n * const usersTable = defineBaseTable({\n *   schema: {\n *     id: z.string(),                    // Auto-required, auto-readOnly (idField)\n *     createdAt: z.string(),             // Read-only system field\n *     name: z.string(),                  // Auto-required\n *     email: z.string().nullable(),      // Optional by default...\n *     legacyField: z.string().nullable(), // Optional by default...\n *   },\n *   idField: \"id\",\n *   required: [\"legacyField\"],  // Make legacyField required for new inserts\n *   readOnly: [\"createdAt\"],    // Exclude from insert/update\n * });\n * // On insert: name and legacyField required; email optional (id and createdAt excluded)\n * // On update: all fields optional (id and createdAt excluded)\n * ```\n *\n * @example Table with multiple read-only fields\n * ```ts\n * import { z } from \"zod\";\n * import { defineBaseTable } from \"@proofkit/fmodata\";\n *\n * const usersTable = defineBaseTable({\n *   schema: {\n *     id: z.string(),\n *     createdAt: z.string(),\n *     modifiedAt: z.string(),\n *     createdBy: z.string(),\n *     notes: z.string().nullable(),\n *   },\n *   idField: \"id\",\n *   readOnly: [\"createdAt\", \"modifiedAt\", \"createdBy\"],\n * });\n * // On insert/update: only notes is available (id and system fields excluded)\n * ```\n */\nexport class BaseTable<\n  Schema extends Record<string, StandardSchemaV1> = any,\n  IdField extends keyof Schema | undefined = undefined,\n  Required extends readonly (keyof Schema | (string & {}))[] = readonly [],\n  ReadOnly extends readonly (keyof Schema | (string & {}))[] = readonly [],\n> {\n  public readonly schema: Schema;\n  public readonly idField?: IdField;\n  public readonly required?: Required;\n  public readonly readOnly?: ReadOnly;\n  public readonly fmfIds?: Record<\n    keyof Schema | (string & {}),\n    `FMFID:${string}`\n  >;\n\n  constructor(config: {\n    schema: Schema;\n    idField?: IdField;\n    required?: Required;\n    readOnly?: ReadOnly;\n    fmfIds?: Record<string, `FMFID:${string}`>;\n  }) {\n    this.schema = config.schema;\n    this.idField = config.idField;\n    this.required = config.required;\n    this.readOnly = config.readOnly;\n    this.fmfIds = config.fmfIds as\n      | Record<keyof Schema, `FMFID:${string}`>\n      | undefined;\n  }\n\n  /**\n   * Returns the FileMaker field ID (FMFID) for a given field name, or the field name itself if not using IDs.\n   * @param fieldName - The field name to get the ID for\n   * @returns The FMFID string or the original field name\n   */\n  getFieldId(fieldName: keyof Schema): string {\n    if (this.fmfIds && fieldName in this.fmfIds) {\n      return this.fmfIds[fieldName];\n    }\n    return String(fieldName);\n  }\n\n  /**\n   * Returns the field name for a given FileMaker field ID (FMFID), or the ID itself if not found.\n   * @param fieldId - The FMFID to get the field name for\n   * @returns The field name or the original ID\n   */\n  getFieldName(fieldId: string): string {\n    if (this.fmfIds) {\n      // Search for the field name that corresponds to this FMFID\n      for (const [fieldName, fmfId] of Object.entries(this.fmfIds)) {\n        if (fmfId === fieldId) {\n          return fieldName;\n        }\n      }\n    }\n    return fieldId;\n  }\n\n  /**\n   * Returns true if this BaseTable is using FileMaker field IDs.\n   */\n  isUsingFieldIds(): boolean {\n    return this.fmfIds !== undefined;\n  }\n}\n\n/**\n * Creates a BaseTable with proper TypeScript type inference.\n *\n * Use this function to create BaseTable instances with full type safety.\n *\n * @example Without entity IDs\n * ```ts\n * const users = defineBaseTable({\n *   schema: { id: z.string(), name: z.string() },\n *   idField: \"id\",\n * });\n * ```\n *\n * @example With entity IDs (FileMaker field IDs)\n * ```ts\n * const products = defineBaseTable({\n *   schema: { id: z.string(), name: z.string() },\n *   idField: \"id\",\n *   fmfIds: { id: \"FMFID:1\", name: \"FMFID:2\" },\n * });\n * ```\n */\nexport function defineBaseTable<\n  const Schema extends Record<string, StandardSchemaV1>,\n  IdField extends keyof Schema | undefined = undefined,\n  const Required extends readonly (\n    | keyof Schema\n    | (string & {})\n  )[] = readonly [],\n  const ReadOnly extends readonly (\n    | keyof Schema\n    | (string & {})\n  )[] = readonly [],\n>(config: {\n  schema: Schema;\n  idField?: IdField;\n  required?: Required;\n  readOnly?: ReadOnly;\n  fmfIds?: { [K in keyof Schema | (string & {})]: `FMFID:${string}` };\n}): BaseTable<Schema, IdField, Required, ReadOnly> {\n  return new BaseTable(config);\n}\n"],"names":[],"mappings":";;;AAoEO,MAAM,UAKX;AAAA,EAUA,YAAY,QAMT;AAfa;AACA;AACA;AACA;AACA;AAYd,SAAK,SAAS,OAAO;AACrB,SAAK,UAAU,OAAO;AACtB,SAAK,WAAW,OAAO;AACvB,SAAK,WAAW,OAAO;AACvB,SAAK,SAAS,OAAO;AAAA,EAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAUvB,WAAW,WAAiC;AAC1C,QAAI,KAAK,UAAU,aAAa,KAAK,QAAQ;AACpC,aAAA,KAAK,OAAO,SAAS;AAAA,IAAA;AAE9B,WAAO,OAAO,SAAS;AAAA,EAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQzB,aAAa,SAAyB;AACpC,QAAI,KAAK,QAAQ;AAEJ,iBAAA,CAAC,WAAW,KAAK,KAAK,OAAO,QAAQ,KAAK,MAAM,GAAG;AAC5D,YAAI,UAAU,SAAS;AACd,iBAAA;AAAA,QAAA;AAAA,MACT;AAAA,IACF;AAEK,WAAA;AAAA,EAAA;AAAA;AAAA;AAAA;AAAA,EAMT,kBAA2B;AACzB,WAAO,KAAK,WAAW;AAAA,EAAA;AAE3B;AAwBO,SAAS,gBAWd,QAMiD;AAC1C,SAAA,IAAI,UAAU,MAAM;AAC7B;"}

package/dist/esm/client/build-occurrences.d.ts

@@ -1,74 +0,0 @@
-import { TableOccurrence } from './table-occurrence.js';
-/**
- * Extract the name type from a TableOccurrence
- */
-type ExtractName<TO> = TO extends TableOccurrence<any, infer Name, any, any> ? Name : never;
-/**
- * Extract all names from an array of TableOccurrences as a union
- */
-type ExtractNames<TOs extends readonly TableOccurrence<any, any, any, any>[]> = ExtractName<TOs[number]>;
-/**
- * Find a TableOccurrence by name from an array
- */
-type FindByName<TOs extends readonly TableOccurrence<any, any, any, any>[], Name extends string> = Extract<TOs[number], TableOccurrence<any, Name, any, any>>;
-/**
- * Navigation configuration - maps TO names to arrays of navigation target names.
- * A table occurrence cannot navigate to itself.
- */
-type NavigationConfig<TOs extends readonly TableOccurrence<any, any, any, any>[]> = {
-    [K in ExtractNames<TOs>]?: Exclude<ExtractNames<TOs>, K>[];
-};
-/**
- * Resolve navigation config to actual TO record for a given TO name
- */
-type ResolveNavForTO<TOs extends readonly TableOccurrence<any, any, any, any>[], Nav extends NavigationConfig<TOs> | undefined, Name extends ExtractNames<TOs>> = Nav extends NavigationConfig<TOs> ? Nav[Name] extends infer NavNames extends string[] ? {
-    [K in NavNames[number]]: FindByName<TOs, K>;
-} : {} : {};
-/**
- * Build the result type - a tuple of TOs with navigation resolved
- */
-type BuildResult<TOs extends readonly TableOccurrence<any, any, any, any>[], Nav extends NavigationConfig<TOs> | undefined> = {
-    [K in keyof TOs]: TOs[K] extends TableOccurrence<infer BT, infer Name, any, infer DefSelect> ? Name extends ExtractNames<TOs> ? TableOccurrence<BT, Name, ResolveNavForTO<TOs, Nav, Name>, DefSelect> : TOs[K] : TOs[K];
-};
-/**
- * Builds TableOccurrences with navigation relationships resolved.
- *
- * This is the second phase of TO definition - after defining base TOs,
- * use this function to link them with navigation relationships.
- *
- * @example Full navigation
- * ```ts
- * const [contacts, users] = buildOccurrences({
- *   occurrences: [_contacts, _users],
- *   navigation: {
- *     contacts: ["users"],
- *     users: ["contacts"],
- *   },
- * });
- * ```
- *
- * @example Partial navigation
- * ```ts
- * const [contacts, users] = buildOccurrences({
- *   occurrences: [_contacts, _users],
- *   navigation: {
- *     contacts: ["users"],
- *   },
- * });
- * ```
- *
- * @example No navigation
- * ```ts
- * const [contacts, users] = buildOccurrences({
- *   occurrences: [_contacts, _users],
- * });
- * ```
- *
- * @param config - Configuration object with occurrences array and optional navigation
- * @returns Tuple of TableOccurrences with navigation resolved (same order as input)
- */
-export declare function buildOccurrences<const TOs extends readonly TableOccurrence<any, any, any, any>[], const Nav extends NavigationConfig<TOs> | undefined>(config: {
-    occurrences: TOs;
-    navigation?: Nav;
-}): BuildResult<TOs, Nav>;
-export {};

package/dist/esm/client/build-occurrences.js

@@ -1,31 +0,0 @@
-import { TableOccurrence } from "./table-occurrence.js";
-function buildOccurrences(config) {
-  const { occurrences, navigation } = config;
-  const toByName = /* @__PURE__ */ new Map();
-  for (const to of occurrences) {
-    toByName.set(to.name, to);
-  }
-  const result = occurrences.map((to) => {
-    const navNames = navigation == null ? void 0 : navigation[to.name];
-    const resolvedNav = {};
-    if (navNames) {
-      for (const navName of navNames) {
-        if (navName === to.name) {
-          throw new Error(
-            `TableOccurrence "${to.name}" cannot navigate to itself`
-          );
-        }
-        const targetTO = toByName.get(navName);
-        if (targetTO) {
-          resolvedNav[navName] = targetTO;
-        }
-      }
-    }
-    return TableOccurrence._withNavigation(to, resolvedNav);
-  });
-  return result;
-}
-export {
-  buildOccurrences
-};
-//# sourceMappingURL=build-occurrences.js.map

package/dist/esm/client/build-occurrences.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"build-occurrences.js","sources":["../../../src/client/build-occurrences.ts"],"sourcesContent":["import { TableOccurrence } from \"./table-occurrence\";\n\n/**\n * Extract the name type from a TableOccurrence\n */\ntype ExtractName<TO> =\n  TO extends TableOccurrence<any, infer Name, any, any> ? Name : never;\n\n/**\n * Extract all names from an array of TableOccurrences as a union\n */\ntype ExtractNames<TOs extends readonly TableOccurrence<any, any, any, any>[]> =\n  ExtractName<TOs[number]>;\n\n/**\n * Find a TableOccurrence by name from an array\n */\ntype FindByName<\n  TOs extends readonly TableOccurrence<any, any, any, any>[],\n  Name extends string,\n> = Extract<TOs[number], TableOccurrence<any, Name, any, any>>;\n\n/**\n * Navigation configuration - maps TO names to arrays of navigation target names.\n * A table occurrence cannot navigate to itself.\n */\ntype NavigationConfig<\n  TOs extends readonly TableOccurrence<any, any, any, any>[],\n> = {\n  [K in ExtractNames<TOs>]?: Exclude<ExtractNames<TOs>, K>[];\n};\n\n/**\n * Resolve navigation config to actual TO record for a given TO name\n */\ntype ResolveNavForTO<\n  TOs extends readonly TableOccurrence<any, any, any, any>[],\n  Nav extends NavigationConfig<TOs> | undefined,\n  Name extends ExtractNames<TOs>,\n> =\n  Nav extends NavigationConfig<TOs>\n    ? Nav[Name] extends infer NavNames extends string[]\n      ? {\n          [K in NavNames[number]]: FindByName<TOs, K>;\n        }\n      : {}\n    : {};\n\n/**\n * Build the result type - a tuple of TOs with navigation resolved\n */\ntype BuildResult<\n  TOs extends readonly TableOccurrence<any, any, any, any>[],\n  Nav extends NavigationConfig<TOs> | undefined,\n> = {\n  [K in keyof TOs]: TOs[K] extends TableOccurrence<\n    infer BT,\n    infer Name,\n    any,\n    infer DefSelect\n  >\n    ? Name extends ExtractNames<TOs>\n      ? TableOccurrence<BT, Name, ResolveNavForTO<TOs, Nav, Name>, DefSelect>\n      : TOs[K]\n    : TOs[K];\n};\n\n/**\n * Configuration object for buildOccurrences\n */\ntype BuildOccurrencesConfig<\n  TOs extends readonly TableOccurrence<any, any, any, any>[],\n> = {\n  occurrences: TOs;\n  navigation?: NavigationConfig<TOs>;\n};\n\n/**\n * Builds TableOccurrences with navigation relationships resolved.\n *\n * This is the second phase of TO definition - after defining base TOs,\n * use this function to link them with navigation relationships.\n *\n * @example Full navigation\n * ```ts\n * const [contacts, users] = buildOccurrences({\n *   occurrences: [_contacts, _users],\n *   navigation: {\n *     contacts: [\"users\"],\n *     users: [\"contacts\"],\n *   },\n * });\n * ```\n *\n * @example Partial navigation\n * ```ts\n * const [contacts, users] = buildOccurrences({\n *   occurrences: [_contacts, _users],\n *   navigation: {\n *     contacts: [\"users\"],\n *   },\n * });\n * ```\n *\n * @example No navigation\n * ```ts\n * const [contacts, users] = buildOccurrences({\n *   occurrences: [_contacts, _users],\n * });\n * ```\n *\n * @param config - Configuration object with occurrences array and optional navigation\n * @returns Tuple of TableOccurrences with navigation resolved (same order as input)\n */\nexport function buildOccurrences<\n  const TOs extends readonly TableOccurrence<any, any, any, any>[],\n  const Nav extends NavigationConfig<TOs> | undefined,\n>(config: { occurrences: TOs; navigation?: Nav }): BuildResult<TOs, Nav> {\n  const { occurrences, navigation } = config;\n\n  // Build a map of name -> TO for quick lookup\n  const toByName = new Map<string, TableOccurrence<any, any, any, any>>();\n  for (const to of occurrences) {\n    toByName.set(to.name, to);\n  }\n\n  // Build result array with navigation resolved\n  const result = occurrences.map((to) => {\n    const navNames = navigation?.[to.name as keyof typeof navigation] as\n      | string[]\n      | undefined;\n\n    // Resolve navigation names to actual TOs\n    const resolvedNav: Record<string, TableOccurrence<any, any, any, any>> = {};\n    if (navNames) {\n      for (const navName of navNames) {\n        // Prevent self-navigation\n        if (navName === to.name) {\n          throw new Error(\n            `TableOccurrence \"${to.name}\" cannot navigate to itself`,\n          );\n        }\n        const targetTO = toByName.get(navName);\n        if (targetTO) {\n          resolvedNav[navName] = targetTO;\n        }\n      }\n    }\n\n    // Create new TO with navigation using internal method\n    return TableOccurrence._withNavigation(to, resolvedNav);\n  });\n\n  return result as BuildResult<TOs, Nav>;\n}\n"],"names":[],"mappings":";AAkHO,SAAS,iBAGd,QAAuE;AACjE,QAAA,EAAE,aAAa,WAAA,IAAe;AAG9B,QAAA,+BAAe,IAAiD;AACtE,aAAW,MAAM,aAAa;AACnB,aAAA,IAAI,GAAG,MAAM,EAAE;AAAA,EAAA;AAI1B,QAAM,SAAS,YAAY,IAAI,CAAC,OAAO;AAC/B,UAAA,WAAW,yCAAa,GAAG;AAKjC,UAAM,cAAmE,CAAC;AAC1E,QAAI,UAAU;AACZ,iBAAW,WAAW,UAAU;AAE1B,YAAA,YAAY,GAAG,MAAM;AACvB,gBAAM,IAAI;AAAA,YACR,oBAAoB,GAAG,IAAI;AAAA,UAC7B;AAAA,QAAA;AAEI,cAAA,WAAW,SAAS,IAAI,OAAO;AACrC,YAAI,UAAU;AACZ,sBAAY,OAAO,IAAI;AAAA,QAAA;AAAA,MACzB;AAAA,IACF;AAIK,WAAA,gBAAgB,gBAAgB,IAAI,WAAW;AAAA,EAAA,CACvD;AAEM,SAAA;AACT;"}