{"version":3,"file":"mutations.cjs","sources":["../../../src/collection/mutations.ts"],"sourcesContent":["import {\n  withArrayChangeTracking,\n  withChangeTracking,\n  withFlatChangeTracking,\n} from '../proxy'\nimport { safeRandomUUID } from '../utils/uuid'\nimport { createTransaction, getActiveTransaction } from '../transactions'\nimport {\n  DeleteKeyNotFoundError,\n  DuplicateKeyError,\n  InvalidKeyError,\n  InvalidSchemaError,\n  KeyUpdateNotAllowedError,\n  MissingDeleteHandlerError,\n  MissingInsertHandlerError,\n  MissingUpdateArgumentError,\n  MissingUpdateHandlerError,\n  NoKeysPassedToDeleteError,\n  NoKeysPassedToUpdateError,\n  SchemaMustBeSynchronousError,\n  SchemaValidationError,\n  UndefinedKeyError,\n  UpdateKeyNotFoundError,\n} from '../errors'\nimport { DIRECT_TRANSACTION_METADATA_KEY } from './transaction-metadata.js'\nimport type { Collection, CollectionImpl } from './index.js'\nimport type { StandardSchemaV1 } from '@standard-schema/spec'\nimport type {\n  CollectionConfig,\n  InsertConfig,\n  OperationConfig,\n  OperationType,\n  PendingMutation,\n  StandardSchema,\n  TransactionConfig,\n  Transaction as TransactionType,\n  TransactionWithMutations,\n  UtilsRecord,\n  WritableDeep,\n} from '../types'\nimport type { TransactionScope } from '../transactions'\nimport type { CollectionLifecycleManager } from './lifecycle'\nimport type { CollectionStateManager } from './state'\n\n// One random prefix per runtime keeps mutation ids unique across tabs and\n// sessions; the counter avoids generating a random UUID per mutation. The\n// prefix waits for the first mutation, because some runtimes reject random\n// values at module scope.\nlet mutationIdPrefix: string | undefined\nlet mutationCount = 0\nfunction createMutationId(): string {\n  mutationIdPrefix ??= safeRandomUUID()\n  return `${mutationIdPrefix}-${++mutationCount}`\n}\n\nexport class CollectionMutationsManager<\n  TOutput extends object = Record<string, unknown>,\n  TKey extends string | number = string | number,\n  TUtils extends UtilsRecord = {},\n  TSchema extends StandardSchemaV1 = StandardSchemaV1,\n  TInput extends object = TOutput,\n> {\n  private lifecycle!: CollectionLifecycleManager<TOutput, TKey, TSchema, TInput>\n  private state!: CollectionStateManager<TOutput, TKey, TSchema, TInput>\n  private collection!: CollectionImpl<TOutput, TKey, TUtils, TSchema, TInput>\n  private config!: CollectionConfig<TOutput, TKey, TSchema, TUtils>\n  private transactionScope?: TransactionScope\n  private id: string\n\n  constructor(\n    config: CollectionConfig<TOutput, TKey, TSchema, TUtils>,\n    id: string,\n  ) {\n    this.id = id\n    this.config = config\n  }\n\n  setDeps(deps: {\n    lifecycle: CollectionLifecycleManager<TOutput, TKey, TSchema, TInput>\n    state: CollectionStateManager<TOutput, TKey, TSchema, TInput>\n    collection: CollectionImpl<TOutput, TKey, TUtils, TSchema, TInput>\n  }) {\n    this.lifecycle = deps.lifecycle\n    this.state = deps.state\n    this.collection = deps.collection\n  }\n\n  setTransactionScope(transactionScope: TransactionScope): void {\n    this.transactionScope = transactionScope\n  }\n\n  private getActiveTransaction() {\n    return this.transactionScope\n      ? this.transactionScope.getActiveTransactionForCollection()\n      : getActiveTransaction()\n  }\n\n  private createTransaction<T extends object>(config: TransactionConfig<T>) {\n    return this.transactionScope\n      ? this.transactionScope.createTransaction(config)\n      : createTransaction(config)\n  }\n\n  private ensureStandardSchema(schema: unknown): StandardSchema<TOutput> {\n    // If the schema already implements the standard-schema interface, return it\n    if (schema && `~standard` in (schema as {})) {\n      return schema as StandardSchema<TOutput>\n    }\n\n    throw new InvalidSchemaError()\n  }\n\n  public validateData(\n    data: unknown,\n    type: `insert` | `update`,\n    key?: TKey,\n  ): TOutput | never {\n    if (!this.config.schema) return data as TOutput\n\n    const standardSchema = this.ensureStandardSchema(this.config.schema)\n\n    // For updates, we need to merge with the existing data before validation\n    if (type === `update` && key) {\n      // Get the existing data for this key\n      const existingData = this.state.get(key)\n\n      if (\n        existingData &&\n        data &&\n        typeof data === `object` &&\n        typeof existingData === `object`\n      ) {\n        // Merge the update with the existing data\n        const mergedData = { ...existingData, ...data }\n\n        // Validate the merged data\n        const result = standardSchema[`~standard`].validate(mergedData)\n\n        // Ensure validation is synchronous\n        if (result instanceof Promise) {\n          throw new SchemaMustBeSynchronousError()\n        }\n\n        // If validation fails, throw a SchemaValidationError with the issues\n        if (`issues` in result && result.issues) {\n          const typedIssues = result.issues.map((issue) => ({\n            message: issue.message,\n            path: issue.path?.map((p) => String(p)),\n          }))\n          throw new SchemaValidationError(type, typedIssues)\n        }\n\n        // Extract only the modified keys from the validated result\n        const validatedMergedData = result.value as TOutput\n        const modifiedKeys = Object.keys(data)\n        const extractedChanges = Object.fromEntries(\n          modifiedKeys.map((k) => [k, validatedMergedData[k as keyof TOutput]]),\n        ) as TOutput\n\n        return extractedChanges\n      }\n    }\n\n    // For inserts or updates without existing data, validate the data directly\n    const result = standardSchema[`~standard`].validate(data)\n\n    // Ensure validation is synchronous\n    if (result instanceof Promise) {\n      throw new SchemaMustBeSynchronousError()\n    }\n\n    // If validation fails, throw a SchemaValidationError with the issues\n    if (`issues` in result && result.issues) {\n      const typedIssues = result.issues.map((issue) => ({\n        message: issue.message,\n        path: issue.path?.map((p) => String(p)),\n      }))\n      throw new SchemaValidationError(type, typedIssues)\n    }\n\n    return result.value as TOutput\n  }\n\n  public generateGlobalKey(key: any, item: any): string {\n    if (typeof key !== `string` && typeof key !== `number`) {\n      // Preserve specific error for undefined keys\n      if (typeof key === `undefined`) {\n        throw new UndefinedKeyError(item)\n      }\n      throw new InvalidKeyError(key, item)\n    }\n\n    return `KEY::${this.id}/${key}`\n  }\n\n  private markPendingLocalChanges(\n    mutations: Array<PendingMutation<TOutput>>,\n  ): void {\n    for (const mutation of mutations) {\n      // The handler can sync synchronously before its transaction is registered.\n      // This is provisional; only completed mutations retain a local origin.\n      this.state.pendingLocalChanges.add(mutation.key as TKey)\n    }\n  }\n\n  /**\n   * A local-only Collection confirms its own writes. Without a user handler\n   * for this operation type, and with no other transaction unsettled, write\n   * the mutations as synced rows and return a completed transaction instead\n   * of publishing an optimistic overlay and confirming it a tick later.\n   */\n  private commitLocalOnlyDirect(\n    mutations: Array<PendingMutation<TOutput>>,\n    type: OperationType,\n  ): TransactionType<TOutput> | undefined {\n    const direct = this.state.localOnlyDirectWrite\n    if (!direct?.types.has(type)) return undefined\n    for (const transaction of this.state.transactions.values()) {\n      // A persisting transaction holds sync commits, and a pending one\n      // overlays them.\n      if (\n        transaction.state === `pending` ||\n        transaction.state === `persisting`\n      ) {\n        return undefined\n      }\n    }\n    const transaction = this.createTransaction<TOutput>({\n      autoCommit: false,\n      metadata: { [DIRECT_TRANSACTION_METADATA_KEY]: true },\n      mutationFn: () => Promise.resolve(),\n    })\n    transaction.applyMutations(mutations)\n    direct.write(mutations)\n    transaction.setState(`completed`)\n    transaction.isPersisted.resolve(transaction)\n    return transaction\n  }\n\n  /**\n   * Inserts one or more items into the collection\n   */\n  insert = (data: TInput | Array<TInput>, config?: InsertConfig) => {\n    this.lifecycle.validateCollectionUsable(`insert`)\n    const state = this.state\n    const ambientTransaction = this.getActiveTransaction()\n\n    // If no ambient transaction exists, check for an onInsert handler early\n    if (!ambientTransaction && !this.config.onInsert) {\n      throw new MissingInsertHandlerError()\n    }\n\n    const items = Array.isArray(data) ? data : [data]\n    // One timestamp per call; mutations replace these rather than mutate them.\n    const now = new Date()\n    const mutations: Array<PendingMutation<TOutput>> = []\n    const keysInCurrentBatch = new Set<TKey>()\n\n    // Create mutations for each item\n    items.forEach((item) => {\n      // Validate the data against the schema if one exists\n      const validatedData = this.validateData(item, `insert`)\n\n      // Reject duplicate keys within this batch before starting sync.\n      const key = this.config.getKey(validatedData)\n      if (keysInCurrentBatch.has(key)) {\n        throw new DuplicateKeyError(key)\n      }\n      keysInCurrentBatch.add(key)\n      const globalKey = this.generateGlobalKey(key, item)\n\n      const mutation: PendingMutation<TOutput, `insert`> = {\n        mutationId: createMutationId(),\n        original: {},\n        modified: validatedData,\n        // Pick the values from validatedData based on what's passed in - this is for cases\n        // where a schema has default values. The validated data has the extra default\n        // values but for changes, we just want to show the data that was actually passed in.\n        changes: Object.fromEntries(\n          Object.keys(item).map((k) => [\n            k,\n            validatedData[k as keyof typeof validatedData],\n          ]),\n        ) as TInput,\n        globalKey,\n        key,\n        metadata: config?.metadata as unknown,\n        syncMetadata: this.config.sync.getSyncMetadata?.() || {},\n        optimistic: config?.optimistic ?? true,\n        type: `insert`,\n        createdAt: now,\n        updatedAt: now,\n        collection: this.collection,\n      }\n\n      mutations.push(mutation)\n    })\n\n    // Reject duplicates already visible before explicitly starting sync; startup may\n    // synchronously reveal additional keys, so check again afterward.\n    let duplicate = mutations.find(({ key }) => state.has(key))\n    if (duplicate) throw new DuplicateKeyError(duplicate.key)\n    this.collection._sync.startSync()\n    duplicate = mutations.find(({ key }) => state.has(key))\n    if (duplicate) throw new DuplicateKeyError(duplicate.key)\n\n    // If an ambient transaction exists, use it\n    if (ambientTransaction) {\n      ambientTransaction.applyMutations(mutations)\n\n      state.transactions.set(ambientTransaction.id, ambientTransaction)\n      state.scheduleTransactionCleanup(ambientTransaction)\n      state.recomputeOptimisticState(true)\n\n      return ambientTransaction\n    } else {\n      const localOnly = this.commitLocalOnlyDirect(mutations, `insert`)\n      if (localOnly) return localOnly\n      // Create a new transaction with a mutation function that calls the onInsert handler\n      const directOpTransaction = this.createTransaction<TOutput>({\n        metadata: { [DIRECT_TRANSACTION_METADATA_KEY]: true },\n        mutationFn: async (params) => {\n          // Call the onInsert handler with the transaction and collection\n          return await this.config.onInsert!({\n            transaction:\n              params.transaction as unknown as TransactionWithMutations<\n                TOutput,\n                `insert`,\n                Collection<TOutput, TKey, TUtils>\n              >,\n            collection: this.collection as unknown as Collection<\n              TOutput,\n              TKey,\n              TUtils\n            >,\n          })\n        },\n      })\n\n      // Apply mutations to the new transaction\n      directOpTransaction.applyMutations(mutations)\n      this.markPendingLocalChanges(mutations)\n      // The Collection owns the request before its handler can write through\n      // sync, so a confirmation written by the handler waits for settlement.\n      state.transactions.set(directOpTransaction.id, directOpTransaction)\n      state.scheduleTransactionCleanup(directOpTransaction)\n      state.recomputeOptimisticState(true)\n      // Errors still reject tx.isPersisted.promise; this catch only prevents global unhandled rejections\n      directOpTransaction.commit().catch(() => undefined)\n\n      return directOpTransaction\n    }\n  }\n\n  /**\n   * Updates one or more items in the collection using a callback function\n   */\n  update(\n    keys: TKey | Array<TKey>,\n    configOrCallback:\n      | ((draft: WritableDeep<TInput>) => void)\n      | ((drafts: Array<WritableDeep<TInput>>) => void)\n      | OperationConfig,\n    maybeCallback?:\n      | ((draft: WritableDeep<TInput>) => void)\n      | ((drafts: Array<WritableDeep<TInput>>) => void),\n  ) {\n    if (typeof keys === `undefined`) {\n      throw new MissingUpdateArgumentError()\n    }\n\n    const state = this.state\n    this.lifecycle.validateCollectionUsable(`update`)\n\n    const ambientTransaction = this.getActiveTransaction()\n\n    // If no ambient transaction exists, check for an onUpdate handler early\n    if (!ambientTransaction && !this.config.onUpdate) {\n      throw new MissingUpdateHandlerError()\n    }\n\n    const isArray = Array.isArray(keys)\n    const keysArray = isArray ? keys : [keys]\n\n    if (isArray && keysArray.length === 0) {\n      throw new NoKeysPassedToUpdateError()\n    }\n\n    const callback =\n      typeof configOrCallback === `function` ? configOrCallback : maybeCallback\n    if (typeof callback !== `function`) throw new TypeError()\n    const config =\n      typeof configOrCallback === `function` ? {} : configOrCallback\n\n    this.collection._sync.startSync()\n\n    // Get the current objects or empty objects if they don't exist\n    const currentObjects = keysArray.map((key) => {\n      const item = this.state.get(key)\n      if (!item) {\n        throw new UpdateKeyNotFoundError(key)\n      }\n\n      return item\n    }) as unknown as Array<TInput>\n\n    // Flat rows need no proxy; nested rows track changes through drafts.\n    const changesArray =\n      withFlatChangeTracking(\n        currentObjects,\n        callback as (drafts: Array<TInput> | TInput) => void,\n        isArray,\n      ) ??\n      (isArray\n        ? withArrayChangeTracking(\n            currentObjects,\n            callback as (draft: Array<TInput>) => void,\n          )\n        : [\n            withChangeTracking(\n              currentObjects[0]!,\n              callback as (draft: TInput) => void,\n            ),\n          ])\n\n    // Create mutations for each object that has changes\n    // One timestamp per call; mutations replace these rather than mutate them.\n    const now = new Date()\n    const mutations: Array<\n      PendingMutation<\n        TOutput,\n        `update`,\n        CollectionImpl<TOutput, TKey, TUtils, TSchema, TInput>\n      >\n    > = keysArray\n      .map((key, index) => {\n        const itemChanges = changesArray[index] // A fresh object the tracker recorded for this item\n\n        // Skip items with no changes\n        if (!itemChanges || Object.keys(itemChanges).length === 0) {\n          return null\n        }\n\n        const originalItem = currentObjects[index] as unknown as TOutput\n        // Validate the user-provided changes for this item\n        const validatedUpdatePayload = this.validateData(\n          itemChanges,\n          `update`,\n          key,\n        )\n\n        // Construct the full modified item by applying the validated update payload to the original item\n        const modifiedItem = { ...originalItem, ...validatedUpdatePayload }\n\n        // Check if the ID of the item is being changed\n        const originalItemId = this.config.getKey(originalItem)\n        const modifiedItemId = this.config.getKey(modifiedItem)\n\n        if (originalItemId !== modifiedItemId) {\n          throw new KeyUpdateNotAllowedError(originalItemId, modifiedItemId)\n        }\n\n        const globalKey = this.generateGlobalKey(modifiedItemId, modifiedItem)\n\n        return {\n          mutationId: createMutationId(),\n          original: originalItem,\n          modified: modifiedItem,\n          // Pick the values from modifiedItem based on what's passed in - this is for cases\n          // where a schema has default values or transforms. The modified data has the extra\n          // default or transformed values but for changes, we just want to show the data that\n          // was actually passed in.\n          // Without a schema, validation returns the tracker's fresh change\n          // object, which already holds exactly these values.\n          changes: (validatedUpdatePayload === itemChanges\n            ? itemChanges\n            : Object.fromEntries(\n                Object.keys(itemChanges).map((k) => [\n                  k,\n                  modifiedItem[k as keyof typeof modifiedItem],\n                ]),\n              )) as TInput,\n          globalKey,\n          key,\n          metadata: config.metadata as unknown,\n          syncMetadata: (state.syncedMetadata.get(key) || {}) as Record<\n            string,\n            unknown\n          >,\n          optimistic: config.optimistic ?? true,\n          type: `update`,\n          createdAt: now,\n          updatedAt: now,\n          collection: this.collection,\n        }\n      })\n      .filter(Boolean) as Array<\n      PendingMutation<\n        TOutput,\n        `update`,\n        CollectionImpl<TOutput, TKey, TUtils, TSchema, TInput>\n      >\n    >\n\n    // If no changes were made, return an empty transaction early\n    if (mutations.length === 0) {\n      const emptyTransaction = this.createTransaction({\n        mutationFn: async () => {},\n      })\n      // Errors still propagate through tx.isPersisted.promise; suppress the background commit from warning\n      emptyTransaction.commit().catch(() => undefined)\n      // Schedule cleanup for empty transaction\n      state.scheduleTransactionCleanup(emptyTransaction)\n      return emptyTransaction\n    }\n\n    // If an ambient transaction exists, use it\n    if (ambientTransaction) {\n      ambientTransaction.applyMutations(mutations)\n\n      state.transactions.set(ambientTransaction.id, ambientTransaction)\n      state.scheduleTransactionCleanup(ambientTransaction)\n      state.recomputeOptimisticState(true)\n\n      return ambientTransaction\n    }\n\n    // No need to check for onUpdate handler here as we've already checked at the beginning\n\n    const localOnly = this.commitLocalOnlyDirect(mutations, `update`)\n    if (localOnly) return localOnly\n\n    // Create a new transaction with a mutation function that calls the onUpdate handler\n    const directOpTransaction = this.createTransaction<TOutput>({\n      metadata: { [DIRECT_TRANSACTION_METADATA_KEY]: true },\n      mutationFn: async (params) => {\n        // Call the onUpdate handler with the transaction and collection\n        return this.config.onUpdate!({\n          transaction:\n            params.transaction as unknown as TransactionWithMutations<\n              TOutput,\n              `update`,\n              Collection<TOutput, TKey, TUtils>\n            >,\n          collection: this.collection as unknown as Collection<\n            TOutput,\n            TKey,\n            TUtils\n          >,\n        })\n      },\n    })\n\n    // Apply mutations to the new transaction\n    directOpTransaction.applyMutations(mutations)\n    this.markPendingLocalChanges(mutations)\n    // Own the request before its handler runs; see insert.\n    state.transactions.set(directOpTransaction.id, directOpTransaction)\n    state.scheduleTransactionCleanup(directOpTransaction)\n    state.recomputeOptimisticState(true)\n    // Errors still hit tx.isPersisted.promise; avoid leaking an unhandled rejection from the fire-and-forget commit\n    directOpTransaction.commit().catch(() => undefined)\n\n    return directOpTransaction\n  }\n\n  /**\n   * Deletes one or more items from the collection\n   */\n  delete = (\n    keys: Array<TKey> | TKey,\n    config?: OperationConfig,\n  ): TransactionType<any> => {\n    const state = this.state\n    this.lifecycle.validateCollectionUsable(`delete`)\n\n    const ambientTransaction = this.getActiveTransaction()\n\n    // If no ambient transaction exists, check for an onDelete handler early\n    if (!ambientTransaction && !this.config.onDelete) {\n      throw new MissingDeleteHandlerError()\n    }\n\n    if (Array.isArray(keys) && keys.length === 0) {\n      throw new NoKeysPassedToDeleteError()\n    }\n\n    const keysArray = Array.isArray(keys) ? keys : [keys]\n    this.collection._sync.startSync()\n    // One timestamp per call; mutations replace these rather than mutate them.\n    const now = new Date()\n    const mutations: Array<\n      PendingMutation<\n        TOutput,\n        `delete`,\n        CollectionImpl<TOutput, TKey, TUtils, TSchema, TInput>\n      >\n    > = []\n\n    for (const key of keysArray) {\n      if (!this.state.has(key)) {\n        throw new DeleteKeyNotFoundError(key)\n      }\n      const globalKey = this.generateGlobalKey(key, this.state.get(key)!)\n      const mutation: PendingMutation<\n        TOutput,\n        `delete`,\n        CollectionImpl<TOutput, TKey, TUtils, TSchema, TInput>\n      > = {\n        mutationId: createMutationId(),\n        original: this.state.get(key)!,\n        modified: this.state.get(key)!,\n        changes: this.state.get(key)!,\n        globalKey,\n        key,\n        metadata: config?.metadata as unknown,\n        syncMetadata: (state.syncedMetadata.get(key) || {}) as Record<\n          string,\n          unknown\n        >,\n        optimistic: config?.optimistic ?? true,\n        type: `delete`,\n        createdAt: now,\n        updatedAt: now,\n        collection: this.collection,\n      }\n\n      mutations.push(mutation)\n    }\n\n    // If an ambient transaction exists, use it\n    if (ambientTransaction) {\n      ambientTransaction.applyMutations(mutations)\n\n      state.transactions.set(ambientTransaction.id, ambientTransaction)\n      state.scheduleTransactionCleanup(ambientTransaction)\n      state.recomputeOptimisticState(true)\n\n      return ambientTransaction\n    }\n\n    const localOnly = this.commitLocalOnlyDirect(mutations, `delete`)\n    if (localOnly) return localOnly\n\n    // Create a new transaction with a mutation function that calls the onDelete handler\n    const directOpTransaction = this.createTransaction<TOutput>({\n      autoCommit: true,\n      metadata: { [DIRECT_TRANSACTION_METADATA_KEY]: true },\n      mutationFn: async (params) => {\n        // Call the onDelete handler with the transaction and collection\n        return this.config.onDelete!({\n          transaction:\n            params.transaction as unknown as TransactionWithMutations<\n              TOutput,\n              `delete`,\n              Collection<TOutput, TKey, TUtils>\n            >,\n          collection: this.collection as unknown as Collection<\n            TOutput,\n            TKey,\n            TUtils\n          >,\n        })\n      },\n    })\n\n    // Apply mutations to the new transaction\n    directOpTransaction.applyMutations(mutations)\n    this.markPendingLocalChanges(mutations)\n    // Own the request before its handler runs; see insert.\n    state.transactions.set(directOpTransaction.id, directOpTransaction)\n    state.scheduleTransactionCleanup(directOpTransaction)\n    state.recomputeOptimisticState(true)\n    // Errors still reject tx.isPersisted.promise; silence the internal commit promise to prevent test noise\n    directOpTransaction.commit().catch(() => undefined)\n\n    return directOpTransaction\n  }\n}\n"],"names":["safeRandomUUID","config","MissingInsertHandlerError","DuplicateKeyError","commitLocalOnlyDirect","DIRECT_TRANSACTION_METADATA_KEY","markPendingLocalChanges","MissingDeleteHandlerError","NoKeysPassedToDeleteError","DeleteKeyNotFoundError","transactionScope","getActiveTransaction","createTransaction","ensureStandardSchema","InvalidSchemaError","result","SchemaMustBeSynchronousError","SchemaValidationError","UndefinedKeyError","InvalidKeyError","transaction","MissingUpdateArgumentError","MissingUpdateHandlerError","NoKeysPassedToUpdateError","UpdateKeyNotFoundError","withFlatChangeTracking","withArrayChangeTracking","withChangeTracking","KeyUpdateNotAllowedError"],"mappings":";;;;;;;AAgDA,IAAI;AACJ,IAAI,gBAAgB;AACpB,SAAS,mBAA2B;AAClC,uBAAqBA,KAAAA,eAAA;AACrB,SAAO,GAAG,gBAAgB,IAAI,EAAE,aAAa;AAC/C;AAEO,MAAM,2BAMX;AAAA,EAQA,YACE,QACA,IACA;AA0KF,SAAA,SAAS,CAAC,MAA8BC,YAA0B;AAChE,WAAK,UAAU,yBAAyB,QAAQ;AAChD,YAAM,QAAQ,KAAK;AACnB,YAAM,qBAAqB,KAAK,qBAAA;AAGhC,UAAI,CAAC,sBAAsB,CAAC,KAAK,OAAO,UAAU;AAChD,cAAM,IAAIC,OAAAA,0BAAA;AAAA,MACZ;AAEA,YAAM,QAAQ,MAAM,QAAQ,IAAI,IAAI,OAAO,CAAC,IAAI;AAEhD,YAAM,0BAAU,KAAA;AAChB,YAAM,YAA6C,CAAA;AACnD,YAAM,yCAAyB,IAAA;AAG/B,YAAM,QAAQ,CAAC,SAAS;AAEtB,cAAM,gBAAgB,KAAK,aAAa,MAAM,QAAQ;AAGtD,cAAM,MAAM,KAAK,OAAO,OAAO,aAAa;AAC5C,YAAI,mBAAmB,IAAI,GAAG,GAAG;AAC/B,gBAAM,IAAIC,OAAAA,kBAAkB,GAAG;AAAA,QACjC;AACA,2BAAmB,IAAI,GAAG;AAC1B,cAAM,YAAY,KAAK,kBAAkB,KAAK,IAAI;AAElD,cAAM,WAA+C;AAAA,UACnD,YAAY,iBAAA;AAAA,UACZ,UAAU,CAAA;AAAA,UACV,UAAU;AAAA;AAAA;AAAA;AAAA,UAIV,SAAS,OAAO;AAAA,YACd,OAAO,KAAK,IAAI,EAAE,IAAI,CAAC,MAAM;AAAA,cAC3B;AAAA,cACA,cAAc,CAA+B;AAAA,YAAA,CAC9C;AAAA,UAAA;AAAA,UAEH;AAAA,UACA;AAAA,UACA,UAAUF,SAAQ;AAAA,UAClB,cAAc,KAAK,OAAO,KAAK,kBAAA,KAAuB,CAAA;AAAA,UACtD,YAAYA,SAAQ,cAAc;AAAA,UAClC,MAAM;AAAA,UACN,WAAW;AAAA,UACX,WAAW;AAAA,UACX,YAAY,KAAK;AAAA,QAAA;AAGnB,kBAAU,KAAK,QAAQ;AAAA,MACzB,CAAC;AAID,UAAI,YAAY,UAAU,KAAK,CAAC,EAAE,UAAU,MAAM,IAAI,GAAG,CAAC;AAC1D,UAAI,UAAW,OAAM,IAAIE,yBAAkB,UAAU,GAAG;AACxD,WAAK,WAAW,MAAM,UAAA;AACtB,kBAAY,UAAU,KAAK,CAAC,EAAE,UAAU,MAAM,IAAI,GAAG,CAAC;AACtD,UAAI,UAAW,OAAM,IAAIA,yBAAkB,UAAU,GAAG;AAGxD,UAAI,oBAAoB;AACtB,2BAAmB,eAAe,SAAS;AAE3C,cAAM,aAAa,IAAI,mBAAmB,IAAI,kBAAkB;AAChE,cAAM,2BAA2B,kBAAkB;AACnD,cAAM,yBAAyB,IAAI;AAEnC,eAAO;AAAA,MACT,OAAO;AACL,cAAM,YAAY,KAAKC,GAAsB,WAAW,QAAQ;AAChE,YAAI,UAAW,QAAO;AAEtB,cAAM,sBAAsB,KAAK,kBAA2B;AAAA,UAC1D,UAAU,EAAE,CAACC,oBAAAA,+BAA+B,GAAG,KAAA;AAAA,UAC/C,YAAY,OAAO,WAAW;AAE5B,mBAAO,MAAM,KAAK,OAAO,SAAU;AAAA,cACjC,aACE,OAAO;AAAA,cAKT,YAAY,KAAK;AAAA,YAAA,CAKlB;AAAA,UACH;AAAA,QAAA,CACD;AAGD,4BAAoB,eAAe,SAAS;AAC5C,aAAKC,GAAwB,SAAS;AAGtC,cAAM,aAAa,IAAI,oBAAoB,IAAI,mBAAmB;AAClE,cAAM,2BAA2B,mBAAmB;AACpD,cAAM,yBAAyB,IAAI;AAEnC,4BAAoB,OAAA,EAAS,MAAM,MAAM,MAAS;AAElD,eAAO;AAAA,MACT;AAAA,IACF;AAyNA,SAAA,SAAS,CACP,MACAL,YACyB;AACzB,YAAM,QAAQ,KAAK;AACnB,WAAK,UAAU,yBAAyB,QAAQ;AAEhD,YAAM,qBAAqB,KAAK,qBAAA;AAGhC,UAAI,CAAC,sBAAsB,CAAC,KAAK,OAAO,UAAU;AAChD,cAAM,IAAIM,OAAAA,0BAAA;AAAA,MACZ;AAEA,UAAI,MAAM,QAAQ,IAAI,KAAK,KAAK,WAAW,GAAG;AAC5C,cAAM,IAAIC,OAAAA,0BAAA;AAAA,MACZ;AAEA,YAAM,YAAY,MAAM,QAAQ,IAAI,IAAI,OAAO,CAAC,IAAI;AACpD,WAAK,WAAW,MAAM,UAAA;AAEtB,YAAM,0BAAU,KAAA;AAChB,YAAM,YAMF,CAAA;AAEJ,iBAAW,OAAO,WAAW;AAC3B,YAAI,CAAC,KAAK,MAAM,IAAI,GAAG,GAAG;AACxB,gBAAM,IAAIC,OAAAA,uBAAuB,GAAG;AAAA,QACtC;AACA,cAAM,YAAY,KAAK,kBAAkB,KAAK,KAAK,MAAM,IAAI,GAAG,CAAE;AAClE,cAAM,WAIF;AAAA,UACF,YAAY,iBAAA;AAAA,UACZ,UAAU,KAAK,MAAM,IAAI,GAAG;AAAA,UAC5B,UAAU,KAAK,MAAM,IAAI,GAAG;AAAA,UAC5B,SAAS,KAAK,MAAM,IAAI,GAAG;AAAA,UAC3B;AAAA,UACA;AAAA,UACA,UAAUR,SAAQ;AAAA,UAClB,cAAe,MAAM,eAAe,IAAI,GAAG,KAAK,CAAA;AAAA,UAIhD,YAAYA,SAAQ,cAAc;AAAA,UAClC,MAAM;AAAA,UACN,WAAW;AAAA,UACX,WAAW;AAAA,UACX,YAAY,KAAK;AAAA,QAAA;AAGnB,kBAAU,KAAK,QAAQ;AAAA,MACzB;AAGA,UAAI,oBAAoB;AACtB,2BAAmB,eAAe,SAAS;AAE3C,cAAM,aAAa,IAAI,mBAAmB,IAAI,kBAAkB;AAChE,cAAM,2BAA2B,kBAAkB;AACnD,cAAM,yBAAyB,IAAI;AAEnC,eAAO;AAAA,MACT;AAEA,YAAM,YAAY,KAAKG,GAAsB,WAAW,QAAQ;AAChE,UAAI,UAAW,QAAO;AAGtB,YAAM,sBAAsB,KAAK,kBAA2B;AAAA,QAC1D,YAAY;AAAA,QACZ,UAAU,EAAE,CAACC,oBAAAA,+BAA+B,GAAG,KAAA;AAAA,QAC/C,YAAY,OAAO,WAAW;AAE5B,iBAAO,KAAK,OAAO,SAAU;AAAA,YAC3B,aACE,OAAO;AAAA,YAKT,YAAY,KAAK;AAAA,UAAA,CAKlB;AAAA,QACH;AAAA,MAAA,CACD;AAGD,0BAAoB,eAAe,SAAS;AAC5C,WAAKC,GAAwB,SAAS;AAEtC,YAAM,aAAa,IAAI,oBAAoB,IAAI,mBAAmB;AAClE,YAAM,2BAA2B,mBAAmB;AACpD,YAAM,yBAAyB,IAAI;AAEnC,0BAAoB,OAAA,EAAS,MAAM,MAAM,MAAS;AAElD,aAAO;AAAA,IACT;AA5lBE,SAAK,KAAK;AACV,SAAK,SAAS;AAAA,EAChB;AAAA,EAEA,QAAQ,MAIL;AACD,SAAK,YAAY,KAAK;AACtB,SAAK,QAAQ,KAAK;AAClB,SAAK,aAAa,KAAK;AAAA,EACzB;AAAA,EAEA,oBAAoB,kBAA0C;AAC5D,SAAKI,KAAmB;AAAA,EAC1B;AAAA,EAEQ,uBAAuB;AAC7B,WAAO,KAAKA,KACR,KAAKA,GAAiB,kCAAA,IACtBC,kCAAA;AAAA,EACN;AAAA,EAEQ,kBAAoC,QAA8B;AACxE,WAAO,KAAKD,KACR,KAAKA,GAAiB,kBAAkB,MAAM,IAC9CE,aAAAA,kBAAkB,MAAM;AAAA,EAC9B;AAAA,EAEQC,GAAqB,QAA0C;AAErE,QAAI,UAAU,eAAgB,QAAe;AAC3C,aAAO;AAAA,IACT;AAEA,UAAM,IAAIC,OAAAA,mBAAA;AAAA,EACZ;AAAA,EAEO,aACL,MACA,MACA,KACiB;AACjB,QAAI,CAAC,KAAK,OAAO,OAAQ,QAAO;AAEhC,UAAM,iBAAiB,KAAKD,GAAqB,KAAK,OAAO,MAAM;AAGnE,QAAI,SAAS,YAAY,KAAK;AAE5B,YAAM,eAAe,KAAK,MAAM,IAAI,GAAG;AAEvC,UACE,gBACA,QACA,OAAO,SAAS,YAChB,OAAO,iBAAiB,UACxB;AAEA,cAAM,aAAa,EAAE,GAAG,cAAc,GAAG,KAAA;AAGzC,cAAME,UAAS,eAAe,WAAW,EAAE,SAAS,UAAU;AAG9D,YAAIA,mBAAkB,SAAS;AAC7B,gBAAM,IAAIC,OAAAA,6BAAA;AAAA,QACZ;AAGA,YAAI,YAAYD,WAAUA,QAAO,QAAQ;AACvC,gBAAM,cAAcA,QAAO,OAAO,IAAI,CAAC,WAAW;AAAA,YAChD,SAAS,MAAM;AAAA,YACf,MAAM,MAAM,MAAM,IAAI,CAAC,MAAM,OAAO,CAAC,CAAC;AAAA,UAAA,EACtC;AACF,gBAAM,IAAIE,OAAAA,sBAAsB,MAAM,WAAW;AAAA,QACnD;AAGA,cAAM,sBAAsBF,QAAO;AACnC,cAAM,eAAe,OAAO,KAAK,IAAI;AACrC,cAAM,mBAAmB,OAAO;AAAA,UAC9B,aAAa,IAAI,CAAC,MAAM,CAAC,GAAG,oBAAoB,CAAkB,CAAC,CAAC;AAAA,QAAA;AAGtE,eAAO;AAAA,MACT;AAAA,IACF;AAGA,UAAM,SAAS,eAAe,WAAW,EAAE,SAAS,IAAI;AAGxD,QAAI,kBAAkB,SAAS;AAC7B,YAAM,IAAIC,OAAAA,6BAAA;AAAA,IACZ;AAGA,QAAI,YAAY,UAAU,OAAO,QAAQ;AACvC,YAAM,cAAc,OAAO,OAAO,IAAI,CAAC,WAAW;AAAA,QAChD,SAAS,MAAM;AAAA,QACf,MAAM,MAAM,MAAM,IAAI,CAAC,MAAM,OAAO,CAAC,CAAC;AAAA,MAAA,EACtC;AACF,YAAM,IAAIC,OAAAA,sBAAsB,MAAM,WAAW;AAAA,IACnD;AAEA,WAAO,OAAO;AAAA,EAChB;AAAA,EAEO,kBAAkB,KAAU,MAAmB;AACpD,QAAI,OAAO,QAAQ,YAAY,OAAO,QAAQ,UAAU;AAEtD,UAAI,OAAO,QAAQ,aAAa;AAC9B,cAAM,IAAIC,OAAAA,kBAAkB,IAAI;AAAA,MAClC;AACA,YAAM,IAAIC,OAAAA,gBAAgB,KAAK,IAAI;AAAA,IACrC;AAEA,WAAO,QAAQ,KAAK,EAAE,IAAI,GAAG;AAAA,EAC/B;AAAA,EAEQb,GACN,WACM;AACN,eAAW,YAAY,WAAW;AAGhC,WAAK,MAAM,oBAAoB,IAAI,SAAS,GAAW;AAAA,IACzD;AAAA,EACF;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQQF,GACN,WACA,MACsC;AACtC,UAAM,SAAS,KAAK,MAAM;AAC1B,QAAI,CAAC,QAAQ,MAAM,IAAI,IAAI,EAAG,QAAO;AACrC,eAAWgB,gBAAe,KAAK,MAAM,aAAa,UAAU;AAG1D,UACEA,aAAY,UAAU,aACtBA,aAAY,UAAU,cACtB;AACA,eAAO;AAAA,MACT;AAAA,IACF;AACA,UAAM,cAAc,KAAK,kBAA2B;AAAA,MAClD,YAAY;AAAA,MACZ,UAAU,EAAE,CAACf,oBAAAA,+BAA+B,GAAG,KAAA;AAAA,MAC/C,YAAY,MAAM,QAAQ,QAAA;AAAA,IAAQ,CACnC;AACD,gBAAY,eAAe,SAAS;AACpC,WAAO,MAAM,SAAS;AACtB,gBAAY,SAAS,WAAW;AAChC,gBAAY,YAAY,QAAQ,WAAW;AAC3C,WAAO;AAAA,EACT;AAAA;AAAA;AAAA;AAAA,EAwHA,OACE,MACA,kBAIA,eAGA;AACA,QAAI,OAAO,SAAS,aAAa;AAC/B,YAAM,IAAIgB,OAAAA,2BAAA;AAAA,IACZ;AAEA,UAAM,QAAQ,KAAK;AACnB,SAAK,UAAU,yBAAyB,QAAQ;AAEhD,UAAM,qBAAqB,KAAK,qBAAA;AAGhC,QAAI,CAAC,sBAAsB,CAAC,KAAK,OAAO,UAAU;AAChD,YAAM,IAAIC,OAAAA,0BAAA;AAAA,IACZ;AAEA,UAAM,UAAU,MAAM,QAAQ,IAAI;AAClC,UAAM,YAAY,UAAU,OAAO,CAAC,IAAI;AAExC,QAAI,WAAW,UAAU,WAAW,GAAG;AACrC,YAAM,IAAIC,OAAAA,0BAAA;AAAA,IACZ;AAEA,UAAM,WACJ,OAAO,qBAAqB,aAAa,mBAAmB;AAC9D,QAAI,OAAO,aAAa,WAAY,OAAM,IAAI,UAAA;AAC9C,UAAM,SACJ,OAAO,qBAAqB,aAAa,CAAA,IAAK;AAEhD,SAAK,WAAW,MAAM,UAAA;AAGtB,UAAM,iBAAiB,UAAU,IAAI,CAAC,QAAQ;AAC5C,YAAM,OAAO,KAAK,MAAM,IAAI,GAAG;AAC/B,UAAI,CAAC,MAAM;AACT,cAAM,IAAIC,OAAAA,uBAAuB,GAAG;AAAA,MACtC;AAEA,aAAO;AAAA,IACT,CAAC;AAGD,UAAM,eACJC,MAAAA;AAAAA,MACE;AAAA,MACA;AAAA,MACA;AAAA,IAAA,MAED,UACGC,MAAAA;AAAAA,MACE;AAAA,MACA;AAAA,IAAA,IAEF;AAAA,MACEC,MAAAA;AAAAA,QACE,eAAe,CAAC;AAAA,QAChB;AAAA,MAAA;AAAA,IACF;AAKR,UAAM,0BAAU,KAAA;AAChB,UAAM,YAMF,UACD,IAAI,CAAC,KAAK,UAAU;AACnB,YAAM,cAAc,aAAa,KAAK;AAGtC,UAAI,CAAC,eAAe,OAAO,KAAK,WAAW,EAAE,WAAW,GAAG;AACzD,eAAO;AAAA,MACT;AAEA,YAAM,eAAe,eAAe,KAAK;AAEzC,YAAM,yBAAyB,KAAK;AAAA,QAClC;AAAA,QACA;AAAA,QACA;AAAA,MAAA;AAIF,YAAM,eAAe,EAAE,GAAG,cAAc,GAAG,uBAAA;AAG3C,YAAM,iBAAiB,KAAK,OAAO,OAAO,YAAY;AACtD,YAAM,iBAAiB,KAAK,OAAO,OAAO,YAAY;AAEtD,UAAI,mBAAmB,gBAAgB;AACrC,cAAM,IAAIC,OAAAA,yBAAyB,gBAAgB,cAAc;AAAA,MACnE;AAEA,YAAM,YAAY,KAAK,kBAAkB,gBAAgB,YAAY;AAErE,aAAO;AAAA,QACL,YAAY,iBAAA;AAAA,QACZ,UAAU;AAAA,QACV,UAAU;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,QAOV,SAAU,2BAA2B,cACjC,cACA,OAAO;AAAA,UACL,OAAO,KAAK,WAAW,EAAE,IAAI,CAAC,MAAM;AAAA,YAClC;AAAA,YACA,aAAa,CAA8B;AAAA,UAAA,CAC5C;AAAA,QAAA;AAAA,QAEP;AAAA,QACA;AAAA,QACA,UAAU,OAAO;AAAA,QACjB,cAAe,MAAM,eAAe,IAAI,GAAG,KAAK,CAAA;AAAA,QAIhD,YAAY,OAAO,cAAc;AAAA,QACjC,MAAM;AAAA,QACN,WAAW;AAAA,QACX,WAAW;AAAA,QACX,YAAY,KAAK;AAAA,MAAA;AAAA,IAErB,CAAC,EACA,OAAO,OAAO;AASjB,QAAI,UAAU,WAAW,GAAG;AAC1B,YAAM,mBAAmB,KAAK,kBAAkB;AAAA,QAC9C,YAAY,YAAY;AAAA,QAAC;AAAA,MAAA,CAC1B;AAED,uBAAiB,OAAA,EAAS,MAAM,MAAM,MAAS;AAE/C,YAAM,2BAA2B,gBAAgB;AACjD,aAAO;AAAA,IACT;AAGA,QAAI,oBAAoB;AACtB,yBAAmB,eAAe,SAAS;AAE3C,YAAM,aAAa,IAAI,mBAAmB,IAAI,kBAAkB;AAChE,YAAM,2BAA2B,kBAAkB;AACnD,YAAM,yBAAyB,IAAI;AAEnC,aAAO;AAAA,IACT;AAIA,UAAM,YAAY,KAAKxB,GAAsB,WAAW,QAAQ;AAChE,QAAI,UAAW,QAAO;AAGtB,UAAM,sBAAsB,KAAK,kBAA2B;AAAA,MAC1D,UAAU,EAAE,CAACC,oBAAAA,+BAA+B,GAAG,KAAA;AAAA,MAC/C,YAAY,OAAO,WAAW;AAE5B,eAAO,KAAK,OAAO,SAAU;AAAA,UAC3B,aACE,OAAO;AAAA,UAKT,YAAY,KAAK;AAAA,QAAA,CAKlB;AAAA,MACH;AAAA,IAAA,CACD;AAGD,wBAAoB,eAAe,SAAS;AAC5C,SAAKC,GAAwB,SAAS;AAEtC,UAAM,aAAa,IAAI,oBAAoB,IAAI,mBAAmB;AAClE,UAAM,2BAA2B,mBAAmB;AACpD,UAAM,yBAAyB,IAAI;AAEnC,wBAAoB,OAAA,EAAS,MAAM,MAAM,MAAS;AAElD,WAAO;AAAA,EACT;AAkHF;;"}