@milaboratories/uikit 2.4.2 → 2.4.4

package/dist/lib/model/common/dist/index.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.js","sources":["../../../../../../../model/common/src/drivers/blob.ts","../../../../../../../model/common/src/util.ts","../../../../../../../model/common/src/drivers/ls.ts","../../../../../../../model/common/src/drivers/pframe/data_info.ts","../../../../../../../model/common/src/json.ts","../../../../../../../model/common/src/drivers/pframe/spec/spec.ts","../../../../../../../model/common/src/drivers/pframe/table_calculate.ts","../../../../../../../model/common/src/drivers/pframe/spec/ids.ts","../../../../../../../model/common/src/drivers/pframe/spec/anchored.ts","../../../../../../../model/common/src/pool/spec.ts","../../../../../../../model/common/src/drivers/pframe/spec/selectors.ts","../../../../../../../model/common/src/drivers/pframe/spec/native_id.ts","../../../../../../../model/common/src/ref.ts","../../../../../../../model/common/src/value_or_error.ts","../../../../../../../model/common/src/plid.ts"],"sourcesContent":["import type { Branded } from '../branding';\nimport { z } from 'zod';\n\n/** Handle of locally downloaded blob. This handle is issued only after the\n * blob's content is downloaded locally, and ready for quick access. */\nexport type LocalBlobHandle = Branded<string, 'LocalBlobHandle'>;\n\n/** Handle of remote blob. This handle is issued as soon as the data becomes\n * available on the remote server. */\nexport type RemoteBlobHandle = Branded<string, 'RemoteBlobHandle'>;\n\n/** Being configured inside the output structure provides information about\n * blob's content and means to retrieve it when needed. */\nexport interface BlobHandleAndSize<\n  H extends LocalBlobHandle | RemoteBlobHandle = | LocalBlobHandle\n  | RemoteBlobHandle,\n> {\n  /** Handle to retrieve block content using {@link BlobDriver.getContent()} */\n  readonly handle: H;\n\n  /** Blob size in bytes. */\n  readonly size: number;\n}\n\n/** Range in bytes, from should be less or equal than to. */\nexport const RangeBytes = z.object({\n  /** Included left border. */\n  from: z.number(),\n  /** Excluded right border. */\n  to: z.number(),\n});\n\nexport type RangeBytes = z.infer<typeof RangeBytes>;\n\nexport function newRangeBytesOpt(from?: number, to?: number): RangeBytes | undefined {\n  if (from == undefined || to == undefined) {\n    return undefined;\n  }\n\n  return { from, to };\n}\n\nexport function validateRangeBytes(range: RangeBytes, errMsg: string) {\n  if (range.from < 0 || range.to < 0 || range.from >= range.to) {\n    throw new Error(`${errMsg}: invalid bytes range: ${range}`);\n  }\n}\n\n/** Being configured inside the output structure provides information about\n * locally downloaded blob and means to retrieve it's content when needed. This\n * structure is created only after the blob's content is downloaded locally, and\n * ready for quick access. */\nexport type LocalBlobHandleAndSize = BlobHandleAndSize<LocalBlobHandle>;\n\n/** Being configured inside the output structure provides information about\n * remote blob and means to retrieve it's content when needed. This structure\n * is created as soon as remote blob becomes available. */\nexport type RemoteBlobHandleAndSize = BlobHandleAndSize<RemoteBlobHandle>;\n\n/** Defines API of blob driver as it is seen from the block UI code. */\nexport interface BlobDriver {\n  /** Given the blob handle returns its content. Depending on the handle type,\n   * content will be served from locally downloaded file, or directly from\n   * remote platforma storage. */\n  getContent(handle: LocalBlobHandle | RemoteBlobHandle, range?: RangeBytes): Promise<Uint8Array>;\n}\n","export function assertNever(x: never): never {\n  throw new Error('Unexpected object: ' + x); // This is ok, because this is a possible runtime error\n}\n","import { assertNever } from '../util';\nimport type { Branded } from '../branding';\nimport type { TableRange } from './pframe';\nimport type { FileLike } from './interfaces';\n\nconst uploadPrefix = 'upload://upload/';\nconst indexPrefix = 'index://index/';\n\nexport type ImportFileHandleUpload = `upload://upload/${string}`;\nexport type ImportFileHandleIndex = `index://index/${string}`;\n\nexport type ImportFileHandle = ImportFileHandleUpload | ImportFileHandleIndex;\n\nexport type LocalImportFileHandle = Branded<ImportFileHandle, 'Local'>;\n\nexport function isImportFileHandleUpload(\n  handle: ImportFileHandle,\n): handle is ImportFileHandleUpload {\n  return handle.startsWith(uploadPrefix);\n}\n\nexport function isImportFileHandleIndex(handle: ImportFileHandle): handle is ImportFileHandleIndex {\n  return handle.startsWith(indexPrefix);\n}\n\n/** Results in upload */\nexport type StorageHandleLocal = `local://${string}`;\n\n/** Results in index */\nexport type StorageHandleRemote = `remote://${string}`;\n\nexport type StorageHandle = StorageHandleLocal | StorageHandleRemote;\n\nexport type StorageEntry = {\n  name: string;\n  handle: StorageHandle;\n  initialFullPath: string;\n\n  // TODO\n  // pathStartsWithDisk\n};\n\nexport type ListFilesResult = {\n  parent?: string;\n  entries: LsEntry[];\n};\n\nexport type LsEntry =\n  | {\n    type: 'dir';\n    name: string;\n    fullPath: string;\n  }\n  | {\n    type: 'file';\n    name: string;\n    fullPath: string;\n\n    /** This handle should be set to args... */\n    handle: ImportFileHandle;\n  };\n\nexport type OpenDialogFilter = {\n  /** Human-readable file type name */\n  readonly name: string;\n  /** File extensions */\n  readonly extensions: string[];\n};\n\nexport type OpenDialogOps = {\n  /** Open dialog window title */\n  readonly title?: string;\n  /** Custom label for the confirmation button, when left empty the default label will be used. */\n  readonly buttonLabel?: string;\n  /** Limits of file types user can select */\n  readonly filters?: OpenDialogFilter[];\n};\n\nexport type OpenSingleFileResponse = {\n  /** Contains local file handle, allowing file importing or content reading. If user canceled\n   * the dialog, field will be undefined. */\n  readonly file?: LocalImportFileHandle;\n};\n\nexport type OpenMultipleFilesResponse = {\n  /** Contains local file handles, allowing file importing or content reading. If user canceled\n   * the dialog, field will be undefined. */\n  readonly files?: LocalImportFileHandle[];\n};\n\n/** Can be used to limit request for local file content to a certain bytes range */\nexport type FileRange = {\n  /** From byte index (inclusive) */\n  readonly from: number;\n  /** To byte index (exclusive) */\n  readonly to: number;\n};\n\nexport interface LsDriver {\n  /** remote and local storages */\n  getStorageList(): Promise<StorageEntry[]>;\n\n  listFiles(storage: StorageHandle, fullPath: string): Promise<ListFilesResult>;\n\n  /** Opens system file open dialog allowing to select single file and awaits user action */\n  showOpenSingleFileDialog(ops: OpenDialogOps): Promise<OpenSingleFileResponse>;\n\n  /** Opens system file open dialog allowing to multiple files and awaits user action */\n  showOpenMultipleFilesDialog(ops: OpenDialogOps): Promise<OpenMultipleFilesResponse>;\n\n  /** Given a handle to a local file, allows to get file size */\n  getLocalFileSize(file: LocalImportFileHandle): Promise<number>;\n\n  /** Given a handle to a local file, allows to get its content */\n  getLocalFileContent(file: LocalImportFileHandle, range?: TableRange): Promise<Uint8Array>;\n\n  /**\n   * Resolves browser's File object into platforma's import file handle.\n   *\n   * This method is useful among other things for implementation of UI\n   * components, that handle file Drag&Drop.\n   * */\n  fileToImportHandle(file: FileLike): Promise<ImportFileHandle>;\n\n  /** Saves currently opened block webview as a PDF. */\n  exportToPdf?(): Promise<void>;\n}\n\n/** Gets a file path from an import handle. */\nexport function getFilePathFromHandle(handle: ImportFileHandle): string {\n  if (isImportFileHandleIndex(handle)) {\n    const trimmed = handle.slice(indexPrefix.length);\n    const data = JSON.parse(decodeURIComponent(trimmed)) as { path: string };\n    return data.path;\n  } else if (isImportFileHandleUpload(handle)) {\n    const trimmed = handle.slice(uploadPrefix.length);\n    const data = JSON.parse(decodeURIComponent(trimmed)) as { localPath: string };\n    return data.localPath;\n  }\n\n  assertNever(handle);\n}\n\nfunction extractFileName(filePath: string) {\n  return filePath.replace(/^.*[\\\\/]/, '');\n}\n\n/** Gets a file name from an import handle. */\nexport function getFileNameFromHandle(handle: ImportFileHandle): string {\n  return extractFileName(getFilePathFromHandle(handle));\n}\n","import { assertNever } from '../../util';\n\n/**\n * Represents a JavaScript representation of a value in a PColumn. Can be null, a number, or a string.\n * These are the primitive types that can be stored directly in PColumns.\n *\n * Note: Actual columns can hold more value types, which are converted to these JavaScript types\n * once they enter the JavaScript runtime.\n */\nexport type PColumnValue = null | number | string;\n\n/**\n * Represents a key for a PColumn value.\n * Can be an array of strings or numbers.\n */\nexport type PColumnKey = (number | string)[];\n\n/**\n * Represents a single entry in a PColumn's data structure.\n * Contains a key and a value.\n */\nexport type PColumnDataEntry<T> = {\n  /** Key for the value */\n  key: PColumnKey;\n\n  /** Value / blob at the given key */\n  value: T;\n};\n\n/**\n * Represents column data stored as a simple JSON structure.\n * Used for small datasets that can be efficiently stored directly in memory.\n */\nexport type JsonDataInfo = {\n  /** Identifier for this data format ('Json') */\n  type: 'Json';\n\n  /** Number of axes that make up the complete key (tuple length) */\n  keyLength: number;\n\n  /**\n   * Key-value pairs where keys are stringified tuples of axis values\n   * and values are the column values for those coordinates\n   */\n  data: Record<string, PColumnValue>;\n};\n\n/**\n * Represents column data partitioned across multiple JSON blobs.\n * Used for larger datasets that need to be split into manageable chunks.\n */\nexport type JsonPartitionedDataInfo<Blob> = {\n  /** Identifier for this data format ('JsonPartitioned') */\n  type: 'JsonPartitioned';\n\n  /** Number of leading axes used for partitioning */\n  partitionKeyLength: number;\n\n  /** Map of stringified partition keys to blob references */\n  parts: Record<string, Blob>;\n};\n\n/**\n * Represents a binary format chunk containing index and values as separate blobs.\n * Used for efficient storage and retrieval of column data in binary format.\n */\nexport type BinaryChunk<Blob> = {\n  /** Binary blob containing structured index information */\n  index: Blob;\n\n  /** Binary blob containing the actual values */\n  values: Blob;\n};\n\n/**\n * Represents column data partitioned across multiple binary chunks.\n * Optimized for efficient storage and retrieval of large datasets.\n */\nexport type BinaryPartitionedDataInfo<Blob> = {\n  /** Identifier for this data format ('BinaryPartitioned') */\n  type: 'BinaryPartitioned';\n\n  /** Number of leading axes used for partitioning */\n  partitionKeyLength: number;\n\n  /** Map of stringified partition keys to binary chunks */\n  parts: Record<string, BinaryChunk<Blob>>;\n};\n\nexport type ParquetChunkMappingAxis = {\n  /** Data type (matches PColumn axis types) */\n  type: 'Int' | 'Long' | 'String';\n\n  /** Field name in the Parquet file */\n  id: string;\n};\n\nexport type ParquetChunkMappingColumn = {\n  /** Data type (matches PColumn value type) */\n  type: 'Int' | 'Long' | 'Float' | 'Double' | 'String';\n\n  /** Field name in the Parquet file */\n  id: string;\n};\n\nexport type ParquetChunkMapping = {\n  /** Axes mappings - Parquet file is sorted by these fields in this order */\n  axes: ParquetChunkMappingAxis[];\n\n  /** Column mapping */\n  column: ParquetChunkMappingColumn;\n};\n\nexport type ParquetChunkStats = {\n  /** Number of rows in the chunk */\n  numberOfRows: number;\n  /** Byte size information for storage optimization and query planning */\n  size: {\n    /** Byte sizes for each axis column in the same order as axes mapping */\n    axes: number[];\n    /** Byte size for the data column */\n    column: number;\n  };\n};\n\nexport type ParquetChunkMetadata = {\n  /** Content hash calculated for the specific axes and data this chunk represents */\n  dataDigest: string;\n\n  /** Pre-computed statistics for optimization without blob download */\n  stats: Partial<ParquetChunkStats>;\n};\n\nexport type ParquetChunk<Blob> = {\n  /** Parquet file (PTable) containing column data */\n  data: Blob;\n} & ParquetChunkMapping & Partial<ParquetChunkMetadata>;\n\nexport type ParquetPartitionedDataInfo<Blob> = {\n  /** Identifier for this data format ('ParquetPartitioned') */\n  type: 'ParquetPartitioned';\n\n  /** Number of leading axes used for partitioning */\n  partitionKeyLength: number;\n\n  /** Map of stringified partition keys to parquet files */\n  parts: Record<string, Blob>;\n};\n\n/**\n * Union type representing all possible data storage formats for PColumn data.\n * The specific format used depends on data size, access patterns, and performance requirements.\n *\n * @template Blob - Type parameter representing the storage reference type (could be ResourceInfo, PFrameBlobId, etc.)\n */\nexport type DataInfo<Blob> =\n  | JsonDataInfo\n  | JsonPartitionedDataInfo<Blob>\n  | BinaryPartitionedDataInfo<Blob>\n  | ParquetPartitionedDataInfo<Blob>;\n\n/**\n * Type guard function that checks if the given value is a valid DataInfo.\n *\n * @param value - The value to check\n * @returns True if the value is a valid DataInfo, false otherwise\n */\nexport function isDataInfo<Blob>(value: unknown): value is DataInfo<Blob> {\n  if (!value || typeof value !== 'object') {\n    return false;\n  }\n\n  const data = value as Record<string, unknown>;\n  if (!('type' in data)) {\n    return false;\n  }\n\n  switch (data.type) {\n    case 'Json':\n      return (\n        typeof data.keyLength === 'number'\n        && data.data !== undefined\n        && typeof data.data === 'object'\n      );\n    case 'JsonPartitioned':\n    case 'BinaryPartitioned':\n    case 'ParquetPartitioned':\n      return (\n        typeof data.partitionKeyLength === 'number'\n        && data.parts !== undefined\n        && typeof data.parts === 'object'\n      );\n    default:\n      return false;\n  }\n}\n\n/**\n * Maps blob references in a DataInfo object from one type to another using a mapping function.\n *\n * @template B1 - Source blob type\n * @template B2 - Target blob type\n * @param dataInfo - The source DataInfo object\n * @param mapFn - Function to transform blobs from type B1 to type B2\n * @returns A new DataInfo object with transformed blob references\n */\nexport function mapDataInfo<B1, B2>(\n  dataInfo: ParquetPartitionedDataInfo<B1>,\n  mapFn: (blob: B1) => B2,\n): ParquetPartitionedDataInfo<B2>;\nexport function mapDataInfo<B1, B2>(\n  dataInfo: Exclude<DataInfo<B1>, ParquetPartitionedDataInfo<B1>>,\n  mapFn: (blob: B1) => B2,\n): Exclude<DataInfo<B2>, ParquetPartitionedDataInfo<B2>>;\nexport function mapDataInfo<B1, B2>(\n  dataInfo: DataInfo<B1>,\n  mapFn: (blob: B1) => B2,\n): DataInfo<B2>;\nexport function mapDataInfo<B1, B2>(\n  dataInfo: DataInfo<B1> | undefined,\n  mapFn: (blob: B1) => B2,\n): DataInfo<B2> | undefined {\n  if (dataInfo === undefined) {\n    return undefined;\n  }\n\n  switch (dataInfo.type) {\n    case 'Json':\n      // Json type doesn't contain blobs, so return as is\n      return dataInfo;\n    case 'JsonPartitioned': {\n      // Map each blob in parts\n      const newParts: Record<string, B2> = {};\n      for (const [key, blob] of Object.entries(dataInfo.parts)) {\n        newParts[key] = mapFn(blob);\n      }\n      return {\n        ...dataInfo,\n        parts: newParts,\n      };\n    }\n    case 'BinaryPartitioned': {\n      // Map each index and values blob in parts\n      const newParts: Record<string, BinaryChunk<B2>> = {};\n      for (const [key, chunk] of Object.entries(dataInfo.parts)) {\n        newParts[key] = {\n          index: mapFn(chunk.index),\n          values: mapFn(chunk.values),\n        };\n      }\n      return {\n        ...dataInfo,\n        parts: newParts,\n      };\n    }\n    case 'ParquetPartitioned': {\n      // Map each blob in parts\n      const newParts: Record<string, B2> = {};\n      for (const [key, blob] of Object.entries(dataInfo.parts)) {\n        newParts[key] = mapFn(blob);\n      }\n      return {\n        ...dataInfo,\n        parts: newParts,\n      };\n    }\n  }\n}\n\n/**\n * @param dataInfo - The source DataInfo object\n * @param cb - Callback, function that have access to every blob to visit them all\n * @returns Nothing\n */\nexport function visitDataInfo<B>(\n  dataInfo: DataInfo<B>,\n  cb: (blob: B) => void,\n): void {\n  switch (dataInfo.type) {\n    case 'Json':\n      // Json type doesn't contain blobs, so return as is\n      break;\n    case 'JsonPartitioned': {\n      // Visit each blob in parts\n      Object.values(dataInfo.parts).forEach(cb);\n      break;\n    }\n    case 'BinaryPartitioned': {\n      // Visit each index and values blob in parts\n      Object.values(dataInfo.parts).forEach((chunk) => {\n        cb(chunk.index);\n        cb(chunk.values);\n      });\n      break;\n    }\n    case 'ParquetPartitioned': {\n      // Visit each blob in parts\n      Object.values(dataInfo.parts).forEach(cb);\n      break;\n    }\n  }\n}\n\n//\n// Lightway representation for ExplicitJsonData\n//\n\n/**\n * Represents a single key-value entry in a column's explicit data structure.\n * Used when directly instantiating PColumns with explicit data.\n */\nexport type PColumnValuesEntry = {\n  key: PColumnKey;\n  val: PColumnValue;\n};\n\n/**\n * Array of key-value entries representing explicit column data.\n * Used for lightweight explicit instantiation of PColumns.\n */\nexport type PColumnValues = PColumnValuesEntry[];\n\n/**\n * Entry-based representation of JsonDataInfo\n */\nexport interface JsonDataInfoEntries {\n  type: 'Json';\n  keyLength: number;\n  data: PColumnDataEntry<PColumnValue>[];\n}\n\n/**\n * Entry-based representation of JsonPartitionedDataInfo\n */\nexport interface JsonPartitionedDataInfoEntries<Blob> {\n  type: 'JsonPartitioned';\n  partitionKeyLength: number;\n  parts: PColumnDataEntry<Blob>[];\n}\n\n/**\n * Entry-based representation of BinaryPartitionedDataInfo\n */\nexport interface BinaryPartitionedDataInfoEntries<Blob> {\n  type: 'BinaryPartitioned';\n  partitionKeyLength: number;\n  parts: PColumnDataEntry<BinaryChunk<Blob>>[];\n}\n\n/**\n * Entry-based representation of ParquetPartitionedDataInfo\n */\nexport interface ParquetPartitionedDataInfoEntries<Blob> {\n  type: 'ParquetPartitioned';\n  partitionKeyLength: number;\n  parts: PColumnDataEntry<Blob>[];\n}\n/**\n * Union type representing all possible entry-based partitioned data storage formats\n */\nexport type PartitionedDataInfoEntries<Blob> =\n  | JsonPartitionedDataInfoEntries<Blob>\n  | BinaryPartitionedDataInfoEntries<Blob>\n  | ParquetPartitionedDataInfoEntries<Blob>;\n\n/**\n * Union type representing all possible entry-based data storage formats\n */\nexport type DataInfoEntries<Blob> =\n  | JsonDataInfoEntries\n  | PartitionedDataInfoEntries<Blob>;\n\n/**\n * Type guard function that checks if the given value is a valid DataInfoEntries.\n *\n * @param value - The value to check\n * @returns True if the value is a valid DataInfoEntries, false otherwise\n */\nexport function isDataInfoEntries<Blob>(value: unknown): value is DataInfoEntries<Blob> {\n  if (!value || typeof value !== 'object') {\n    return false;\n  }\n\n  const data = value as Record<string, unknown>;\n  if (!('type' in data)) {\n    return false;\n  }\n\n  switch (data.type) {\n    case 'Json':\n      return (\n        typeof data.keyLength === 'number'\n        && Array.isArray(data.data)\n      );\n    case 'JsonPartitioned':\n    case 'BinaryPartitioned':\n    case 'ParquetPartitioned':\n      return (\n        typeof data.partitionKeyLength === 'number'\n        && Array.isArray(data.parts)\n      );\n    default:\n      return false;\n  }\n}\n\n/**\n * Type guard function that checks if the given value is a valid PartitionedDataInfoEntries.\n *\n * @template Blob - Type parameter representing the storage reference type\n * @param value - The value to check\n * @returns True if the value is a valid PartitionedDataInfoEntries, false otherwise\n */\nexport function isPartitionedDataInfoEntries<Blob>(value: unknown): value is PartitionedDataInfoEntries<Blob> {\n  if (!isDataInfoEntries(value)) return false;\n  switch (value.type) {\n    case 'JsonPartitioned':\n    case 'BinaryPartitioned':\n    case 'ParquetPartitioned':\n      return true;\n    default:\n      return false;\n  }\n}\n\n/**\n * Converts DataInfo to DataInfoEntries\n *\n * @param dataInfo - The record-based DataInfo object\n * @returns The equivalent entry-based DataInfoEntries object\n */\nexport function dataInfoToEntries<Blob>(dataInfo: DataInfo<Blob>): DataInfoEntries<Blob> {\n  switch (dataInfo.type) {\n    case 'Json': return {\n      type: 'Json',\n      keyLength: dataInfo.keyLength,\n      data: Object.entries(dataInfo.data).map(([keyStr, value]) => {\n        const key = JSON.parse(keyStr) as PColumnKey;\n        return { key, value } as PColumnDataEntry<PColumnValue>;\n      }),\n    };\n    case 'JsonPartitioned': return {\n      type: 'JsonPartitioned',\n      partitionKeyLength: dataInfo.partitionKeyLength,\n      parts: Object.entries(dataInfo.parts).map(([keyStr, blob]) => {\n        const key = JSON.parse(keyStr) as PColumnKey;\n        return { key, value: blob } as PColumnDataEntry<Blob>;\n      }),\n    };\n    case 'BinaryPartitioned': return {\n      type: 'BinaryPartitioned',\n      partitionKeyLength: dataInfo.partitionKeyLength,\n      parts: Object.entries(dataInfo.parts).map(([keyStr, chunk]) => {\n        const key = JSON.parse(keyStr) as PColumnKey;\n        return { key, value: chunk } as PColumnDataEntry<BinaryChunk<Blob>>;\n      }),\n    };\n    case 'ParquetPartitioned': return {\n      type: 'ParquetPartitioned',\n      partitionKeyLength: dataInfo.partitionKeyLength,\n      parts: Object.entries(dataInfo.parts).map(([keyStr, blob]) => {\n        const key = JSON.parse(keyStr) as PColumnKey;\n        return { key, value: blob } as PColumnDataEntry<Blob>;\n      }),\n    };\n    default:\n      assertNever(dataInfo);\n  }\n}\n\n/**\n * Converts DataInfoEntries to DataInfo\n *\n * @param dataInfoEntries - The entry-based DataInfoEntries object\n * @returns The equivalent record-based DataInfo object\n */\nexport function entriesToDataInfo<Blob>(dataInfoEntries: DataInfoEntries<Blob>): DataInfo<Blob> {\n  switch (dataInfoEntries.type) {\n    case 'Json': return {\n      type: 'Json',\n      keyLength: dataInfoEntries.keyLength,\n      data: Object.fromEntries(\n        dataInfoEntries.data.map(({ key, value }) => [JSON.stringify(key), value]),\n      ),\n    };\n    case 'JsonPartitioned': return {\n      type: 'JsonPartitioned',\n      partitionKeyLength: dataInfoEntries.partitionKeyLength,\n      parts: Object.fromEntries(\n        dataInfoEntries.parts.map(({ key, value }) => [JSON.stringify(key), value]),\n      ),\n    };\n    case 'BinaryPartitioned': return {\n      type: 'BinaryPartitioned',\n      partitionKeyLength: dataInfoEntries.partitionKeyLength,\n      parts: Object.fromEntries(\n        dataInfoEntries.parts.map(({ key, value }) => [JSON.stringify(key), value]),\n      ),\n    };\n    case 'ParquetPartitioned': return {\n      type: 'ParquetPartitioned',\n      partitionKeyLength: dataInfoEntries.partitionKeyLength,\n      parts: Object.fromEntries(\n        dataInfoEntries.parts.map(({ key, value }) => [JSON.stringify(key), value]),\n      ),\n    };\n    default:\n      assertNever(dataInfoEntries);\n  }\n}\n\n/**\n * Maps blob references in a DataInfoEntries object from one type to another using a mapping function.\n *\n * @template B1 - Source blob type\n * @template B2 - Target blob type\n * @param dataInfoEntries - The source DataInfoEntries object\n * @param mapFn - Function to transform blobs from type B1 to type B2\n * @returns A new DataInfoEntries object with transformed blob references\n */\nexport function mapDataInfoEntries<B1, B2>(\n  dataInfoEntries: DataInfoEntries<B1>,\n  mapFn: (blob: B1) => B2,\n): DataInfoEntries<B2>;\nexport function mapDataInfoEntries<B1, B2>(\n  dataInfoEntries: DataInfoEntries<B1> | undefined,\n  mapFn: (blob: B1) => B2,\n): DataInfoEntries<B2> | undefined {\n  if (dataInfoEntries === undefined) {\n    return undefined;\n  }\n\n  switch (dataInfoEntries.type) {\n    case 'Json':\n      // Json type doesn't contain blobs, so return as is\n      return dataInfoEntries;\n    case 'JsonPartitioned': return {\n      ...dataInfoEntries,\n      parts: dataInfoEntries.parts.map((entry) => ({\n        key: entry.key,\n        value: mapFn(entry.value),\n      })),\n    };\n    case 'BinaryPartitioned': return {\n      ...dataInfoEntries,\n      parts: dataInfoEntries.parts.map((entry) => ({\n        key: entry.key,\n        value: {\n          index: mapFn(entry.value.index),\n          values: mapFn(entry.value.values),\n        },\n      })),\n    };\n    case 'ParquetPartitioned': return {\n      ...dataInfoEntries,\n      parts: dataInfoEntries.parts.map((entry) => ({\n        key: entry.key,\n        value: mapFn(entry.value),\n      })),\n    };\n  }\n}\n","import canonicalize from 'canonicalize';\n\ntype JsonPrimitive = string | number | boolean | null | undefined;\n\ntype JsonValue = JsonPrimitive | JsonValue[] | {\n  [key: string]: JsonValue;\n};\n\n// eslint-disable-next-line @typescript-eslint/no-unsafe-function-type\ntype NotAssignableToJson = bigint | symbol | Function;\n\nexport type JsonCompatible<T> = unknown extends T ? unknown : {\n  [P in keyof T]:\n  T[P] extends JsonValue ? T[P] :\n    T[P] extends NotAssignableToJson ? never :\n      JsonCompatible<T[P]>;\n};\n\nexport type StringifiedJson<T = unknown> = JsonCompatible<T> extends never ? never : string & {\n  __json_stringified: T;\n};\n\nexport function stringifyJson<T>(value: JsonCompatible<T>): StringifiedJson<T> {\n  return JSON.stringify(value)! as StringifiedJson<T>;\n}\n\nexport type CanonicalizedJson<T = unknown> = JsonCompatible<T> extends never ? never : string & {\n  __json_canonicalized: T;\n};\n\nexport function canonicalizeJson<T>(value: JsonCompatible<T>): CanonicalizedJson<T> {\n  return canonicalize(value)! as CanonicalizedJson<T>;\n}\n\nexport function parseJson<T>(value: StringifiedJson<T> | CanonicalizedJson<T>): T {\n  return JSON.parse(value) as T;\n}\n","import { ensureError } from '../../../errors';\nimport {\n  canonicalizeJson,\n  type CanonicalizedJson,\n  type StringifiedJson,\n} from '../../../json';\nimport type {\n  PObject,\n  PObjectId,\n  PObjectSpec,\n} from '../../../pool';\nimport { z } from 'zod';\n\ntype Expect<T extends true> = T;\ntype Equal<X, Y> =\n  (<T>() => T extends X ? 1 : 2) extends (<T>() => T extends Y ? 1 : 2) ? true : false;\n\nexport const ValueType = {\n  Int: 'Int',\n  Long: 'Long',\n  Float: 'Float',\n  Double: 'Double',\n  String: 'String',\n  Bytes: 'Bytes',\n} as const;\n\n/** PFrame columns and axes within them may store one of these types. */\nexport type ValueType = (typeof ValueType)[keyof typeof ValueType];\n\nexport type Metadata = Record<string, string>;\n\nexport function readMetadata<U extends Metadata, T extends keyof U = keyof U>(\n  metadata: Metadata | undefined,\n  key: T,\n): U[T] | undefined {\n  return (metadata as U | undefined)?.[key];\n}\n\ntype MetadataJsonImpl<M> = {\n  [P in keyof M as (M[P] extends StringifiedJson ? P : never)]: M[P] extends StringifiedJson<infer U> ? z.ZodType<U> : never;\n};\nexport type MetadataJson<M> = MetadataJsonImpl<Required<M>>;\n\nexport function readMetadataJsonOrThrow<M extends Metadata, T extends keyof MetadataJson<M>>(\n  metadata: Metadata | undefined,\n  metadataJson: MetadataJson<M>,\n  key: T,\n  methodNameInError: string = 'readMetadataJsonOrThrow',\n): z.infer<MetadataJson<M>[T]> | undefined {\n  const json = readMetadata<M, T>(metadata, key);\n  if (json === undefined) return undefined;\n\n  const schema = metadataJson[key];\n  try {\n    const value = JSON.parse(json);\n    return schema.parse(value);\n  } catch (error: unknown) {\n    throw new Error(\n      `${methodNameInError} failed, `\n      + `key: ${String(key)}, `\n      + `value: ${json}, `\n      + `error: ${ensureError(error)}`,\n    );\n  }\n}\n\nexport function readMetadataJson<M extends Metadata, T extends keyof MetadataJson<M>>(\n  metadata: Metadata | undefined,\n  metadataJson: MetadataJson<M>,\n  key: T,\n): z.infer<MetadataJson<M>[T]> | undefined {\n  try {\n    return readMetadataJsonOrThrow(metadata, metadataJson, key);\n  } catch {\n    return undefined; // treat invalid values as unset\n  }\n}\n\n/// Well-known domains\nexport const Domain = {\n  Alphabet: 'pl7.app/alphabet',\n  BlockId: 'pl7.app/blockId',\n} as const;\n\nexport type Domain = Metadata & Partial<{\n  [Domain.Alphabet]: 'nucleotide' | 'aminoacid' | string;\n  [Domain.BlockId]: string;\n}>;\n\nexport type DomainJson = MetadataJson<Domain>;\nexport const DomainJson: DomainJson = {};\n\n/// Helper function for reading plain domain values\nexport function readDomain<T extends keyof Domain>(\n  spec: { domain?: Metadata | undefined } | undefined,\n  key: T,\n): Domain[T] | undefined {\n  return readMetadata<Domain, T>(spec?.domain, key);\n}\n\n/// Helper function for reading json-encoded domain values, throws on JSON parsing error\nexport function readDomainJsonOrThrow<T extends keyof DomainJson>(\n  spec: { domain?: Metadata | undefined } | undefined,\n  key: T,\n): z.infer<DomainJson[T]> | undefined {\n  return readMetadataJsonOrThrow<Domain, T>(spec?.domain, DomainJson, key, 'readDomainJsonOrThrow');\n}\n\n/// Helper function for reading json-encoded domain values, returns undefined on JSON parsing error\nexport function readDomainJson<T extends keyof DomainJson>(\n  spec: { domain?: Metadata | undefined } | undefined,\n  key: T,\n): z.infer<DomainJson[T]> | undefined {\n  return readMetadataJson<Domain, T>(spec?.domain, DomainJson, key);\n}\n\n/// Well-known annotations\nexport const Annotation = {\n  Alphabet: 'pl7.app/alphabet',\n  DiscreteValues: 'pl7.app/discreteValues',\n  Format: 'pl7.app/format',\n  Graph: {\n    IsVirtual: 'pl7.app/graph/isVirtual',\n  },\n  HideDataFromUi: 'pl7.app/hideDataFromUi',\n  IsLinkerColumn: 'pl7.app/isLinkerColumn',\n  Label: 'pl7.app/label',\n  Max: 'pl7.app/max',\n  Min: 'pl7.app/min',\n  Parents: 'pl7.app/parents',\n  Sequence: {\n    Annotation: {\n      Mapping: 'pl7.app/sequence/annotation/mapping',\n    },\n    IsAnnotation: 'pl7.app/sequence/isAnnotation',\n  },\n  Table: {\n    FontFamily: 'pl7.app/table/fontFamily',\n    OrderPriority: 'pl7.app/table/orderPriority',\n    Visibility: 'pl7.app/table/visibility',\n  },\n  Trace: 'pl7.app/trace',\n} as const;\n\nexport type Annotation = Metadata & Partial<{\n  [Annotation.Alphabet]: 'nucleotide' | 'aminoacid' | string;\n  [Annotation.DiscreteValues]: StringifiedJson<number[]> | StringifiedJson<string[]>;\n  [Annotation.Format]: string;\n  [Annotation.Graph.IsVirtual]: StringifiedJson<boolean>;\n  [Annotation.HideDataFromUi]: StringifiedJson<boolean>;\n  [Annotation.IsLinkerColumn]: StringifiedJson<boolean>;\n  [Annotation.Label]: string;\n  [Annotation.Max]: StringifiedJson<number>;\n  [Annotation.Min]: StringifiedJson<number>;\n  [Annotation.Parents]: StringifiedJson<AxisSpec[]>;\n  [Annotation.Sequence.Annotation.Mapping]: StringifiedJson<Record<string, string>>;\n  [Annotation.Sequence.IsAnnotation]: StringifiedJson<boolean>;\n  [Annotation.Table.FontFamily]: string;\n  [Annotation.Table.OrderPriority]: StringifiedJson<number>;\n  [Annotation.Table.Visibility]: 'hidden' | 'optional' | string;\n  [Annotation.Trace]: StringifiedJson<Record<string, unknown>>;\n}>;\n\nexport const AxisSpec = z.object({\n  type: z.nativeEnum(ValueType),\n  name: z.string(),\n  domain: z.record(z.string(), z.string()).optional(),\n  annotations: z.record(z.string(), z.string()).optional(),\n  parentAxes: z.array(z.number()).optional(),\n}).passthrough();\ntype _test = Expect<Equal<\n  Readonly<z.infer<typeof AxisSpec>>,\n  Readonly<AxisSpec & Record<string, unknown>>\n>>;\n\nexport type AnnotationJson = MetadataJson<Annotation>;\nexport const AnnotationJson: AnnotationJson = {\n  [Annotation.DiscreteValues]: z.array(z.string()).or(z.array(z.number())),\n  [Annotation.Graph.IsVirtual]: z.boolean(),\n  [Annotation.HideDataFromUi]: z.boolean(),\n  [Annotation.IsLinkerColumn]: z.boolean(),\n  [Annotation.Max]: z.number(),\n  [Annotation.Min]: z.number(),\n  [Annotation.Parents]: z.array(AxisSpec),\n  [Annotation.Sequence.Annotation.Mapping]: z.record(z.string(), z.string()),\n  [Annotation.Sequence.IsAnnotation]: z.boolean(),\n  [Annotation.Table.OrderPriority]: z.number(),\n  [Annotation.Trace]: z.record(z.string(), z.unknown()),\n};\n\n/// Helper function for reading plain annotation values\nexport function readAnnotation<T extends keyof Annotation>(\n  spec: { annotations?: Metadata | undefined } | undefined,\n  key: T,\n): Annotation[T] | undefined {\n  return readMetadata<Annotation, T>(spec?.annotations, key);\n}\n\n/// Helper function for reading json-encoded annotation values, throws on JSON parsing error\nexport function readAnnotationJsonOrThrow<T extends keyof AnnotationJson>(\n  spec: { annotations?: Metadata | undefined } | undefined,\n  key: T,\n): z.infer<AnnotationJson[T]> | undefined {\n  return readMetadataJsonOrThrow<Annotation, T>(spec?.annotations, AnnotationJson, key, 'readAnnotationJsonOrThrow');\n}\n\n/// Helper function for reading json-encoded annotation values, returns undefined on JSON parsing error\nexport function readAnnotationJson<T extends keyof AnnotationJson>(\n  spec: { annotations?: Metadata | undefined } | undefined,\n  key: T,\n): z.infer<AnnotationJson[T]> | undefined {\n  return readMetadataJson<Annotation, T>(spec?.annotations, AnnotationJson, key);\n}\n\n/**\n * Specification of an individual axis.\n *\n * Each axis is a part of a composite key that addresses data inside the PColumn.\n *\n * Each record inside a PColumn is addressed by a unique tuple of values set for\n * all the axes specified in the column spec.\n * */\nexport interface AxisSpec {\n  /** Type of the axis value. Should not use non-key types like float or double. */\n  readonly type: ValueType;\n\n  /** Name of the axis */\n  readonly name: string;\n\n  /** Adds auxiliary information to the axis name, type and parents to form a\n   * unique identifier */\n  readonly domain?: Record<string, string>;\n\n  /** Any additional information attached to the axis that does not affect its\n   * identifier */\n  readonly annotations?: Record<string, string>;\n\n  /**\n   * Parent axes provide contextual grouping for the axis in question, establishing\n   * a hierarchy where the current axis is dependent on one or more axes for its\n   * full definition and meaning. For instance, in a data structure where each\n   * \"container\" axis may contain multiple \"item\" axes, the `item` axis would\n   * list the index of the `container` axis in this field to denote its dependency.\n   *\n   * This means that the identity or significance of the `item` axis is only\n   * interpretable when combined with its parent `container` axis. An `item` axis\n   * index by itself may be non-unique and only gains uniqueness within the context\n   * of its parent `container`. Therefore, the `parentAxes` field is essential for\n   * mapping these relationships and ensuring data coherence across nested or\n   * multi-level data models.\n   *\n   * A list of zero-based indices of parent axes in the overall axes specification\n   * from the column spec. Each index corresponds to the position of a parent axis\n   * in the list that defines the structure of the data model.\n   */\n  readonly parentAxes?: number[];\n}\n\n/** Parents are specs, not indexes; normalized axis can be used considering its parents independently from column */\nexport interface AxisSpecNormalized extends Omit<AxisSpec, 'parentAxes'> {\n  parentAxesSpec: AxisSpecNormalized[];\n}\n\n/** Tree: axis is a root, its parents are children */\nexport type AxisTree = {\n  axis: AxisSpecNormalized;\n  children: AxisTree[]; // parents\n};\n\nfunction makeAxisTree(axis: AxisSpecNormalized): AxisTree {\n  return { axis, children: [] };\n}\n\n/** Build tree by axis parents annotations */\nexport function getAxesTree(rootAxis: AxisSpecNormalized): AxisTree {\n  const root = makeAxisTree(rootAxis);\n  let nodesQ = [root];\n  while (nodesQ.length) {\n    const nextNodes: AxisTree[] = [];\n    for (const node of nodesQ) {\n      node.children = node.axis.parentAxesSpec.map(makeAxisTree);\n      nextNodes.push(...node.children);\n    }\n    nodesQ = nextNodes;\n  }\n  return root;\n}\n\n/** Get set of canonicalized axisIds from axisTree */\nexport function getSetFromAxisTree(tree: AxisTree): Set<CanonicalizedJson<AxisId>> {\n  const set = new Set([canonicalizeJson(getAxisId(tree.axis))]);\n  let nodesQ = [tree];\n  while (nodesQ.length) {\n    const nextNodes = [];\n    for (const node of nodesQ) {\n      for (const parent of node.children) {\n        set.add(canonicalizeJson(getAxisId(parent.axis)));\n        nextNodes.push(parent);\n      }\n    }\n    nodesQ = nextNodes;\n  }\n  return set;\n}\n\n/** Get array of axisSpecs from axisTree */\nexport function getArrayFromAxisTree(tree: AxisTree): AxisSpecNormalized[] {\n  const res = [tree.axis];\n  let nodesQ = [tree];\n  while (nodesQ.length) {\n    const nextNodes = [];\n    for (const node of nodesQ) {\n      for (const parent of node.children) {\n        res.push(parent.axis);\n        nextNodes.push(parent);\n      }\n    }\n    nodesQ = nextNodes;\n  }\n  return res;\n}\n\nexport function canonicalizeAxisWithParents(axis: AxisSpecNormalized) {\n  return canonicalizeJson(getArrayFromAxisTree(getAxesTree(axis)).map(getAxisId));\n}\n\nfunction normalizingAxesComparator(axis1: AxisSpecNormalized, axis2: AxisSpecNormalized): 1 | -1 | 0 {\n  if (axis1.name !== axis2.name) {\n    return axis1.name < axis2.name ? 1 : -1;\n  }\n  if (axis1.type !== axis2.type) {\n    return axis1.type < axis2.type ? 1 : -1;\n  }\n  const domain1 = canonicalizeJson(axis1.domain ?? {});\n  const domain2 = canonicalizeJson(axis2.domain ?? {});\n  if (domain1 !== domain2) {\n    return domain1 < domain2 ? 1 : -1;\n  }\n\n  const parents1 = canonicalizeAxisWithParents(axis1);\n  const parents2 = canonicalizeAxisWithParents(axis2);\n\n  if (parents1 !== parents2) {\n    return parents1 < parents2 ? 1 : -1;\n  }\n\n  const annotation1 = canonicalizeJson(axis1.annotations ?? {});\n  const annotation2 = canonicalizeJson(axis2.annotations ?? {});\n  if (annotation1 !== annotation2) {\n    return annotation1 < annotation2 ? 1 : -1;\n  }\n  return 0;\n}\n\nfunction parseParentsFromAnnotations(axis: AxisSpec) {\n  const parentsList = readAnnotationJson(axis, Annotation.Parents);\n  if (parentsList === undefined) {\n    return [];\n  }\n  return parentsList;\n}\n\nfunction sortParentsDeep(axisSpec: AxisSpecNormalized) {\n  axisSpec.parentAxesSpec.forEach(sortParentsDeep);\n  axisSpec.parentAxesSpec.sort(normalizingAxesComparator);\n}\n\nfunction hasCycleOfParents(axisSpec: AxisSpecNormalized) {\n  const root = makeAxisTree(axisSpec);\n  let nodesQ = [root];\n  const ancestors = new Set(canonicalizeJson(getAxisId(axisSpec)));\n  while (nodesQ.length) {\n    const nextNodes: AxisTree[] = [];\n    const levelIds = new Set<CanonicalizedJson<AxisId>>();\n    for (const node of nodesQ) {\n      node.children = node.axis.parentAxesSpec.map(makeAxisTree);\n      for (const child of node.children) {\n        const childId = canonicalizeJson(getAxisId(child.axis));\n        if (!levelIds.has(childId)) {\n          nextNodes.push(child);\n          levelIds.add(childId);\n          if (ancestors.has(childId)) {\n            return true;\n          }\n          ancestors.add(childId);\n        }\n      }\n    }\n    nodesQ = nextNodes;\n  }\n  return false;\n}\n\n/** Create list of normalized axisSpec (parents are in array of specs, not indexes) */\nexport function getNormalizedAxesList(axes: AxisSpec[]): AxisSpecNormalized[] {\n  if (!axes.length) {\n    return [];\n  }\n  const modifiedAxes: AxisSpecNormalized[] = axes.map((axis) => {\n    const { parentAxes: _, ...copiedRest } = axis;\n    return { ...copiedRest, annotations: { ...copiedRest.annotations }, parentAxesSpec: [] };\n  });\n\n  axes.forEach((axis, idx) => {\n    const modifiedAxis = modifiedAxes[idx];\n    if (axis.parentAxes) { // if we have parents by indexes then take from the list\n      modifiedAxis.parentAxesSpec = axis.parentAxes.map((idx) => modifiedAxes[idx]);\n    } else { // else try to parse from annotation and normalize recursively\n      modifiedAxis.parentAxesSpec = getNormalizedAxesList(parseParentsFromAnnotations(axis));\n      delete modifiedAxis.annotations?.[Annotation.Parents];\n    }\n  });\n\n  if (modifiedAxes.some(hasCycleOfParents)) { // Axes list is broken\n    modifiedAxes.forEach((axis) => {\n      axis.parentAxesSpec = [];\n    });\n  } else {\n    modifiedAxes.forEach((axis) => {\n      sortParentsDeep(axis);\n    });\n  }\n\n  return modifiedAxes;\n}\n\n/** Create list of regular axisSpec from normalized (parents are indexes, inside of current axes list) */\nexport function getDenormalizedAxesList(axesSpec: AxisSpecNormalized[]): AxisSpec[] {\n  const idsList = axesSpec.map((axisSpec) => canonicalizeJson(getAxisId(axisSpec)));\n  return axesSpec.map((axisSpec) => {\n    const parentsIds = axisSpec.parentAxesSpec.map((axisSpec) => canonicalizeJson(getAxisId(axisSpec)));\n    const parentIdxs = parentsIds.map((id) => idsList.indexOf(id));\n    const { parentAxesSpec: _, ...copiedRest } = axisSpec;\n    if (parentIdxs.length) {\n      return { ...copiedRest, parentAxes: parentIdxs } as AxisSpec;\n    }\n    return copiedRest;\n  });\n}\n\n/** Common type representing spec for all the axes in a column */\nexport type AxesSpec = AxisSpec[];\n\n/// Well-known column names\nexport const PColumnName = {\n  Label: 'pl7.app/label',\n  Table: {\n    RowSelection: 'pl7.app/table/row-selection',\n  },\n} as const;\n\n/**\n * Full column specification including all axes specs and specs of the column\n * itself.\n *\n * A PColumn in its essence represents a mapping from a fixed size, explicitly\n * typed tuple to an explicitly typed value.\n *\n * (axis1Value1, axis2Value1, ...) -> columnValue\n *\n * Each element in tuple correspond to the axis having the same index in axesSpec.\n * */\nexport interface PUniversalColumnSpec extends PObjectSpec {\n  /** Defines specific type of BObject, the most generic type of unit of\n   * information in Platforma Project. */\n  readonly kind: 'PColumn';\n\n  /** Type of column values */\n  readonly valueType: string;\n\n  /** Column name */\n  readonly name: string;\n\n  /** Adds auxiliary information to the axis name, type and parents to form a\n   * unique identifier */\n  readonly domain?: Record<string, string>;\n\n  /** Any additional information attached to the column that does not affect its\n   * identifier */\n  readonly annotations?: Record<string, string>;\n\n  /** A list of zero-based indices of parent axes from the {@link axesSpec} array. */\n  readonly parentAxes?: number[];\n\n  /** Axes specifications */\n  readonly axesSpec: AxesSpec;\n}\n\n/**\n * Specification of a data column.\n *\n * Data column is a specialized type of PColumn that stores only simple values (strings and numbers)\n * addressed by multiple keys. This is in contrast to other PColumn variants that can store more complex\n * values like files or other abstract data types. Data columns are optimized for storing and processing\n * basic tabular data.\n */\nexport interface PDataColumnSpec extends PUniversalColumnSpec {\n  /** Type of column values */\n  readonly valueType: ValueType;\n}\n\n// @todo: change this to PUniversalColumnSpec\nexport type PColumnSpec = PDataColumnSpec;\n\n/** Unique PColumnSpec identifier */\nexport type PColumnSpecId = {\n  /** Defines specific type of BObject, the most generic type of unit of\n   * information in Platforma Project. */\n  readonly kind: 'PColumn';\n\n  /** Type of column values */\n  readonly valueType: ValueType;\n\n  /** Column name */\n  readonly name: string;\n\n  /** Adds auxiliary information to the axis name, type and parents to form a\n   * unique identifier */\n  readonly domain?: Record<string, string>;\n\n  /** A list of zero-based indices of parent axes from the {@link axesSpec} array. */\n  readonly parentAxes?: number[];\n\n  /** Axes id */\n  readonly axesId: AxesId;\n};\n\nexport function getPColumnSpecId(spec: PColumnSpec): PColumnSpecId {\n  return {\n    kind: spec.kind,\n    valueType: spec.valueType,\n    name: spec.name,\n    domain: spec.domain,\n    parentAxes: spec.parentAxes,\n    axesId: getAxesId(spec.axesSpec),\n  };\n}\n\nexport interface PColumn<Data> extends PObject<Data> {\n  /** PColumn spec, allowing it to be found among other PObjects */\n  readonly spec: PColumnSpec;\n}\n\n/** Columns in a PFrame also have internal identifier, this object represents\n * combination of specs and such id */\nexport interface PColumnIdAndSpec {\n  /** Internal column id within the PFrame */\n  readonly columnId: PObjectId;\n\n  /** Column spec */\n  readonly spec: PColumnSpec;\n}\n\n/** Get column id and spec from a column */\nexport function getColumnIdAndSpec<Data>(column: PColumn<Data>): PColumnIdAndSpec {\n  return {\n    columnId: column.id,\n    spec: column.spec,\n  };\n}\n\n/** Information returned by {@link PFrame.listColumns} method */\nexport interface PColumnInfo extends PColumnIdAndSpec {\n  /** True if data was associated with this PColumn */\n  readonly hasData: boolean;\n}\n\nexport interface AxisId {\n  /** Type of the axis or column value. For an axis should not use non-key\n   * types like float or double. */\n  readonly type: ValueType;\n\n  /** Name of the axis or column */\n  readonly name: string;\n\n  /** Adds auxiliary information to the axis or column name and type to form a\n   * unique identifier */\n  readonly domain?: Record<string, string>;\n}\n\n/** Array of axis ids */\nexport type AxesId = AxisId[];\n\n/** Extracts axis ids from axis spec */\nexport function getAxisId(spec: AxisSpec): AxisId {\n  const { type, name, domain } = spec;\n  const result = { type, name };\n  if (domain && Object.entries(domain).length > 0) {\n    Object.assign(result, { domain });\n  }\n  return result;\n}\n\n/** Extracts axes ids from axes spec array from column spec */\nexport function getAxesId(spec: AxesSpec): AxesId {\n  return spec.map(getAxisId);\n}\n\n/** Canonicalizes axis id */\nexport function canonicalizeAxisId(id: AxisId): CanonicalizedJson<AxisId> {\n  return canonicalizeJson(getAxisId(id));\n}\n\n/** Returns true if all domains from query are found in target */\nfunction matchDomain(query?: Record<string, string>, target?: Record<string, string>) {\n  if (query === undefined) return target === undefined;\n  if (target === undefined) return true;\n  for (const k in target) {\n    if (query[k] !== target[k]) return false;\n  }\n  return true;\n}\n\n/** Returns whether \"match\" axis id is compatible with the \"query\" */\nexport function matchAxisId(query: AxisId, target: AxisId): boolean {\n  return query.name === target.name && matchDomain(query.domain, target.domain);\n}\n","import type { PTableColumnId, PTableColumnSpec } from './table_common';\nimport type { PTableVector } from './data_types';\nimport type { PObjectId } from '../../pool';\nimport { assertNever } from '../../util';\nimport type { PColumn } from './spec/spec';\nimport type { PColumnValues } from './data_info';\n\n/** Defines a terminal column node in the join request tree */\nexport interface ColumnJoinEntry<Col> {\n  /** Node type discriminator */\n  readonly type: 'column';\n\n  /** Local column */\n  readonly column: Col;\n}\n\n/**\n * Axis filter slicing target axis from column axes.\n * If the axis has parents or is a parent, slicing cannot be applied (an error will be thrown).\n * */\nexport interface ConstantAxisFilter {\n  /** Filter type discriminator */\n  readonly type: 'constant';\n\n  /** Index of axis to slice (zero-based) */\n  readonly axisIndex: number;\n\n  /** Equality filter reference value, see {@link SingleValueEqualPredicate} */\n  readonly constant: string | number;\n}\n\n/** Defines a terminal column node in the join request tree */\nexport interface SlicedColumnJoinEntry<Col> {\n  /** Node type discriminator */\n  readonly type: 'slicedColumn';\n\n  /** Local column */\n  readonly column: Col;\n\n  /** New column id */\n  readonly newId: PObjectId;\n\n  /** Non-empty list of axis filters */\n  readonly axisFilters: ConstantAxisFilter[];\n}\n\n/** Defines a terminal column node in the join request tree */\nexport interface InlineColumnJoinEntry {\n  /** Node type discriminator */\n  readonly type: 'inlineColumn';\n\n  /** Column definition */\n  readonly column: PColumn<PColumnValues>;\n}\n\n/**\n * Defines a join request tree node that will output only records present in\n * all child nodes ({@link entries}).\n * */\nexport interface InnerJoin<Col> {\n  /** Node type discriminator */\n  readonly type: 'inner';\n\n  /** Child nodes to be inner joined */\n  readonly entries: JoinEntry<Col>[];\n}\n\n/**\n * Defines a join request tree node that will output all records present at\n * least in one of the child nodes ({@link entries}), values for those PColumns\n * that lacks corresponding combinations of axis values will be marked as absent,\n * see {@link PTableVector.absent}.\n * */\nexport interface FullJoin<Col> {\n  /** Node type discriminator */\n  readonly type: 'full';\n\n  /** Child nodes to be fully outer joined */\n  readonly entries: JoinEntry<Col>[];\n}\n\n/**\n * Defines a join request tree node that will output all records present in\n * {@link primary} child node, and records from the {@link secondary} nodes will\n * be added to the output only if present, values for those PColumns from the\n * {@link secondary} list, that lacks corresponding combinations of axis values\n * will be marked as absent, see {@link PTableVector.absent}.\n *\n * This node can be thought as a chain of SQL LEFT JOIN operations starting from\n * the {@link primary} node and adding {@link secondary} nodes one by one.\n * */\nexport interface OuterJoin<Col> {\n  /** Node type discriminator */\n  readonly type: 'outer';\n\n  /** Primes the join operation. Left part of LEFT JOIN. */\n  readonly primary: JoinEntry<Col>;\n\n  /** Driven nodes, giving their values only if primary node have corresponding\n   * nodes. Right parts of LEFT JOIN chain. */\n  readonly secondary: JoinEntry<Col>[];\n}\n\n/**\n * Base type of all join request tree nodes. Join request tree allows to combine\n * information from multiple PColumns into a PTable. Correlation between records\n * is performed by looking for records with the same values in common axis between\n * the PColumns. Common axis are those axis which have equal {@link AxisId} derived\n * from the columns axes spec.\n * */\nexport type JoinEntry<Col> =\n  | ColumnJoinEntry<Col>\n  | SlicedColumnJoinEntry<Col>\n  | InlineColumnJoinEntry\n  | InnerJoin<Col>\n  | FullJoin<Col>\n  | OuterJoin<Col>;\n\n/** Container representing whole data stored in specific PTable column. */\nexport interface FullPTableColumnData {\n  /** Unified spec */\n  readonly spec: PTableColumnSpec;\n\n  /** Data */\n  readonly data: PTableVector;\n}\n\nexport interface SingleValueIsNAPredicate {\n  /** Comparison operator */\n  readonly operator: 'IsNA';\n}\n\nexport interface SingleValueEqualPredicate {\n  /** Comparison operator */\n  readonly operator: 'Equal';\n\n  /** Reference value, NA values will not match */\n  readonly reference: string | number;\n}\n\nexport interface SingleValueInSetPredicate {\n  /** Comparison operator */\n  readonly operator: 'InSet';\n\n  /** Reference values, NA values will not match */\n  readonly references: (string | number)[];\n}\n\nexport interface SingleValueIEqualPredicate {\n  /** Comparison operator (case insensitive) */\n  readonly operator: 'IEqual';\n\n  /** Reference value, NA values will not match */\n  readonly reference: string;\n}\n\nexport interface SingleValueLessPredicate {\n  /** Comparison operator */\n  readonly operator: 'Less';\n\n  /** Reference value, NA values will not match */\n  readonly reference: string | number;\n}\n\nexport interface SingleValueLessOrEqualPredicate {\n  /** Comparison operator */\n  readonly operator: 'LessOrEqual';\n\n  /** Reference value, NA values will not match */\n  readonly reference: string | number;\n}\n\nexport interface SingleValueGreaterPredicate {\n  /** Comparison operator */\n  readonly operator: 'Greater';\n\n  /** Reference value, NA values will not match */\n  readonly reference: string | number;\n}\n\nexport interface SingleValueGreaterOrEqualPredicate {\n  /** Comparison operator */\n  readonly operator: 'GreaterOrEqual';\n\n  /** Reference value, NA values will not match */\n  readonly reference: string | number;\n}\n\nexport interface SingleValueStringContainsPredicate {\n  /** Comparison operator */\n  readonly operator: 'StringContains';\n\n  /** Reference substring, NA values are skipped */\n  readonly substring: string;\n}\n\nexport interface SingleValueStringIContainsPredicate {\n  /** Comparison operator (case insensitive) */\n  readonly operator: 'StringIContains';\n\n  /** Reference substring, NA values are skipped */\n  readonly substring: string;\n}\n\nexport interface SingleValueMatchesPredicate {\n  /** Comparison operator */\n  readonly operator: 'Matches';\n\n  /** Regular expression, NA values are skipped */\n  readonly regex: string;\n}\n\nexport interface SingleValueStringContainsFuzzyPredicate {\n  /** Comparison operator */\n  readonly operator: 'StringContainsFuzzy';\n\n  /** Reference value, NA values are skipped */\n  readonly reference: string;\n\n  /**\n   * Integer specifying the upper bound of edit distance between\n   * reference and actual value.\n   * When {@link substitutionsOnly} is not defined or set to false\n   * Levenshtein distance is used (substitutions and indels)\n   * @see https://en.wikipedia.org/wiki/Levenshtein_distance\n   * When {@link substitutionsOnly} is set to true\n   * Hamming distance is used (substitutions only)\n   * @see https://en.wikipedia.org/wiki/Hamming_distance\n   */\n  readonly maxEdits: number;\n\n  /** Changes the type of edit distance in {@link maxEdits} */\n  readonly substitutionsOnly?: boolean;\n\n  /**\n   * Some character in {@link reference} that will match any\n   * single character in searched text.\n   */\n  readonly wildcard?: string;\n}\n\nexport interface SingleValueStringIContainsFuzzyPredicate {\n  /** Comparison operator (case insensitive) */\n  readonly operator: 'StringIContainsFuzzy';\n\n  /** Reference value, NA values are skipped */\n  readonly reference: string;\n\n  /**\n   * Integer specifying the upper bound of edit distance between\n   * reference and actual value.\n   * When {@link substitutionsOnly} is not defined or set to false\n   * Levenshtein distance is used (substitutions and indels)\n   * @see https://en.wikipedia.org/wiki/Levenshtein_distance\n   * When {@link substitutionsOnly} is set to true\n   * Hamming distance is used (substitutions only)\n   * @see https://en.wikipedia.org/wiki/Hamming_distance\n   */\n  readonly maxEdits: number;\n\n  /** Changes the type of edit distance in {@link maxEdits} */\n  readonly substitutionsOnly?: boolean;\n\n  /**\n   * Some character in {@link reference} that will match any\n   * single character in searched text.\n   */\n  readonly wildcard?: string;\n}\n\nexport interface SingleValueNotPredicateV2 {\n  /** Comparison operator */\n  readonly operator: 'Not';\n\n  /** Operand to negate */\n  readonly operand: SingleValuePredicateV2;\n}\n\nexport interface SingleValueAndPredicateV2 {\n  /** Comparison operator */\n  readonly operator: 'And';\n\n  /** Operands to combine */\n  readonly operands: SingleValuePredicateV2[];\n}\n\nexport interface SingleValueOrPredicateV2 {\n  /** Comparison operator */\n  readonly operator: 'Or';\n\n  /** Operands to combine */\n  readonly operands: SingleValuePredicateV2[];\n}\n\n/** Filtering predicate for a single axis or column value */\nexport type SingleValuePredicateV2 =\n  | SingleValueIsNAPredicate\n  | SingleValueEqualPredicate\n  | SingleValueInSetPredicate\n  | SingleValueLessPredicate\n  | SingleValueLessOrEqualPredicate\n  | SingleValueGreaterPredicate\n  | SingleValueGreaterOrEqualPredicate\n  | SingleValueStringContainsPredicate\n  | SingleValueMatchesPredicate\n  | SingleValueStringContainsFuzzyPredicate\n  | SingleValueNotPredicateV2\n  | SingleValueAndPredicateV2\n  | SingleValueOrPredicateV2\n  | SingleValueIEqualPredicate\n  | SingleValueStringIContainsPredicate\n  | SingleValueStringIContainsFuzzyPredicate;\n\n/**\n * Filter PTable records based on specific axis or column value. If this is an\n * axis value filter and the axis is part of a partitioning key in some of the\n * source PColumns, the filter will be pushed down to those columns, so only\n * specific partitions will be retrieved from the remote storage.\n * */\nexport interface PTableRecordSingleValueFilterV2 {\n  /** Filter type discriminator */\n  readonly type: 'bySingleColumnV2';\n\n  /** Target axis selector to examine values from */\n  readonly column: PTableColumnId;\n\n  /** Value predicate */\n  readonly predicate: SingleValuePredicateV2;\n}\n\n/** Generic PTable records filter */\nexport type PTableRecordFilter = PTableRecordSingleValueFilterV2;\n\n/** Sorting parameters for a PTable.  */\nexport type PTableSorting = {\n  /** Unified column identifier */\n  readonly column: PTableColumnId;\n\n  /** Sorting order */\n  readonly ascending: boolean;\n\n  /** Sorting in respect to NA and absent values */\n  readonly naAndAbsentAreLeastValues: boolean;\n};\n\n/** Information required to instantiate a PTable. */\nexport interface PTableDef<Col> {\n  /** Join tree to populate the PTable */\n  readonly src: JoinEntry<Col>;\n\n  /** Partition filters */\n  readonly partitionFilters: PTableRecordFilter[];\n\n  /** Record filters */\n  readonly filters: PTableRecordFilter[];\n\n  /** Table sorting */\n  readonly sorting: PTableSorting[];\n}\n\n/** Request to create and retrieve entirety of data of PTable. */\nexport type CalculateTableDataRequest<Col> = {\n  /** Join tree to populate the PTable */\n  readonly src: JoinEntry<Col>;\n\n  /** Record filters */\n  readonly filters: PTableRecordFilter[];\n\n  /** Table sorting */\n  readonly sorting: PTableSorting[];\n};\n\n/** Response for {@link CalculateTableDataRequest} */\nexport type CalculateTableDataResponse = FullPTableColumnData[];\n\nexport function mapPTableDef<C1, C2>(\n  def: PTableDef<C1>,\n  cb: (c: C1) => C2,\n): PTableDef<C2> {\n  return { ...def, src: mapJoinEntry(def.src, cb) };\n}\n\nexport function mapJoinEntry<C1, C2>(\n  entry: JoinEntry<C1>,\n  cb: (c: C1) => C2,\n): JoinEntry<C2> {\n  switch (entry.type) {\n    case 'column':\n      return {\n        type: 'column',\n        column: cb(entry.column),\n      };\n    case 'slicedColumn':\n      return {\n        type: 'slicedColumn',\n        column: cb(entry.column),\n        newId: entry.newId,\n        axisFilters: entry.axisFilters,\n      };\n    case 'inlineColumn':\n      return entry;\n    case 'inner':\n    case 'full':\n      return {\n        type: entry.type,\n        entries: entry.entries.map((col) => mapJoinEntry(col, cb)),\n      };\n    case 'outer':\n      return {\n        type: 'outer',\n        primary: mapJoinEntry(entry.primary, cb),\n        secondary: entry.secondary.map((col) => mapJoinEntry(col, cb)),\n      };\n    default:\n      assertNever(entry);\n  }\n}\n","import type { Branded } from '../../../branding';\nimport type { AnchoredPColumnId } from './selectors';\nimport type { FilteredPColumnId } from './filtered_column';\nimport canonicalize from 'canonicalize';\nimport type { PObjectId } from '../../../pool';\n/**\n * Universal column identifier optionally anchored and optionally filtered.\n */\nexport type UniversalPColumnId = AnchoredPColumnId | FilteredPColumnId;\n\n/**\n * Canonically serialized {@link UniversalPColumnId}.\n */\nexport type SUniversalPColumnId = Branded<PObjectId, 'SUniversalPColumnId', '__pl_model_brand_2__'>;\n\n/**\n * Canonically serializes a {@link UniversalPColumnId} to a string.\n * @param id - The column identifier to serialize\n * @returns The canonically serialized string\n */\nexport function stringifyColumnId(id: UniversalPColumnId): SUniversalPColumnId {\n  return canonicalize(id)! as SUniversalPColumnId;\n}\n\n/**\n * Parses a canonically serialized {@link UniversalPColumnId} from a string.\n * @param str - The string to parse\n * @returns The parsed column identifier\n */\nexport function parseColumnId(str: SUniversalPColumnId): UniversalPColumnId {\n  return JSON.parse(str) as UniversalPColumnId;\n}\n","import canonicalize from 'canonicalize';\nimport type { AxisFilter, AxisFilterValue } from './filtered_column';\nimport type { SUniversalPColumnId, UniversalPColumnId } from './ids';\nimport { stringifyColumnId } from './ids';\nimport type { AAxisSelector, AnchorAxisRef, AnchorAxisRefByIdx, AnchoredPColumnId, AnchoredPColumnSelector, AxisSelector, PColumnSelector } from './selectors';\nimport type { AxisId, PColumnSpec } from './spec';\nimport { getAxisId, matchAxisId } from './spec';\n\n//\n// Helper functions\n//\n\nfunction axisKey(axis: AxisId): string {\n  return canonicalize(getAxisId(axis))!;\n}\n\nfunction domainKey(key: string, value: string): string {\n  return JSON.stringify([key, value]);\n}\n\n/**\n * Context for resolving and generating anchored references to columns and axes\n * Maintains maps of known domain values and axes that can be referenced by anchors\n */\nexport class AnchoredIdDeriver {\n  private readonly domains = new Map<string, string>();\n  private readonly axes = new Map<string, AnchorAxisRefByIdx>();\n  /**\n   * Domain packs are used to group domain keys that can be anchored to the same anchor\n   * This is used to optimize the lookup of domain anchors\n   */\n  private readonly domainPacks: string[][] = [];\n  /**\n   * Maps domain packs to anchors\n   */\n  private readonly domainPackToAnchor = new Map<string, string>();\n\n  /**\n   * Creates a new anchor context from a set of anchor column specifications\n   * @param anchors Record of anchor column specifications indexed by anchor ID\n   */\n  constructor(public readonly anchors: Record<string, PColumnSpec>) {\n    const anchorEntries = Object.entries(anchors);\n    anchorEntries.sort((a, b) => a[0].localeCompare(b[0]));\n    for (const [anchorId, spec] of anchorEntries) {\n      for (let axisIdx = 0; axisIdx < spec.axesSpec.length; axisIdx++) {\n        const axis = spec.axesSpec[axisIdx];\n        const key = axisKey(axis);\n        this.axes.set(key, { anchor: anchorId, idx: axisIdx });\n      }\n      if (spec.domain !== undefined) {\n        const domainEntries = Object.entries(spec.domain);\n        domainEntries.sort((a, b) => a[0].localeCompare(b[0]));\n\n        this.domainPackToAnchor.set(JSON.stringify(domainEntries), anchorId);\n        this.domainPacks.push(domainEntries.map(([dKey]) => dKey));\n\n        for (const [dKey, dValue] of domainEntries) {\n          const key = domainKey(dKey, dValue);\n          this.domains.set(key, anchorId);\n        }\n      }\n    }\n  }\n\n  /**\n   * Derives an anchored column identifier from a column specification\n   * @param spec Column specification to anchor\n   * @returns An anchored column identifier that can be used to identify columns similar to the input specification\n   */\n  derive(spec: PColumnSpec): AnchoredPColumnId;\n\n  /**\n   * Derives an anchored column identifier from a column specification\n   * @param spec Column specification to anchor\n   * @param axisFilters Axis filters to apply to the column\n   * @returns An anchored and sliced column identifier that can be used to identify columns similar to the input specification\n   */\n  derive(spec: PColumnSpec, axisFilters?: AxisFilter[]): UniversalPColumnId;\n\n  /**\n   * Implementation of derive method\n   */\n  derive(spec: PColumnSpec, axisFilters?: AxisFilter[]): UniversalPColumnId {\n    const result: AnchoredPColumnId = {\n      name: spec.name,\n      axes: [],\n    };\n\n    let skipDomains: Set<string> | undefined = undefined;\n    if (spec.domain !== undefined) {\n      outer:\n      for (const domainPack of this.domainPacks) {\n        const dAnchor: string[][] = [];\n        for (const domainKey of domainPack) {\n          const dValue = spec.domain[domainKey];\n          if (dValue !== undefined)\n            dAnchor.push([domainKey, dValue]);\n          else\n            break outer;\n        }\n        const domainAnchor = this.domainPackToAnchor.get(JSON.stringify(dAnchor));\n        if (domainAnchor !== undefined) {\n          result.domainAnchor = domainAnchor;\n          skipDomains = new Set(domainPack);\n          break;\n        }\n      }\n    }\n\n    for (const [dKey, dValue] of Object.entries(spec.domain ?? {})) {\n      if (skipDomains !== undefined && skipDomains.has(dKey))\n        continue;\n      const key = domainKey(dKey, dValue);\n      const anchorId = this.domains.get(key);\n      result.domain ??= {};\n      result.domain[dKey] = anchorId ? { anchor: anchorId } : dValue;\n    }\n\n    result.axes = spec.axesSpec.map((axis) => {\n      const key = axisKey(axis);\n      const anchorAxisRef = this.axes.get(key);\n      if (anchorAxisRef === undefined) return getAxisId(axis);\n      else return anchorAxisRef;\n    });\n\n    // If no axis filters are provided, return the anchored ID as is\n    if (!axisFilters || axisFilters.length === 0) {\n      return result;\n    }\n\n    // Process axis filters and create a sliced column ID\n    const resolvedFilters: [number, AxisFilterValue][] = [];\n\n    for (const filter of axisFilters) {\n      const [axisIdOrIndex, value] = filter;\n\n      // If it's already a numeric index, validate it\n      if (typeof axisIdOrIndex === 'number') {\n        if (axisIdOrIndex < 0 || axisIdOrIndex >= spec.axesSpec.length) {\n          throw new Error(`Axis index ${axisIdOrIndex} is out of bounds (0-${spec.axesSpec.length - 1})`);\n        }\n        resolvedFilters.push([axisIdOrIndex, value]);\n      } else {\n        // If it's a string (axis name), resolve it to an index\n        const axisIndex = spec.axesSpec.findIndex((axis) => axis.name === axisIdOrIndex);\n        if (axisIndex === -1) {\n          throw new Error(`Axis with name \"${axisIdOrIndex}\" not found in the column specification`);\n        }\n        resolvedFilters.push([axisIndex, value]);\n      }\n    }\n\n    // Sort filters by axis index to ensure consistency\n    resolvedFilters.sort((a, b) => a[0] - b[0]);\n\n    return {\n      source: result,\n      axisFilters: resolvedFilters,\n    };\n  }\n\n  /**\n   * Derives a canonicalized string representation of an anchored column identifier, can be used as a unique identifier for the column\n   * @param spec Column specification to anchor\n   * @param axisFilters Optional axis filters to apply to the column\n   * @returns A canonicalized string representation of the anchored column identifier\n   */\n  deriveS(spec: PColumnSpec, axisFilters?: AxisFilter[]): SUniversalPColumnId {\n    return stringifyColumnId(this.derive(spec, axisFilters));\n  }\n}\n\n/**\n * Options for the resolveAnchors function\n */\nexport type ResolveAnchorsOptions = {\n  /**\n   * If true, missing domain keys in anchors will be ignored.\n   * If false (default), an error will be thrown.\n   */\n  ignoreMissingDomains?: boolean;\n};\n\n/**\n * Resolves anchored references in a column matcher to create a non-anchored matcher.\n * Doing an opposite operation to {@link AnchorIdDeriver.derive()}.\n *\n * @param anchors - Record of anchor column specifications indexed by anchor id\n * @param matcher - An anchored column matcher (or id, which is subtype of it) containing references that need to be resolved\n * @param options - Options for resolving anchors\n * @returns A non-anchored column matcher with all references resolved to actual values\n */\nexport function resolveAnchors(anchors: Record<string, PColumnSpec>, matcher: AnchoredPColumnSelector, options?: ResolveAnchorsOptions): PColumnSelector {\n  const result = { ...matcher };\n  const ignoreMissingDomains = options?.ignoreMissingDomains ?? false;\n\n  if (result.domainAnchor !== undefined) {\n    const anchorSpec = anchors[result.domainAnchor];\n    if (!anchorSpec)\n      throw new Error(`Anchor \"${result.domainAnchor}\" not found`);\n\n    const anchorDomains = anchorSpec.domain || {};\n    result.domain = { ...anchorDomains, ...result.domain };\n    delete result.domainAnchor;\n  }\n\n  if (result.domain) {\n    const resolvedDomain: Record<string, string> = {};\n    for (const [key, value] of Object.entries(result.domain)) {\n      if (typeof value === 'string') {\n        resolvedDomain[key] = value;\n      } else {\n        // It's an AnchorDomainRef\n        const anchorSpec = anchors[value.anchor];\n        if (!anchorSpec)\n          throw new Error(`Anchor \"${value.anchor}\" not found for domain key \"${key}\"`);\n\n        if (!anchorSpec.domain || anchorSpec.domain[key] === undefined) {\n          if (!ignoreMissingDomains)\n            throw new Error(`Domain key \"${key}\" not found in anchor \"${value.anchor}\"`);\n          continue;\n        }\n\n        resolvedDomain[key] = anchorSpec.domain[key];\n      }\n    }\n    result.domain = resolvedDomain;\n  }\n\n  if (result.axes)\n    result.axes = result.axes.map((axis) => resolveAxisReference(anchors, axis));\n\n  return result as PColumnSelector;\n}\n\n/**\n * Resolves an anchored axis reference to a concrete AxisId\n */\nfunction resolveAxisReference(anchors: Record<string, PColumnSpec>, axisRef: AAxisSelector): AxisSelector {\n  if (!isAnchorAxisRef(axisRef))\n    return axisRef;\n\n  // It's an anchored reference\n  const anchorId = axisRef.anchor;\n  const anchorSpec = anchors[anchorId];\n  if (!anchorSpec)\n    throw new Error(`Anchor \"${anchorId}\" not found for axis reference`);\n\n  if ('idx' in axisRef) {\n    // AnchorAxisRefByIdx\n    if (axisRef.idx < 0 || axisRef.idx >= anchorSpec.axesSpec.length)\n      throw new Error(`Axis index ${axisRef.idx} out of bounds for anchor \"${anchorId}\"`);\n    return anchorSpec.axesSpec[axisRef.idx];\n  } else if ('name' in axisRef) {\n    // AnchorAxisRefByName\n    const matches = anchorSpec.axesSpec.filter((axis) => axis.name === axisRef.name);\n    if (matches.length > 1)\n      throw new Error(`Multiple axes with name \"${axisRef.name}\" found in anchor \"${anchorId}\"`);\n    if (matches.length === 0)\n      throw new Error(`Axis with name \"${axisRef.name}\" not found in anchor \"${anchorId}\"`);\n    return matches[0];\n  } else if ('id' in axisRef) {\n    // AnchorAxisRefByMatcher\n    const matches = anchorSpec.axesSpec.filter((axis) => matchAxisId(axisRef.id, getAxisId(axis)));\n    if (matches.length > 1)\n      throw new Error(`Multiple matching axes found for matcher in anchor \"${anchorId}\"`);\n    if (matches.length === 0)\n      throw new Error(`No matching axis found for matcher in anchor \"${anchorId}\"`);\n    return matches[0];\n  }\n\n  throw new Error(`Unsupported axis reference type`);\n}\n\n/**\n * Type guard to check if a value is an anchored axis reference\n */\nfunction isAnchorAxisRef(value: AAxisSelector): value is AnchorAxisRef {\n  return typeof value === 'object' && 'anchor' in value;\n}\n","import type { Branded } from '../branding';\nimport type { JoinEntry, PColumn, PColumnSpec } from '../drivers';\nimport { assertNever } from '../util';\nimport type { ResultPoolEntry } from './entry';\n\n/** Any object exported into the result pool by the block always have spec attached to it */\nexport interface PObjectSpec {\n  /** PObject kind discriminator */\n  readonly kind: string;\n\n  /** Name is common part of PObject identity */\n  readonly name: string;\n\n  /** Domain is a set of key-value pairs that can be used to identify the object */\n  readonly domain?: Record<string, string>;\n\n  /** Additional information attached to the object */\n  readonly annotations?: Record<string, string>;\n}\n\n/** Stable PObject id */\nexport type PObjectId = Branded<string, 'PColumnId'>;\n\n/**\n * Full PObject representation.\n *\n * @template Data type of the object referencing or describing the \"data\" part of the PObject\n * */\nexport interface PObject<Data> {\n  /** Fully rendered PObjects are assigned a stable identifier. */\n  readonly id: PObjectId;\n\n  /** PObject spec, allowing it to be found among other PObjects */\n  readonly spec: PObjectSpec;\n\n  /** A handle to data object */\n  readonly data: Data;\n}\n\nexport function isPColumnSpec(spec: PObjectSpec): spec is PColumnSpec {\n  return spec.kind === 'PColumn';\n}\n\nexport function isPColumn<T>(obj: PObject<T>): obj is PColumn<T> {\n  return isPColumnSpec(obj.spec);\n}\n\nexport function isPColumnSpecResult(\n  r: ResultPoolEntry<PObjectSpec>,\n): r is ResultPoolEntry<PColumnSpec> {\n  return isPColumnSpec(r.obj);\n}\n\nexport function isPColumnResult<T>(\n  r: ResultPoolEntry<PObject<T>>,\n): r is ResultPoolEntry<PColumn<T>> {\n  return isPColumnSpec(r.obj.spec);\n}\n\nexport function ensurePColumn<T>(obj: PObject<T>): PColumn<T> {\n  if (!isPColumn(obj)) throw new Error(`not a PColumn (kind = ${obj.spec.kind})`);\n  return obj;\n}\n\nexport function mapPObjectData<D1, D2>(pObj: PColumn<D1>, cb: (d: D1) => D2): PColumn<D2>;\nexport function mapPObjectData<D1, D2>(\n  pObj: PColumn<D1> | undefined,\n  cb: (d: D1) => D2\n): PColumn<D2> | undefined;\nexport function mapPObjectData<D1, D2>(pObj: PObject<D1>, cb: (d: D1) => D2): PObject<D2>;\nexport function mapPObjectData<D1, D2>(\n  pObj: PObject<D1> | undefined,\n  cb: (d: D1) => D2\n): PObject<D2> | undefined;\nexport function mapPObjectData<D1, D2>(\n  pObj: PObject<D1> | undefined,\n  cb: (d: D1) => D2,\n): PObject<D2> | undefined {\n  return pObj === undefined\n    ? undefined\n    : {\n        ...pObj,\n        data: cb(pObj.data),\n      };\n}\n\nexport function extractAllColumns<D>(entry: JoinEntry<PColumn<D>>): PColumn<D>[] {\n  const columns = new Map<PObjectId, PColumn<D>>();\n  const addAllColumns = (entry: JoinEntry<PColumn<D>>) => {\n    switch (entry.type) {\n      case 'column':\n        columns.set(entry.column.id, entry.column);\n        return;\n      case 'slicedColumn':\n        columns.set(entry.column.id, entry.column);\n        return;\n      case 'inlineColumn':\n        return;\n      case 'full':\n      case 'inner':\n        for (const e of entry.entries) addAllColumns(e);\n        return;\n      case 'outer':\n        addAllColumns(entry.primary);\n        for (const e of entry.secondary) addAllColumns(e);\n        return;\n      default:\n        assertNever(entry);\n    }\n  };\n  addAllColumns(entry);\n  return [...columns.values()];\n}\n","import { isPColumnSpec, type PObjectSpec } from '../../../pool';\nimport type { AxisId, PColumnSpec, ValueType } from './spec';\nimport { getAxisId } from './spec';\n\n/**\n * Defines a pattern for matching axes within the PFrame data model.\n *\n * AxisSelector provides a flexible way to identify axes based on their\n * properties. All fields are optional, allowing for partial matching.\n * When multiple properties are specified, all must match for an axis\n * to be selected (logical AND).\n *\n * This interface is used in various selection and matching operations\n * throughout the PFrame system, such as column queries and axis lookups.\n */\nexport interface AxisSelector {\n  /**\n   * Optional value type to match against.\n   * When specified, only axes with this exact type will match.\n   * Can be a single type or an array of types to match against any of them.\n   * Valid types include: 'Int', 'Long', 'Float', 'Double', 'String', 'Bytes'.\n   */\n  type?: ValueType | ValueType[];\n\n  /**\n   * Optional name to match against.\n   * When specified, only axes with this exact name will match.\n   */\n  name?: string;\n\n  /**\n   * Optional domain key-value pairs to match against.\n   * Domains provide additional context to uniquely identify an axis beyond its name and type.\n   * When specified, an axis will match only if it contains all the key-value pairs defined here.\n   * An axis with additional domain entries not present in this selector will still match.\n   */\n  domain?: Record<string, string>;\n}\n\n/**\n * Reference to an axis by its numerical index within the anchor column's axes array\n * Format: [anchorId, axisIndex]\n */\nexport type AnchorAxisRefByIdx = { anchor: string; idx: number };\n\n/**\n * Reference to an axis by its name within the anchor column\n * Format: [anchorId, axisName]\n */\nexport type AnchorAxisRefByName = { anchor: string; name: string };\n\n/**\n * Reference to an axis using an AxisId matcher within the anchor\n * Format: [anchorId, axisMatcher]\n */\nexport type AnchorAxisRefByMatcher = { anchor: string; id: AxisId };\n\n/**\n * Basic anchor axis reference that can be either by index or a direct AxisId\n */\nexport type AnchorAxisIdOrRefBasic = AnchorAxisRefByIdx | AxisId;\n\n/** Union of all possible ways to reference an axis in an anchored context  */\nexport type AnchorAxisRef = AnchorAxisRefByIdx | AnchorAxisRefByName | AnchorAxisRefByMatcher;\n\n/** Reference to a domain value through an anchor */\nexport type AnchorDomainRef = { anchor: string };\n\n/**\n * Domain value that can be either a direct string value or a reference to a domain through an anchor\n * Used to establish domain context that can be resolved relative to other anchored columns\n */\nexport type ADomain = string | AnchorDomainRef;\n/**\n * Axis identifier that can be either a direct AxisId or a reference to an axis through an anchor\n * Allows referring to axes in a way that can be resolved in different contexts\n */\nexport type AAxisSelector = AxisSelector | AnchorAxisRef;\n\n/**\n * Match resolution strategy for PColumns\n * Specifies how to handle when multiple columns match the criteria\n * (default is \"expectSingle\")\n */\nexport type AnchoredColumnMatchStrategy = 'expectSingle' | 'expectMultiple' | 'takeFirst';\n\n/**\n * Matcher for PColumns in an anchored context\n * Supports partial matching on axes, allowing for flexible column discovery\n */\nexport interface AnchoredPColumnSelector {\n  /** Optional name of the column to match; can't be used together with namePattern */\n  name?: string;\n  /** Optional regexp pattern for column name matching; can't be used together with name */\n  namePattern?: string;\n  /** Optional value type to match. If an array is provided, matches if the column's type is any of the specified types */\n  type?: ValueType | ValueType[];\n  /** If specified, the domain values must be anchored to this anchor */\n  domainAnchor?: string;\n  /** Optional domain values to match, can include anchored references, if domainAnchor is specified,\n   * interpreted as additional domains to domain from the anchor */\n  domain?: Record<string, ADomain>;\n  /** Optional axes to match, can include anchored references */\n  axes?: AAxisSelector[];\n  /** When true, allows matching if only a subset of axes match */\n  partialAxesMatch?: boolean;\n  /** Optional annotations to match with exact values */\n  annotations?: Record<string, string>;\n  /** Optional annotation patterns to match with regex patterns */\n  annotationPatterns?: Record<string, string>;\n  /** Match resolution strategy, default is \"expectSingle\" */\n  matchStrategy?: AnchoredColumnMatchStrategy;\n}\n\n/**\n * Matcher for PColumns in a non-anchored context\n */\nexport interface PColumnSelector extends AnchoredPColumnSelector {\n  domainAnchor?: never;\n  domain?: Record<string, string>;\n  axes?: AxisSelector[];\n}\n\n/**\n * Strict identifier for PColumns in an anchored context\n * Unlike APColumnMatcher, this requires exact matches on domain and axes\n */\nexport interface AnchoredPColumnId extends AnchoredPColumnSelector {\n  /** Name is required for exact column identification */\n  name: string;\n  /** No namePattern in ID */\n  namePattern?: never;\n  /** Type is not used in exact column identification */\n  type?: never;\n  /** Full axes specification using only basic references */\n  axes: AnchorAxisIdOrRefBasic[];\n  /** Partial axes matching is not allowed for exact identification */\n  partialAxesMatch?: never;\n  /** Annotations are not used in exact column identification */\n  annotations?: never;\n  /** Annotation patterns are not used in exact column identification */\n  annotationPatterns?: never;\n  /** \"Id\" implies single match strategy */\n  matchStrategy?: never;\n}\n\n/**\n * Determines if an axis ID matches an axis selector.\n *\n * @param selector - The selector with criteria to match against\n * @param axis - The AxisId to check against the selector\n * @returns true if the AxisId matches all specified criteria in the selector, false otherwise\n */\nexport function matchAxis(selector: AxisSelector, axis: AxisId): boolean {\n  // Match name if specified\n  if (selector.name !== undefined && selector.name !== axis.name)\n    return false;\n\n  // Match type if specified\n  if (selector.type !== undefined) {\n    if (Array.isArray(selector.type)) {\n      if (!selector.type.includes(axis.type))\n        return false;\n    } else if (selector.type !== axis.type) {\n      return false;\n    }\n  }\n\n  // Match domain if specified - using existing logic from matchAxisId\n  if (selector.domain !== undefined) {\n    const axisDomain = axis.domain || {};\n    for (const [key, value] of Object.entries(selector.domain))\n      if (axisDomain[key] !== value)\n        return false;\n  }\n\n  return true;\n}\n\n/**\n * Determines if a given PColumnSpec matches a selector.\n *\n * @param pcolumn - The PColumnSpec to check against the selector\n * @param selector - The selector criteria to match against\n * @returns true if the PColumnSpec matches all criteria in the selector, false otherwise\n */\nexport function matchPColumn(pcolumn: PColumnSpec, selector: PColumnSelector): boolean {\n  // Match name if specified\n  if (selector.name !== undefined && pcolumn.name !== selector.name)\n    return false;\n\n  // Match name pattern if specified\n  if (selector.namePattern !== undefined && !new RegExp(selector.namePattern).test(pcolumn.name))\n    return false;\n\n  // Match type if specified\n  if (selector.type !== undefined) {\n    if (Array.isArray(selector.type)) {\n      if (!selector.type.includes(pcolumn.valueType))\n        return false;\n    } else if (selector.type !== pcolumn.valueType) {\n      return false;\n    }\n  }\n\n  // Match domain if specified\n  if (selector.domain !== undefined) {\n    const columnDomain = pcolumn.domain || {};\n    for (const [key, value] of Object.entries(selector.domain))\n      if (columnDomain[key] !== value)\n        return false;\n  }\n\n  // Match axes if specified\n  if (selector.axes !== undefined) {\n    const pcolumnAxes = pcolumn.axesSpec.map(getAxisId);\n\n    if (selector.partialAxesMatch) {\n      // For partial matching, all selector axes must match at least one column axis\n      for (const selectorAxis of selector.axes)\n        if (!pcolumnAxes.some((columnAxis) => matchAxis(selectorAxis, columnAxis)))\n          return false;\n    } else {\n      // For exact matching, column must have the same number of axes and all must match\n      if (pcolumnAxes.length !== selector.axes.length)\n        return false;\n\n      // Each selector axis must match a corresponding column axis\n      for (let i = 0; i < selector.axes.length; i++)\n        if (!matchAxis(selector.axes[i], pcolumnAxes[i]))\n          return false;\n    }\n  }\n\n  // Match annotations if specified\n  if (selector.annotations !== undefined) {\n    const columnAnnotations = pcolumn.annotations || {};\n    for (const [key, value] of Object.entries(selector.annotations))\n      if (columnAnnotations[key] !== value)\n        return false;\n  }\n\n  // Match annotation patterns if specified\n  if (selector.annotationPatterns !== undefined) {\n    const columnAnnotations = pcolumn.annotations || {};\n    for (const [key, pattern] of Object.entries(selector.annotationPatterns)) {\n      const value = columnAnnotations[key];\n      if (value === undefined || !new RegExp(pattern).test(value))\n        return false;\n    }\n  }\n\n  return true;\n}\n\n/**\n * Convert a predicate or array of selectors to a single predicate function\n * @param predicateOrSelectors - Either a function that takes a PColumnSpec and returns a boolean,\n *                              or an array of PColumnSelectors, or a single PColumnSelector\n * @returns A function that takes a PColumnSpec and returns a boolean\n */\nexport function selectorsToPredicate(predicateOrSelectors: PColumnSelector | PColumnSelector[]): ((spec: PObjectSpec) => boolean) {\n  if (Array.isArray(predicateOrSelectors))\n    return (spec) => predicateOrSelectors.some((selector) => isPColumnSpec(spec) && matchPColumn(spec, selector));\n  else\n    return (spec) => isPColumnSpec(spec) && matchPColumn(spec, predicateOrSelectors);\n}\n","import type { Branded } from '../../../branding';\nimport { isPColumnSpec, type PObjectSpec } from '../../../pool';\nimport { getAxesId } from './spec';\nimport canonicalize from 'canonicalize';\nexport type NativePObjectId = Branded<string, 'NativePObjectId'>;\n\nexport function deriveNativeId(spec: PObjectSpec): NativePObjectId {\n  const result: Record<string, unknown> = {\n    kind: spec.kind,\n    name: spec.name,\n  };\n  if (spec.domain !== undefined)\n    result.domain = spec.domain;\n  if (isPColumnSpec(spec))\n    result.axesSpec = getAxesId(spec.axesSpec);\n  return canonicalize(result) as NativePObjectId;\n}\n","import { z } from 'zod';\n\nexport const PlRef = z\n  .object({\n    __isRef: z\n      .literal(true)\n      .describe('Crucial marker for the block dependency tree reconstruction'),\n    blockId: z.string()\n      .describe('Upstream block id'),\n    name: z.string()\n      .describe('Name of the output provided to the upstream block\\'s output context'),\n    requireEnrichments: z.literal(true).optional()\n      .describe('True if current block that stores this reference in its args, may need enrichments '\n        + 'for the references value originating from the blocks in between current and referenced block'),\n  })\n  .describe(\n    'Universal reference type, allowing to set block connections. It is crucial that '\n    + '{@link __isRef} is present and equal to true, internal logic relies on this marker '\n    + 'to build block dependency trees.',\n  )\n  .readonly();\nexport type PlRef = z.infer<typeof PlRef>;\n/** @deprecated use {@link PlRef} */\nexport type Ref = PlRef;\n\n/**\n * Type guard to check if a value is a PlRef.\n *\n * @param value - The value to check.\n * @returns True if the value is a PlRef, false otherwise.\n */\nexport function isPlRef(value: unknown): value is PlRef {\n  return (\n    typeof value === 'object'\n    && value !== null\n    && '__isRef' in value\n    && (value as { __isRef: unknown }).__isRef === true\n    && 'blockId' in value\n    && 'name' in value\n  );\n}\n\n/** Standard way how to communicate possible connections given specific\n * requirements for incoming data. */\nexport type Option = {\n  /** Fully rendered reference to be assigned for the intended field in block's\n   * args */\n  readonly ref: PlRef;\n\n  /** Label to be present for the user in i.e. drop-down list */\n  readonly label: string;\n};\n\n/**\n * Creates a PlRef with the given blockId and name.\n *\n * @param blockId - The blockId of the reference.\n * @param name - The name of the reference.\n * @param requireEnrichments - Whether the reference requires enrichments.\n */\nexport function createPlRef(blockId: string, name: string, requireEnrichments: boolean = false) {\n  if (requireEnrichments)\n    return {\n      __isRef: true,\n      blockId,\n      name,\n      requireEnrichments: true,\n    };\n  else\n    return {\n      __isRef: true,\n      blockId,\n      name,\n    };\n}\n\n/**\n * Creates a new PlRef based on an existing one, explicitly setting (default) or removing the\n * requireEnrichments property.\n *\n * @param ref - The original PlRef object.\n * @param requireEnrichments - If true, the `requireEnrichments: true` property is added\n *   to the returned PlRef. If false, the `requireEnrichments` property is removed. Defaults to true.\n * @returns A new PlRef object with the `requireEnrichments` property set or removed accordingly.\n */\nexport function withEnrichments(ref: PlRef, requireEnrichments: boolean = true): PlRef {\n  if (requireEnrichments)\n    return {\n      ...ref,\n      requireEnrichments: true,\n    };\n  else {\n    const { requireEnrichments: _, ...rest } = ref;\n    return rest;\n  }\n}\n\n/** Compare two PlRefs and returns true if they are qual */\nexport function plRefsEqual(ref1: PlRef, ref2: PlRef, ignoreEnrichments: boolean = false) {\n  return ref1.blockId === ref2.blockId && ref1.name === ref2.name && (ignoreEnrichments || ref1.requireEnrichments === ref2.requireEnrichments);\n}\n","export type ValueOrError<V, E> =\n  | {\n    ok: true;\n    value: V;\n  }\n  | {\n    ok: false;\n    error: E;\n  };\n\nexport function mapValueInVOE<V1, V2, E>(\n  voe: ValueOrError<V1, E>,\n  cb: (value: V1) => V2,\n): ValueOrError<V2, E> {\n  return voe.ok ? { ok: true, value: cb(voe.value) } : voe;\n}\n","import { z } from 'zod';\nimport { base32Encode } from './base32_encode';\n\n/** Number of raw bytes in the PlId. */\nexport const PlIdBytes = 15;\n/** Characters in string representation */\nexport const PlIdLength = 24; // = 15 bytes * 8 bits / 5 bits per char in base32\n\nexport const PlId = z\n  .string()\n  .length(PlIdLength)\n  .regex(/[ABCDEFGHIJKLMNOPQRSTUVWXYZ234567]/) // RFC4648\n  .brand('PlId');\nexport type PlId = z.infer<typeof PlId>;\n\nexport function uniquePlId(): PlId {\n  const data = new Uint8Array(PlIdBytes);\n  crypto.getRandomValues(data);\n  return PlId.parse(base32Encode(data, 'RFC4648'));\n}\n\nexport function plId(bytes: Uint8Array): PlId {\n  if (bytes.length !== PlIdBytes) throw new Error(`Wrong number of bytes: ${bytes.length}`);\n  return PlId.parse(base32Encode(bytes, 'RFC4648'));\n}\n\nexport async function digestPlId(data: string): Promise<PlId> {\n  const encoder = new TextEncoder();\n  const bytes = await crypto.subtle.digest('SHA-256', encoder.encode(data));\n  return plId(new Uint8Array(bytes.slice(0, 15)));\n}\n"],"names":["z","assertNever","x","uploadPrefix","indexPrefix","isImportFileHandleUpload","handle","isImportFileHandleIndex","getFilePathFromHandle","trimmed","extractFileName","filePath","getFileNameFromHandle","isDataInfo","value","data","mapDataInfo","dataInfo","mapFn","newParts","key","blob","chunk","isDataInfoEntries","isPartitionedDataInfoEntries","dataInfoToEntries","keyStr","entriesToDataInfo","dataInfoEntries","canonicalizeJson","canonicalize","parseJson","ValueType","readMetadata","metadata","Annotation","AxisSpec","readAnnotation","spec","PColumnName","getAxisId","type","name","domain","result","getAxesId","canonicalizeAxisId","id","matchDomain","query","target","k","matchAxisId","mapPTableDef","def","cb","mapJoinEntry","entry","col","stringifyColumnId","axisKey","axis","domainKey","AnchoredIdDeriver","anchors","__publicField","anchorEntries","a","b","anchorId","axisIdx","domainEntries","dKey","dValue","axisFilters","skipDomains","outer","domainPack","dAnchor","domainAnchor","anchorAxisRef","resolvedFilters","filter","axisIdOrIndex","axisIndex","resolveAnchors","matcher","options","ignoreMissingDomains","anchorSpec","anchorDomains","resolvedDomain","resolveAxisReference","axisRef","isAnchorAxisRef","matches","isPColumnSpec","isPColumn","obj","ensurePColumn","mapPObjectData","pObj","extractAllColumns","columns","addAllColumns","e","matchAxis","selector","axisDomain","matchPColumn","pcolumn","columnDomain","pcolumnAxes","selectorAxis","columnAxis","i","columnAnnotations","pattern","selectorsToPredicate","predicateOrSelectors","deriveNativeId","isPlRef","withEnrichments","ref","requireEnrichments","_","rest","mapValueInVOE","voe","PlIdLength"],"mappings":";;;AAyB0BA,EAAE,OAAO;AAAA;AAAA,EAEjC,MAAMA,EAAE,OAAO;AAAA;AAAA,EAEf,IAAIA,EAAE,OAAO;AACf,CAAC;AC9BM,SAASC,EAAYC,GAAiB;AACrC,QAAA,IAAI,MAAM,wBAAwBA,CAAC;AAC3C;ACGA,MAAMC,IAAe,oBACfC,IAAc;AASb,SAASC,EACdC,GACkC;AAC3BA,SAAAA,EAAO,WAAWH,CAAY;AACvC;AAEO,SAASI,EAAwBD,GAA2D;AAC1FA,SAAAA,EAAO,WAAWF,CAAW;AACtC;AA0GO,SAASI,EAAsBF,GAAkC;AAClEC,MAAAA,EAAwBD,CAAM,GAAG;AACnC,UAAMG,IAAUH,EAAO,MAAMF,EAAY,MAAM;AAE/C,WADa,KAAK,MAAM,mBAAmBK,CAAO,CAAC,EACvC;AAAA,EAAA,WACHJ,EAAyBC,CAAM,GAAG;AAC3C,UAAMG,IAAUH,EAAO,MAAMH,EAAa,MAAM;AAEhD,WADa,KAAK,MAAM,mBAAmBM,CAAO,CAAC,EACvC;AAAA,EAAA;AAGdR,EAAAA,EAAYK,CAAM;AACpB;AAEA,SAASI,EAAgBC,GAAkB;AAClCA,SAAAA,EAAS,QAAQ,YAAY,EAAE;AACxC;AAGO,SAASC,EAAsBN,GAAkC;AAC/DI,SAAAA,EAAgBF,EAAsBF,CAAM,CAAC;AACtD;ACiBO,SAASO,EAAiBC,GAAyC;AACpE,MAAA,CAACA,KAAS,OAAOA,KAAU;AACtB,WAAA;AAGT,QAAMC,IAAOD;AACT,MAAA,EAAE,UAAUC;AACP,WAAA;AAGT,UAAQA,EAAK,MAAM;AAAA,IACjB,KAAK;AAED,aAAA,OAAOA,EAAK,aAAc,YACvBA,EAAK,SAAS,UACd,OAAOA,EAAK,QAAS;AAAA,IAE5B,KAAK;AAAA,IACL,KAAK;AAAA,IACL,KAAK;AAED,aAAA,OAAOA,EAAK,sBAAuB,YAChCA,EAAK,UAAU,UACf,OAAOA,EAAK,SAAU;AAAA,IAE7B;AACS,aAAA;AAAA,EAAA;AAEb;AAuBgB,SAAAC,EACdC,GACAC,GAC0B;AAC1B,MAAID,MAAa;AAIjB,YAAQA,EAAS,MAAM;AAAA,MACrB,KAAK;AAEIA,eAAAA;AAAAA,MACT,KAAK,mBAAmB;AAEtB,cAAME,IAA+B,CAAC;AAC3B,mBAAA,CAACC,GAAKC,CAAI,KAAK,OAAO,QAAQJ,EAAS,KAAK;AAC5CE,UAAAA,EAAAC,CAAG,IAAIF,EAAMG,CAAI;AAErB,eAAA;AAAA,UACL,GAAGJ;AAAAA,UACH,OAAOE;AAAAA,QACT;AAAA,MAAA;AAAA,MAEF,KAAK,qBAAqB;AAExB,cAAMA,IAA4C,CAAC;AACxC,mBAAA,CAACC,GAAKE,CAAK,KAAK,OAAO,QAAQL,EAAS,KAAK;AACtDE,UAAAA,EAASC,CAAG,IAAI;AAAA,YACd,OAAOF,EAAMI,EAAM,KAAK;AAAA,YACxB,QAAQJ,EAAMI,EAAM,MAAM;AAAA,UAC5B;AAEK,eAAA;AAAA,UACL,GAAGL;AAAAA,UACH,OAAOE;AAAAA,QACT;AAAA,MAAA;AAAA,MAEF,KAAK,sBAAsB;AAEzB,cAAMA,IAA+B,CAAC;AAC3B,mBAAA,CAACC,GAAKC,CAAI,KAAK,OAAO,QAAQJ,EAAS,KAAK;AAC5CE,UAAAA,EAAAC,CAAG,IAAIF,EAAMG,CAAI;AAErB,eAAA;AAAA,UACL,GAAGJ;AAAAA,UACH,OAAOE;AAAAA,QACT;AAAA,MAAA;AAAA,IAAA;AAGN;AA+GO,SAASI,EAAwBT,GAAgD;AAClF,MAAA,CAACA,KAAS,OAAOA,KAAU;AACtB,WAAA;AAGT,QAAMC,IAAOD;AACT,MAAA,EAAE,UAAUC;AACP,WAAA;AAGT,UAAQA,EAAK,MAAM;AAAA,IACjB,KAAK;AACH,aACE,OAAOA,EAAK,aAAc,YACvB,MAAM,QAAQA,EAAK,IAAI;AAAA,IAE9B,KAAK;AAAA,IACL,KAAK;AAAA,IACL,KAAK;AACH,aACE,OAAOA,EAAK,sBAAuB,YAChC,MAAM,QAAQA,EAAK,KAAK;AAAA,IAE/B;AACS,aAAA;AAAA,EAAA;AAEb;AASO,SAASS,EAAmCV,GAA2D;AAC5G,MAAI,CAACS,EAAkBT,CAAK,EAAU,QAAA;AACtC,UAAQA,EAAM,MAAM;AAAA,IAClB,KAAK;AAAA,IACL,KAAK;AAAA,IACL,KAAK;AACI,aAAA;AAAA,IACT;AACS,aAAA;AAAA,EAAA;AAEb;AAQO,SAASW,EAAwBR,GAAiD;AACvF,UAAQA,EAAS,MAAM;AAAA,IACrB,KAAK;AAAe,aAAA;AAAA,QAClB,MAAM;AAAA,QACN,WAAWA,EAAS;AAAA,QACpB,MAAM,OAAO,QAAQA,EAAS,IAAI,EAAE,IAAI,CAAC,CAACS,GAAQZ,CAAK,OAE9C,EAAE,KADG,KAAK,MAAMY,CAAM,GACf,OAAAZ,IACf;AAAA,MACH;AAAA,IACA,KAAK;AAA0B,aAAA;AAAA,QAC7B,MAAM;AAAA,QACN,oBAAoBG,EAAS;AAAA,QAC7B,OAAO,OAAO,QAAQA,EAAS,KAAK,EAAE,IAAI,CAAC,CAACS,GAAQL,CAAI,OAE/C,EAAE,KADG,KAAK,MAAMK,CAAM,GACf,OAAOL,IACtB;AAAA,MACH;AAAA,IACA,KAAK;AAA4B,aAAA;AAAA,QAC/B,MAAM;AAAA,QACN,oBAAoBJ,EAAS;AAAA,QAC7B,OAAO,OAAO,QAAQA,EAAS,KAAK,EAAE,IAAI,CAAC,CAACS,GAAQJ,CAAK,OAEhD,EAAE,KADG,KAAK,MAAMI,CAAM,GACf,OAAOJ,IACtB;AAAA,MACH;AAAA,IACA,KAAK;AAA6B,aAAA;AAAA,QAChC,MAAM;AAAA,QACN,oBAAoBL,EAAS;AAAA,QAC7B,OAAO,OAAO,QAAQA,EAAS,KAAK,EAAE,IAAI,CAAC,CAACS,GAAQL,CAAI,OAE/C,EAAE,KADG,KAAK,MAAMK,CAAM,GACf,OAAOL,IACtB;AAAA,MACH;AAAA,IACA;AACEpB,MAAAA,EAAYgB,CAAQ;AAAA,EAAA;AAE1B;AAQO,SAASU,EAAwBC,GAAwD;AAC9F,UAAQA,EAAgB,MAAM;AAAA,IAC5B,KAAK;AAAe,aAAA;AAAA,QAClB,MAAM;AAAA,QACN,WAAWA,EAAgB;AAAA,QAC3B,MAAM,OAAO;AAAA,UACXA,EAAgB,KAAK,IAAI,CAAC,EAAE,KAAAR,GAAK,OAAAN,EAAAA,MAAY,CAAC,KAAK,UAAUM,CAAG,GAAGN,CAAK,CAAC;AAAA,QAAA;AAAA,MAE7E;AAAA,IACA,KAAK;AAA0B,aAAA;AAAA,QAC7B,MAAM;AAAA,QACN,oBAAoBc,EAAgB;AAAA,QACpC,OAAO,OAAO;AAAA,UACZA,EAAgB,MAAM,IAAI,CAAC,EAAE,KAAAR,GAAK,OAAAN,EAAAA,MAAY,CAAC,KAAK,UAAUM,CAAG,GAAGN,CAAK,CAAC;AAAA,QAAA;AAAA,MAE9E;AAAA,IACA,KAAK;AAA4B,aAAA;AAAA,QAC/B,MAAM;AAAA,QACN,oBAAoBc,EAAgB;AAAA,QACpC,OAAO,OAAO;AAAA,UACZA,EAAgB,MAAM,IAAI,CAAC,EAAE,KAAAR,GAAK,OAAAN,EAAAA,MAAY,CAAC,KAAK,UAAUM,CAAG,GAAGN,CAAK,CAAC;AAAA,QAAA;AAAA,MAE9E;AAAA,IACA,KAAK;AAA6B,aAAA;AAAA,QAChC,MAAM;AAAA,QACN,oBAAoBc,EAAgB;AAAA,QACpC,OAAO,OAAO;AAAA,UACZA,EAAgB,MAAM,IAAI,CAAC,EAAE,KAAAR,GAAK,OAAAN,EAAAA,MAAY,CAAC,KAAK,UAAUM,CAAG,GAAGN,CAAK,CAAC;AAAA,QAAA;AAAA,MAE9E;AAAA,IACA;AACEb,MAAAA,EAAY2B,CAAe;AAAA,EAAA;AAEjC;AC/dO,SAASC,EAAoBf,GAAgD;AAClF,SAAOgB,EAAahB,CAAK;AAC3B;AAEO,SAASiB,EAAajB,GAAqD;AACzE,SAAA,KAAK,MAAMA,CAAK;AACzB;ACnBO,MAAMkB,IAAY;AAAA,EACvB,KAAK;AAAA,EACL,MAAM;AAAA,EACN,OAAO;AAAA,EACP,QAAQ;AAAA,EACR,QAAQ;AAAA,EACR,OAAO;AACT;AAOgB,SAAAC,EACdC,GACAd,GACkB;AACVc,SAAAA,KAAA,gBAAAA,EAA6Bd,CAAAA;AACvC;AAiFO,MAAMe,IAAa;AAAA,EAExB,gBAAgB;AAAA,EAEhB,OAAO;AAAA,IACL,WAAW;AAAA,EACb;AAAA,EACA,gBAAgB;AAAA,EAChB,gBAAgB;AAAA,EAChB,OAAO;AAAA,EACP,KAAK;AAAA,EACL,KAAK;AAAA,EACL,SAAS;AAAA,EACT,UAAU;AAAA,IACR,YAAY;AAAA,MACV,SAAS;AAAA,IACX;AAAA,IACA,cAAc;AAAA,EAChB;AAAA,EACA,OAAO;AAAA,IAEL,eAAe;AAAA,EAEjB;AAAA,EACA,OAAO;AACT,GAqBaC,IAAWpC,EAAE,OAAO;AAAA,EAC/B,MAAMA,EAAE,WAAWgC,CAAS;AAAA,EAC5B,MAAMhC,EAAE,OAAO;AAAA,EACf,QAAQA,EAAE,OAAOA,EAAE,UAAUA,EAAE,QAAQ,EAAE,SAAS;AAAA,EAClD,aAAaA,EAAE,OAAOA,EAAE,UAAUA,EAAE,QAAQ,EAAE,SAAS;AAAA,EACvD,YAAYA,EAAE,MAAMA,EAAE,OAAO,CAAC,EAAE,SAAS;AAC3C,CAAC,EAAE,YAAY;AAQZmC,EAAW,iBAAXA,IAA4BnC,EAAE,MAAMA,EAAE,OAAA,CAAQ,EAAE,GAAGA,EAAE,MAAMA,EAAE,OAAQ,CAAA,CAAC,GACtEmC,EAAW,MAAM,YAAjBA,IAA6BnC,EAAE,QAAQ,GACvCmC,EAAW,iBAAXA,IAA4BnC,EAAE,QAAQ,GACtCmC,EAAW,iBAAXA,IAA4BnC,EAAE,QAAQ,GACtCmC,EAAW,MAAXA,IAAiBnC,EAAE,OAAO,GAC1BmC,EAAW,MAAXA,IAAiBnC,EAAE,OAAO,GAC1BmC,EAAW,UAAXA,IAAqBnC,EAAE,MAAMoC,CAAQ,GACrCD,EAAW,SAAS,WAAW,UAA/BA,IAAyCnC,EAAE,OAAOA,EAAE,OAAA,GAAUA,EAAE,OAAQ,CAAA,GACxEmC,EAAW,SAAS,eAApBA,IAAmCnC,EAAE,QAAQ,GAC7CmC,EAAW,MAAM,gBAAjBA,IAAiCnC,EAAE,OAAO,GAC1CmC,EAAW,QAAXA,IAAmBnC,EAAE,OAAOA,EAAE,OAAO,GAAGA,EAAE,QAAS,CAAA;AAItC,SAAAqC,EACdC,GACAlB,GAC2B;AACpB,SAAAa,EAA4BK,KAAA,OAAAA,SAAAA,EAAM,aAAalB,CAAG;AAC3D;AAwPO,MAAMmB,KAAc;AAAA,EACzB,OAAO;AAIT;AAuIO,SAASC,EAAUF,GAAwB;AAChD,QAAM,EAAE,MAAAG,GAAM,MAAAC,GAAM,QAAAC,EAAWL,IAAAA,GACzBM,IAAS,EAAE,MAAAH,GAAM,MAAAC,EAAK;AAC5B,SAAIC,KAAU,OAAO,QAAQA,CAAM,EAAE,SAAS,KAC5C,OAAO,OAAOC,GAAQ,EAAE,QAAAD,EAAAA,CAAQ,GAE3BC;AACT;AAGO,SAASC,EAAUP,GAAwB;AACzCA,SAAAA,EAAK,IAAIE,CAAS;AAC3B;AAGO,SAASM,GAAmBC,GAAuC;AACjElB,SAAAA,EAAiBW,EAAUO,CAAE,CAAC;AACvC;AAGA,SAASC,EAAYC,GAAgCC,GAAiC;AAChFD,MAAAA,MAAU,OAAW,QAAOC,MAAW;AACvCA,MAAAA,MAAW,OAAkB,QAAA;AACjC,aAAWC,KAAKD;AACd,QAAID,EAAME,CAAC,MAAMD,EAAOC,CAAC,EAAU,QAAA;AAE9B,SAAA;AACT;AAGgB,SAAAC,EAAYH,GAAeC,GAAyB;AAC3DD,SAAAA,EAAM,SAASC,EAAO,QAAQF,EAAYC,EAAM,QAAQC,EAAO,MAAM;AAC9E;ACjPgB,SAAAG,GACdC,GACAC,GACe;AACR,SAAA,EAAE,GAAGD,GAAK,KAAKE,EAAaF,EAAI,KAAKC,CAAE,EAAE;AAClD;AAEgB,SAAAC,EACdC,GACAF,GACe;AACf,UAAQE,EAAM,MAAM;AAAA,IAClB,KAAK;AACI,aAAA;AAAA,QACL,MAAM;AAAA,QACN,QAAQF,EAAGE,EAAM,MAAM;AAAA,MACzB;AAAA,IACF,KAAK;AACI,aAAA;AAAA,QACL,MAAM;AAAA,QACN,QAAQF,EAAGE,EAAM,MAAM;AAAA,QACvB,OAAOA,EAAM;AAAA,QACb,aAAaA,EAAM;AAAA,MACrB;AAAA,IACF,KAAK;AACIA,aAAAA;AAAAA,IACT,KAAK;AAAA,IACL,KAAK;AACI,aAAA;AAAA,QACL,MAAMA,EAAM;AAAA,QACZ,SAASA,EAAM,QAAQ,IAAI,CAACC,MAAQF,EAAaE,GAAKH,CAAE,CAAC;AAAA,MAC3D;AAAA,IACF,KAAK;AACI,aAAA;AAAA,QACL,MAAM;AAAA,QACN,SAASC,EAAaC,EAAM,SAASF,CAAE;AAAA,QACvC,WAAWE,EAAM,UAAU,IAAI,CAACC,MAAQF,EAAaE,GAAKH,CAAE,CAAC;AAAA,MAC/D;AAAA,IACF;AACEtD,MAAAA,EAAYwD,CAAK;AAAA,EAAA;AAEvB;AC5YO,SAASE,EAAkBZ,GAA6C;AAC7E,SAAOjB,EAAaiB,CAAE;AACxB;ACVA,SAASa,EAAQC,GAAsB;AAC9B/B,SAAAA,EAAaU,EAAUqB,CAAI,CAAC;AACrC;AAEA,SAASC,EAAU1C,GAAaN,GAAuB;AACrD,SAAO,KAAK,UAAU,CAACM,GAAKN,CAAK,CAAC;AACpC;AAMO,MAAMiD,GAAkB;AAAA;AAAA;AAAA;AAAA;AAAA,EAiB7B,YAA4BC,GAAsC;AAhBjDC,IAAAA,EAAA,qCAAc,IAAoB,CAAA,GAClCA,EAAA,kCAAW,IAAgC,CAAA,GAK3CA,EAAA,qBAA0B,EAAC,GAI3BA,EAAA,gDAAyB,IAAoB,CAAA,GAMlC,KAAA,UAAAD;AACpBE,UAAAA,IAAgB,OAAO,QAAQF,CAAO;AAC9BE,IAAAA,EAAA,KAAK,CAACC,GAAGC,MAAMD,EAAE,CAAC,EAAE,cAAcC,EAAE,CAAC,CAAC,CAAC;AACrD,eAAW,CAACC,GAAU/B,CAAI,KAAK4B,GAAe;AAC5C,eAASI,IAAU,GAAGA,IAAUhC,EAAK,SAAS,QAAQgC,KAAW;AACzD,cAAAT,IAAOvB,EAAK,SAASgC,CAAO,GAC5BlD,IAAMwC,EAAQC,CAAI;AACnB,aAAA,KAAK,IAAIzC,GAAK,EAAE,QAAQiD,GAAU,KAAKC,GAAS;AAAA,MAAA;AAEnDhC,UAAAA,EAAK,WAAW,QAAW;AAC7B,cAAMiC,IAAgB,OAAO,QAAQjC,EAAK,MAAM;AAClCiC,UAAA,KAAK,CAACJ,GAAGC,MAAMD,EAAE,CAAC,EAAE,cAAcC,EAAE,CAAC,CAAC,CAAC,GAErD,KAAK,mBAAmB,IAAI,KAAK,UAAUG,CAAa,GAAGF,CAAQ,GAC9D,KAAA,YAAY,KAAKE,EAAc,IAAI,CAAC,CAACC,CAAI,MAAMA,CAAI,CAAC;AAEzD,mBAAW,CAACA,GAAMC,CAAM,KAAKF,GAAe;AACpCnD,gBAAAA,IAAM0C,EAAUU,GAAMC,CAAM;AAC7B,eAAA,QAAQ,IAAIrD,GAAKiD,CAAQ;AAAA,QAAA;AAAA,MAAA;AAAA,IAChC;AAAA,EACF;AAAA;AAAA;AAAA;AAAA,EAsBJ,OAAO/B,GAAmBoC,GAAgD;AACxE,UAAM9B,IAA4B;AAAA,MAChC,MAAMN,EAAK;AAAA,MACX,MAAM,CAAA;AAAA,IACR;AAEIqC,QAAAA;AACA,QAAArC,EAAK,WAAW;AAClBsC;AACWC,mBAAAA,KAAc,KAAK,aAAa;AACzC,gBAAMC,IAAsB,CAAC;AAC7B,qBAAWhB,KAAae,GAAY;AAC5BJ,kBAAAA,IAASnC,EAAK,OAAOwB,CAAS;AACpC,gBAAIW,MAAW;AACbK,cAAAA,EAAQ,KAAK,CAAChB,GAAWW,CAAM,CAAC;AAAA;AAE1BG,oBAAAA;AAAAA,UAAA;AAEV,gBAAMG,IAAe,KAAK,mBAAmB,IAAI,KAAK,UAAUD,CAAO,CAAC;AACxE,cAAIC,MAAiB,QAAW;AAC9BnC,cAAO,eAAemC,GACRJ,IAAA,IAAI,IAAIE,CAAU;AAChC;AAAA,UAAA;AAAA,QAAA;AAKK,eAAA,CAACL,GAAMC,CAAM,KAAK,OAAO,QAAQnC,EAAK,UAAU,CAAA,CAAE,GAAG;AAC9D,UAAIqC,MAAgB,UAAaA,EAAY,IAAIH,CAAI;AACnD;AACIpD,YAAAA,IAAM0C,EAAUU,GAAMC,CAAM,GAC5BJ,IAAW,KAAK,QAAQ,IAAIjD,CAAG;AACrCwB,QAAO,WAAPA,EAAO,SAAW,CAAA,IAClBA,EAAO,OAAO4B,CAAI,IAAIH,IAAW,EAAE,QAAQA,EAAaI,IAAAA;AAAAA,IAAA;AAW1D,QARA7B,EAAO,OAAON,EAAK,SAAS,IAAI,CAACuB,MAAS;AAClCzC,YAAAA,IAAMwC,EAAQC,CAAI,GAClBmB,IAAgB,KAAK,KAAK,IAAI5D,CAAG;AACvC,aAAI4D,MAAkB,SAAkBxC,EAAUqB,CAAI,IAC1CmB;AAAAA,IACb,CAAA,GAGG,CAACN,KAAeA,EAAY,WAAW;AAClC9B,aAAAA;AAIT,UAAMqC,IAA+C,CAAC;AAEtD,eAAWC,KAAUR,GAAa;AAC1B,YAAA,CAACS,GAAerE,CAAK,IAAIoE;AAG3B,UAAA,OAAOC,KAAkB,UAAU;AACrC,YAAIA,IAAgB,KAAKA,KAAiB7C,EAAK,SAAS;AAChD,gBAAA,IAAI,MAAM,cAAc6C,CAAa,wBAAwB7C,EAAK,SAAS,SAAS,CAAC,GAAG;AAEhG2C,UAAgB,KAAK,CAACE,GAAerE,CAAK,CAAC;AAAA,MAAA,OACtC;AAECsE,cAAAA,IAAY9C,EAAK,SAAS,UAAU,CAACuB,MAASA,EAAK,SAASsB,CAAa;AAC/E,YAAIC,MAAc;AAChB,gBAAM,IAAI,MAAM,mBAAmBD,CAAa,yCAAyC;AAE3FF,UAAgB,KAAK,CAACG,GAAWtE,CAAK,CAAC;AAAA,MAAA;AAAA,IAAA;AAK3BmE,WAAAA,EAAA,KAAK,CAACd,GAAGC,MAAMD,EAAE,CAAC,IAAIC,EAAE,CAAC,CAAC,GAEnC;AAAA,MACL,QAAQxB;AAAAA,MACR,aAAaqC;AAAAA,IACf;AAAA,EAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EASF,QAAQ3C,GAAmBoC,GAAiD;AAC1E,WAAOf,EAAkB,KAAK,OAAOrB,GAAMoC,CAAW,CAAC;AAAA,EAAA;AAE3D;AAsBgB,SAAAW,GAAerB,GAAsCsB,GAAkCC,GAAkD;AACjJ3C,QAAAA,IAAS,EAAE,GAAG0C,EAAAA,GACdE,KAAuBD,KAAA,OAAAA,SAAAA,EAAS,yBAAwB;AAE1D3C,MAAAA,EAAO,iBAAiB,QAAW;AAC/B6C,UAAAA,IAAazB,EAAQpB,EAAO,YAAY;AAC9C,QAAI,CAAC6C;AACH,YAAM,IAAI,MAAM,WAAW7C,EAAO,YAAY,aAAa;AAEvD8C,UAAAA,IAAgBD,EAAW,UAAU,CAAC;AAC5C7C,MAAO,SAAS,EAAE,GAAG8C,GAAe,GAAG9C,EAAO,OAAA,GAC9C,OAAOA,EAAO;AAAA,EAAA;AAGhB,MAAIA,EAAO,QAAQ;AACjB,UAAM+C,IAAyC,CAAC;AACrC,eAAA,CAACvE,GAAKN,CAAK,KAAK,OAAO,QAAQ8B,EAAO,MAAM;AACjD,UAAA,OAAO9B,KAAU;AACnB6E,UAAevE,CAAG,IAAIN;AAAAA,WACjB;AAEC2E,cAAAA,IAAazB,EAAQlD,EAAM,MAAM;AACvC,YAAI,CAAC2E;AACH,gBAAM,IAAI,MAAM,WAAW3E,EAAM,MAAM,+BAA+BM,CAAG,GAAG;AAE9E,YAAI,CAACqE,EAAW,UAAUA,EAAW,OAAOrE,CAAG,MAAM,QAAW;AAC9D,cAAI,CAACoE;AACH,kBAAM,IAAI,MAAM,eAAepE,CAAG,0BAA0BN,EAAM,MAAM,GAAG;AAC7E;AAAA,QAAA;AAGF6E,UAAevE,CAAG,IAAIqE,EAAW,OAAOrE,CAAG;AAAA,MAAA;AAG/CwB,MAAO,SAAS+C;AAAAA,EAAA;AAGlB,SAAI/C,EAAO,SACFA,EAAA,OAAOA,EAAO,KAAK,IAAI,CAACiB,MAAS+B,EAAqB5B,GAASH,CAAI,CAAC,IAEtEjB;AACT;AAKA,SAASgD,EAAqB5B,GAAsC6B,GAAsC;AACpG,MAAA,CAACC,EAAgBD,CAAO;AACnBA,WAAAA;AAGT,QAAMxB,IAAWwB,EAAQ,QACnBJ,IAAazB,EAAQK,CAAQ;AACnC,MAAI,CAACoB;AACH,UAAM,IAAI,MAAM,WAAWpB,CAAQ,gCAAgC;AAErE,MAAI,SAASwB,GAAS;AAEpB,QAAIA,EAAQ,MAAM,KAAKA,EAAQ,OAAOJ,EAAW,SAAS;AACxD,YAAM,IAAI,MAAM,cAAcI,EAAQ,GAAG,8BAA8BxB,CAAQ,GAAG;AAC7EoB,WAAAA,EAAW,SAASI,EAAQ,GAAG;AAAA,EAAA,WAC7B,UAAUA,GAAS;AAEtBE,UAAAA,IAAUN,EAAW,SAAS,OAAO,CAAC5B,MAASA,EAAK,SAASgC,EAAQ,IAAI;AAC/E,QAAIE,EAAQ,SAAS;AACnB,YAAM,IAAI,MAAM,4BAA4BF,EAAQ,IAAI,sBAAsBxB,CAAQ,GAAG;AAC3F,QAAI0B,EAAQ,WAAW;AACrB,YAAM,IAAI,MAAM,mBAAmBF,EAAQ,IAAI,0BAA0BxB,CAAQ,GAAG;AACtF,WAAO0B,EAAQ,CAAC;AAAA,EAAA,WACP,QAAQF,GAAS;AAE1B,UAAME,IAAUN,EAAW,SAAS,OAAO,CAAC5B,MAAST,EAAYyC,EAAQ,IAAIrD,EAAUqB,CAAI,CAAC,CAAC;AAC7F,QAAIkC,EAAQ,SAAS;AACnB,YAAM,IAAI,MAAM,uDAAuD1B,CAAQ,GAAG;AACpF,QAAI0B,EAAQ,WAAW;AACrB,YAAM,IAAI,MAAM,iDAAiD1B,CAAQ,GAAG;AAC9E,WAAO0B,EAAQ,CAAC;AAAA,EAAA;AAGZ,QAAA,IAAI,MAAM,iCAAiC;AACnD;AAKA,SAASD,EAAgBhF,GAA8C;AAC9D,SAAA,OAAOA,KAAU,YAAY,YAAYA;AAClD;ACjPO,SAASkF,EAAc1D,GAAwC;AACpE,SAAOA,EAAK,SAAS;AACvB;AAEO,SAAS2D,EAAaC,GAAoC;AACxDF,SAAAA,EAAcE,EAAI,IAAI;AAC/B;AAcO,SAASC,GAAiBD,GAA6B;AACxD,MAAA,CAACD,EAAUC,CAAG,EAAG,OAAM,IAAI,MAAM,yBAAyBA,EAAI,KAAK,IAAI,GAAG;AACvEA,SAAAA;AACT;AAYgB,SAAAE,GACdC,GACA9C,GACyB;AAClB8C,SAAAA,MAAS,SACZ,SACA;AAAA,IACE,GAAGA;AAAAA,IACH,MAAM9C,EAAG8C,EAAK,IAAI;AAAA,EACpB;AACN;AAEO,SAASC,GAAqB7C,GAA4C;AACzE,QAAA8C,IAAc,oBAAA,IACdC,GAAAA,IAAgB,CAAC/C,MAAiC;AACtD,YAAQA,EAAM,MAAM;AAAA,MAClB,KAAK;AACH8C,QAAAA,EAAQ,IAAI9C,EAAM,OAAO,IAAIA,EAAM,MAAM;AACzC;AAAA,MACF,KAAK;AACH8C,QAAAA,EAAQ,IAAI9C,EAAM,OAAO,IAAIA,EAAM,MAAM;AACzC;AAAA,MACF,KAAK;AACH;AAAA,MACF,KAAK;AAAA,MACL,KAAK;AACH,mBAAWgD,KAAKhD,EAAM,QAAS+C,CAAAA,EAAcC,CAAC;AAC9C;AAAA,MACF,KAAK;AACHD,QAAAA,EAAc/C,EAAM,OAAO;AAC3B,mBAAWgD,KAAKhD,EAAM,UAAW+C,CAAAA,EAAcC,CAAC;AAChD;AAAA,MACF;AACExG,QAAAA,EAAYwD,CAAK;AAAA,IAAA;AAAA,EAEvB;AACA,SAAA+C,EAAc/C,CAAK,GACZ,CAAC,GAAG8C,EAAQ,OAAQ,CAAA;AAC7B;ACyCgB,SAAAG,EAAUC,GAAwB9C,GAAuB;AAEvE,MAAI8C,EAAS,SAAS,UAAaA,EAAS,SAAS9C,EAAK;AACjD,WAAA;AAGL,MAAA8C,EAAS,SAAS;AAChB,QAAA,MAAM,QAAQA,EAAS,IAAI;AAC7B,UAAI,CAACA,EAAS,KAAK,SAAS9C,EAAK,IAAI;AAC5B,eAAA;AAAA,eACA8C,EAAS,SAAS9C,EAAK;AACzB,aAAA;AAAA;AAKP8C,MAAAA,EAAS,WAAW,QAAW;AAC3BC,UAAAA,IAAa/C,EAAK,UAAU,CAAC;AACnC,eAAW,CAACzC,GAAKN,CAAK,KAAK,OAAO,QAAQ6F,EAAS,MAAM;AACnDC,UAAAA,EAAWxF,CAAG,MAAMN;AACf,eAAA;AAAA,EAAA;AAGN,SAAA;AACT;AASgB,SAAA+F,EAAaC,GAAsBH,GAAoC;AAMjF,MAJAA,EAAS,SAAS,UAAaG,EAAQ,SAASH,EAAS,QAIzDA,EAAS,gBAAgB,UAAa,CAAC,IAAI,OAAOA,EAAS,WAAW,EAAE,KAAKG,EAAQ,IAAI;AACpF,WAAA;AAGL,MAAAH,EAAS,SAAS;AAChB,QAAA,MAAM,QAAQA,EAAS,IAAI;AAC7B,UAAI,CAACA,EAAS,KAAK,SAASG,EAAQ,SAAS;AACpC,eAAA;AAAA,eACAH,EAAS,SAASG,EAAQ;AAC5B,aAAA;AAAA;AAKPH,MAAAA,EAAS,WAAW,QAAW;AAC3BI,UAAAA,IAAeD,EAAQ,UAAU,CAAC;AACxC,eAAW,CAAC1F,GAAKN,CAAK,KAAK,OAAO,QAAQ6F,EAAS,MAAM;AACnDI,UAAAA,EAAa3F,CAAG,MAAMN;AACjB,eAAA;AAAA,EAAA;AAIT6F,MAAAA,EAAS,SAAS,QAAW;AAC/B,UAAMK,IAAcF,EAAQ,SAAS,IAAItE,CAAS;AAElD,QAAImE,EAAS;AAEX,iBAAWM,KAAgBN,EAAS;AAC9B,YAAA,CAACK,EAAY,KAAK,CAACE,MAAeR,EAAUO,GAAcC,CAAU,CAAC;AAChE,iBAAA;AAAA,WACN;AAEDF,UAAAA,EAAY,WAAWL,EAAS,KAAK;AAChC,eAAA;AAGT,eAASQ,IAAI,GAAGA,IAAIR,EAAS,KAAK,QAAQQ;AACpC,YAAA,CAACT,EAAUC,EAAS,KAAKQ,CAAC,GAAGH,EAAYG,CAAC,CAAC;AACtC,iBAAA;AAAA,IAAA;AAAA,EAAA;AAKXR,MAAAA,EAAS,gBAAgB,QAAW;AAChCS,UAAAA,IAAoBN,EAAQ,eAAe,CAAC;AAClD,eAAW,CAAC1F,GAAKN,CAAK,KAAK,OAAO,QAAQ6F,EAAS,WAAW;AACxDS,UAAAA,EAAkBhG,CAAG,MAAMN;AACtB,eAAA;AAAA,EAAA;AAIT6F,MAAAA,EAAS,uBAAuB,QAAW;AACvCS,UAAAA,IAAoBN,EAAQ,eAAe,CAAC;AACvC,eAAA,CAAC1F,GAAKiG,CAAO,KAAK,OAAO,QAAQV,EAAS,kBAAkB,GAAG;AAClE7F,YAAAA,IAAQsG,EAAkBhG,CAAG;AAC/BN,UAAAA,MAAU,UAAa,CAAC,IAAI,OAAOuG,CAAO,EAAE,KAAKvG,CAAK;AACjD,eAAA;AAAA,IAAA;AAAA,EAAA;AAIN,SAAA;AACT;AAQO,SAASwG,GAAqBC,GAA6F;AAC5H,SAAA,MAAM,QAAQA,CAAoB,IAC7B,CAACjF,MAASiF,EAAqB,KAAK,CAACZ,MAAaX,EAAc1D,CAAI,KAAKuE,EAAavE,GAAMqE,CAAQ,CAAC,IAErG,CAACrE,MAAS0D,EAAc1D,CAAI,KAAKuE,EAAavE,GAAMiF,CAAoB;AACnF;ACpQO,SAASC,GAAelF,GAAoC;AACjE,QAAMM,IAAkC;AAAA,IACtC,MAAMN,EAAK;AAAA,IACX,MAAMA,EAAK;AAAA,EACb;AACA,SAAIA,EAAK,WAAW,WAClBM,EAAO,SAASN,EAAK,SACnB0D,EAAc1D,CAAI,MACbM,EAAA,WAAWC,EAAUP,EAAK,QAAQ,IACpCR,EAAac,CAAM;AAC5B;ACdqB5C,EAClB,OAAO;AAAA,EACN,SAASA,EACN,QAAQ,EAAI,EACZ,SAAS,6DAA6D;AAAA,EACzE,SAASA,EAAE,SACR,SAAS,mBAAmB;AAAA,EAC/B,MAAMA,EAAE,SACL,SAAS,oEAAqE;AAAA,EACjF,oBAAoBA,EAAE,QAAQ,EAAI,EAAE,SAAS,EAC1C,SAAS,iLACwF;AACtG,CAAC,EACA;AAAA,EACC;AAGF,EACC,SAAS;AAWL,SAASyH,GAAQ3G,GAAgC;AACtD,SACE,OAAOA,KAAU,YACdA,MAAU,QACV,aAAaA,KACZA,EAA+B,YAAY,MAC5C,aAAaA,KACb,UAAUA;AAEjB;AA6CgB,SAAA4G,GAAgBC,GAAYC,IAA8B,IAAa;AACjFA,MAAAA;AACK,WAAA;AAAA,MACL,GAAGD;AAAAA,MACH,oBAAoB;AAAA,IACtB;AACG;AACH,UAAM,EAAE,oBAAoBE,GAAG,GAAGC,EAASH,IAAAA;AACpCG,WAAAA;AAAAA,EAAA;AAEX;ACrFgB,SAAAC,GACdC,GACAzE,GACqB;AACdyE,SAAAA,EAAI,KAAK,EAAE,IAAI,IAAM,OAAOzE,EAAGyE,EAAI,KAAK,EAAA,IAAMA;AACvD;ACXO,MAEMC,IAAa;AAENjI,EACjB,OAAA,EACA,OAAOiI,CAAU,EACjB,MAAM,oCAAoC,EAC1C,MAAM,MAAM;"}

package/dist/lib/model/pl-error-like/dist/index.js

@@ -1,36 +0,0 @@
-import "../../../../_virtual/stringify.js";
-import r from "../../../../node_modules/.pnpm/zod@3.23.8/node_modules/zod/lib/index.js";
-const o = r.object({
-  type: r.literal("PlError"),
-  name: r.string(),
-  message: r.string(),
-  /** The message with all details needed for SDK developers. */
-  fullMessage: r.string().optional(),
-  stack: r.string().optional()
-}), e = o.extend({
-  cause: r.lazy(() => a).optional(),
-  errors: r.lazy(() => a.array()).optional()
-}), s = r.object({
-  type: r.literal("StandardError"),
-  name: r.string(),
-  message: r.string(),
-  stack: r.string().optional()
-}), n = s.extend({
-  cause: r.lazy(() => a).optional(),
-  errors: r.lazy(() => a.array()).optional()
-}), a = r.union([n, e]), i = r.object({
-  name: r.string(),
-  message: r.string(),
-  fullMessage: r.string().optional(),
-  stack: r.string().optional()
-}), t = i.extend({
-  cause: r.lazy(() => t).optional(),
-  errors: r.lazy(() => t.array()).optional()
-});
-export {
-  o as BasePlErrorLike,
-  a as ErrorLike,
-  e as PlErrorLike,
-  n as StandardErrorLike
-};
-//# sourceMappingURL=index.js.map

package/dist/lib/model/pl-error-like/dist/index.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.js","sources":["../../../../../../../model/pl-error-like/src/error_like_shape.ts"],"sourcesContent":["import stringify from 'json-stringify-safe';\nimport { z } from 'zod';\n\n// We want to define StandardErrorLike and PlErrorLike, it's a way to define recursive types in zod.\n// https://zod.dev/?id=recursive-types\n// We need zod to parse error strings into these objects for keeping new UI and old blocks compatible.\n\nexport const BasePlErrorLike = z.object({\n  type: z.literal('PlError'),\n  name: z.string(),\n  message: z.string(),\n  /** The message with all details needed for SDK developers. */\n  fullMessage: z.string().optional(),\n  stack: z.string().optional(),\n});\n\n/** Known Pl backend and ML errors. */\nexport type PlErrorLike = z.infer<typeof BasePlErrorLike> & {\n  cause?: ErrorLike;\n  errors?: ErrorLike[];\n};\n\nexport const PlErrorLike: z.ZodType<PlErrorLike> = BasePlErrorLike.extend({\n  cause: z.lazy(() => ErrorLike).optional(),\n  errors: z.lazy(() => ErrorLike.array()).optional(),\n});\n\nconst BaseStandardErrorLike = z.object({\n  type: z.literal('StandardError'),\n  name: z.string(),\n  message: z.string(),\n  stack: z.string().optional(),\n});\n\n/** Others unknown errors that could be thrown by the client. */\nexport type StandardErrorLike = z.infer<typeof BaseStandardErrorLike> & {\n  cause?: ErrorLike;\n  errors?: ErrorLike[];\n};\n\nexport const StandardErrorLike: z.ZodType<StandardErrorLike> = BaseStandardErrorLike.extend({\n  cause: z.lazy(() => ErrorLike).optional(),\n  errors: z.lazy(() => ErrorLike.array()).optional(),\n});\n\nexport const ErrorLike = z.union([StandardErrorLike, PlErrorLike]);\nexport type ErrorLike = z.infer<typeof ErrorLike>;\n\n/** Converts everything into ErrorLike. */\nexport function ensureErrorLike(error: unknown): ErrorLike {\n  const result = ErrorShape.safeParse(error);\n\n  if (result.success) {\n    const err = result.data;\n\n    if (err.name === 'PlQuickJSError'\n      || err.name === 'PlErrorReport'\n      || err.name === 'PlInternalError'\n      || err.name === 'PlTengoError'\n      || err.name === 'PlRunnerError'\n      || err.name === 'PlMonetizationError') {\n      return {\n        type: 'PlError',\n        name: err.name,\n        message: err.message,\n        fullMessage: err.fullMessage ?? undefined,\n        stack: err.stack ?? undefined,\n        cause: err.cause ? ensureErrorLike(err.cause) : undefined,\n        errors: err.errors ? err.errors.map(ensureErrorLike) : undefined,\n      };\n    }\n\n    return {\n      type: 'StandardError',\n      name: err.name,\n      message: err.message,\n      stack: err.stack ?? undefined,\n      cause: err.cause ? ensureErrorLike(err.cause) : undefined,\n      errors: err.errors ? err.errors.map(ensureErrorLike) : undefined,\n    };\n  }\n\n  return {\n    type: 'StandardError',\n    name: 'Error',\n    // Stringify without circular dependencies.\n    // Maps (and sets?) will be converted to empty json objects,\n    // if this is a problem, we should change the library,\n    // but the new library must work in all QuickJS, UI and Node.js like this one.\n    message: stringify(error),\n  };\n}\n\n/** Tries to parse strings into ErrorLike. It's needed for keeping old blocks compatible with new UI. */\nexport function parseErrorLikeSafe(err: string): {\n  success: true;\n  data: ErrorLike;\n} | {\n  success: false;\n  error: Error;\n} {\n  try {\n    return ErrorLike.safeParse(JSON.parse(err));\n  } catch (e) {\n    return { success: false, error: new Error(`parseErrorLikeSafe: could not parse JSON: ${err}, ${String(e)}`) };\n  }\n}\n\n// We want to define ErrorShape schema just to parse it above, it's a way to define recursive types in zod.\n// https://zod.dev/?id=recursive-types\n\nconst baseErrorShape = z.object({\n  name: z.string(),\n  message: z.string(),\n  fullMessage: z.string().optional(),\n  stack: z.string().optional(),\n});\n\ntype ErrorShape = z.infer<typeof baseErrorShape> & {\n  cause?: ErrorShape;\n  errors?: ErrorShape[];\n};\n\nconst ErrorShape: z.ZodType<ErrorShape> = baseErrorShape.extend({\n  cause: z.lazy(() => ErrorShape).optional(),\n  errors: z.lazy(() => ErrorShape.array()).optional(),\n});\n"],"names":["BasePlErrorLike","z","PlErrorLike","ErrorLike","BaseStandardErrorLike","StandardErrorLike","baseErrorShape","ErrorShape"],"mappings":";;AAOaA,MAAAA,IAAkBC,EAAE,OAAO;AAAA,EACtC,MAAMA,EAAE,QAAQ,SAAS;AAAA,EACzB,MAAMA,EAAE,OAAO;AAAA,EACf,SAASA,EAAE,OAAO;AAAA;AAAA,EAElB,aAAaA,EAAE,OAAO,EAAE,SAAS;AAAA,EACjC,OAAOA,EAAE,OAAO,EAAE,SAAS;AAC7B,CAAC,GAQYC,IAAsCF,EAAgB,OAAO;AAAA,EACxE,OAAOC,EAAE,KAAK,MAAME,CAAS,EAAE,SAAS;AAAA,EACxC,QAAQF,EAAE,KAAK,MAAME,EAAU,MAAO,CAAA,EAAE,SAAS;AACnD,CAAC,GAEKC,IAAwBH,EAAE,OAAO;AAAA,EACrC,MAAMA,EAAE,QAAQ,eAAe;AAAA,EAC/B,MAAMA,EAAE,OAAO;AAAA,EACf,SAASA,EAAE,OAAO;AAAA,EAClB,OAAOA,EAAE,OAAO,EAAE,SAAS;AAC7B,CAAC,GAQYI,IAAkDD,EAAsB,OAAO;AAAA,EAC1F,OAAOH,EAAE,KAAK,MAAME,CAAS,EAAE,SAAS;AAAA,EACxC,QAAQF,EAAE,KAAK,MAAME,EAAU,MAAO,CAAA,EAAE,SAAS;AACnD,CAAC,GAEYA,IAAYF,EAAE,MAAM,CAACI,GAAmBH,CAAW,CAAC,GAkE3DI,IAAiBL,EAAE,OAAO;AAAA,EAC9B,MAAMA,EAAE,OAAO;AAAA,EACf,SAASA,EAAE,OAAO;AAAA,EAClB,aAAaA,EAAE,OAAO,EAAE,SAAS;AAAA,EACjC,OAAOA,EAAE,OAAO,EAAE,SAAS;AAC7B,CAAC,GAOKM,IAAoCD,EAAe,OAAO;AAAA,EAC9D,OAAOL,EAAE,KAAK,MAAMM,CAAU,EAAE,SAAS;AAAA,EACzC,QAAQN,EAAE,KAAK,MAAMM,EAAW,MAAO,CAAA,EAAE,SAAS;AACpD,CAAC;"}