{"version":3,"file":"index.mjs","names":[],"sources":["../../src/types.ts","../../src/utils/platform.ts","../../src/utils/validation.ts","../../src/core/array-operations.ts","../../src/utils/array-helpers.ts","../../src/core/pipeline-operations.ts","../../src/core/pipeline.ts","../../src/core/threadts.ts","../../src/decorators/utils.ts","../../src/decorators/parallel.ts","../../src/utils/cache.ts","../../src/decorators/caching.ts","../../src/decorators/flow-control.ts","../../src/decorators/observability.ts","../../src/utils/serialization.ts","../../src/adapters/base.ts","../../src/adapters/browser.ts","../../src/adapters/bun.ts","../../src/adapters/deno.ts","../../__vite-browser-external","../../src/pool/manager.ts","../../src/monitoring/error-handler.ts","../../src/monitoring/performance.ts","../../src/monitoring/health.ts","../../src/index.ts"],"sourcesContent":["/**\n * ThreadTS Universal - Core Types\n * Universal TypeScript library for effortless parallel computing\n */\n\n// Core execution options\nexport interface ThreadOptions {\n  timeout?: number;\n  priority?: 'low' | 'normal' | 'high';\n  signal?: AbortSignal;\n  transferable?: Transferable[];\n  maxRetries?: number;\n  poolSize?: number;\n  // Enhanced Node.js specific options\n  resourceLimits?: {\n    maxOldGenerationSizeMb?: number;\n    maxYoungGenerationSizeMb?: number;\n    codeRangeSizeMb?: number;\n    stackSizeMb?: number;\n  };\n  // Enhanced Deno specific options\n  denoPermissions?: {\n    net?: boolean | string[];\n    read?: boolean | string[];\n    write?: boolean | string[];\n    env?: boolean | string[];\n    run?: boolean | string[];\n    ffi?: boolean | string[];\n    hrtime?: boolean;\n    sys?: boolean | string[];\n  };\n  // Enhanced Bun specific options\n  bunOptions?: {\n    name?: string;\n    credentials?: 'omit' | 'same-origin' | 'include';\n    highPrecisionTiming?: boolean;\n    forceGC?: boolean;\n  };\n  // Cross-platform worker options\n  workerName?: string;\n  isolateContext?: boolean;\n  trackResources?: boolean;\n}\n\n// Generic task definition used by batch/parallel helpers\nexport interface ThreadTask<TData = SerializableData> {\n  fn: SerializableFunction;\n  data?: TData;\n  options?: ThreadOptions;\n}\n\n// Map/reduce helpers can specify batching behaviour in addition to thread options\nexport interface MapOptions extends ThreadOptions {\n  batchSize?: number;\n}\n\n// Progress monitoring\nexport interface ProgressEvent {\n  progress: number; // 0-100\n  message?: string;\n  data?: unknown;\n}\n\n// Execution result with metadata\nexport interface ThreadResult<T = unknown> {\n  result: T;\n  executionTime: number;\n  workerId?: string;\n  error?: Error;\n}\n\n// Worker pool configuration\nexport interface PoolConfig {\n  minWorkers?: number;\n  maxWorkers?: number;\n  idleTimeout?: number;\n  queueSize?: number;\n  strategy?: 'round-robin' | 'least-busy' | 'random';\n}\n\n// Platform detection\nexport type Platform = 'browser' | 'node' | 'deno' | 'bun' | 'unknown';\n\n// Serialization types - Type-safe alternatives to any\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport type SerializableFunction = (...args: any[]) => any;\nexport type SerializableData =\n  | string\n  | number\n  | boolean\n  | null\n  | undefined\n  | ArrayBuffer\n  | { [key: string]: unknown }\n  | unknown[];\n\n// TypedArray union type for better type safety\nexport type TypedArray =\n  | Int8Array\n  | Uint8Array\n  | Uint8ClampedArray\n  | Int16Array\n  | Uint16Array\n  | Int32Array\n  | Uint32Array\n  | Float32Array\n  | Float64Array\n  | BigInt64Array\n  | BigUint64Array;\n\n// Worker adapter interface\nexport interface WorkerAdapter {\n  readonly platform: Platform;\n  createWorker(script: string): Promise<WorkerInstance>;\n  terminateWorker(worker: WorkerInstance): Promise<void>;\n  isSupported(): boolean;\n}\n\n// Worker instance interface\nexport interface WorkerInstance {\n  id: string;\n  execute<T = unknown>(\n    fn: SerializableFunction,\n    data: SerializableData,\n    options?: ThreadOptions\n  ): Promise<ThreadResult<T>>;\n  terminate(): Promise<void>;\n  isIdle(): boolean;\n}\n\n// Pool manager interface\nexport interface PoolManager {\n  execute<T = unknown>(\n    fn: SerializableFunction,\n    data: SerializableData,\n    options?: ThreadOptions\n  ): Promise<ThreadResult<T>>;\n  resize(size: number): Promise<void>;\n  terminate(): Promise<void>;\n  getStats(): PoolStats;\n}\n\n// Pool statistics\nexport interface PoolStats {\n  activeWorkers: number;\n  idleWorkers: number;\n  queuedTasks: number;\n  completedTasks: number;\n  averageExecutionTime: number;\n}\n\n// Error types\nexport class ThreadError extends Error {\n  constructor(\n    message: string,\n    public readonly code: string,\n    public readonly cause?: Error\n  ) {\n    super(message);\n    this.name = 'ThreadError';\n  }\n}\n\nexport class TimeoutError extends ThreadError {\n  constructor(timeout: number) {\n    super(`Operation timed out after ${timeout}ms`, 'TIMEOUT');\n  }\n}\n\nexport class WorkerError extends ThreadError {\n  constructor(message: string, cause?: Error) {\n    super(message, 'WORKER_ERROR', cause);\n  }\n}\n\nexport class SerializationError extends ThreadError {\n  constructor(message: string, cause?: Error) {\n    super(message, 'SERIALIZATION_ERROR', cause);\n  }\n}\n\n// Decorator types\nexport interface ParallelMethodOptions extends ThreadOptions {\n  poolSize?: number;\n  cacheResults?: boolean;\n}\n\n// Event emitter interface for progress tracking\nexport interface ProgressTracker {\n  on(event: 'progress', handler: (event: ProgressEvent) => void): void;\n  off(event: 'progress', handler: (event: ProgressEvent) => void): void;\n  emit(event: 'progress', data: ProgressEvent): void;\n}\n\n// Main thread configuration\nexport interface ThreadConfig {\n  poolSize: number;\n  timeout: number;\n  retries: number;\n  autoResize: boolean;\n  debug: boolean;\n  serializationStrategy: 'auto' | 'json' | 'custom';\n  enableDecorators: boolean;\n  enableMetrics: boolean;\n  maxQueueSize: number;\n  workerIdleTimeout: number;\n  taskPriority: 'low' | 'normal' | 'high';\n}\n\n// Task execution result\nexport interface TaskResult {\n  success: boolean;\n  result: SerializableData | null;\n  error: string | null;\n}\n","/**\n * ThreadTS Universal - Platform Detection Utilities\n */\n\nimport { Platform } from '../types';\n\n// Global environment type definitions\ninterface NodeGlobal {\n  process?: {\n    versions?: {\n      node?: string;\n    };\n    memoryUsage?: () => {\n      rss: number;\n      heapTotal: number;\n      heapUsed: number;\n      external: number;\n      arrayBuffers: number;\n    };\n  };\n  require?: NodeRequire;\n}\n\ninterface DenoGlobal {\n  Deno?: {\n    version: {\n      deno: string;\n    };\n  };\n  navigator?: {\n    hardwareConcurrency?: number;\n  };\n}\n\ninterface BunGlobal {\n  Bun?: {\n    version: string;\n  };\n  navigator?: {\n    hardwareConcurrency?: number;\n  };\n}\n\ninterface BrowserGlobal {\n  navigator?: {\n    hardwareConcurrency?: number;\n  };\n  performance?: {\n    memory?: {\n      usedJSHeapSize: number;\n      totalJSHeapSize: number;\n      jsHeapSizeLimit: number;\n    };\n    now(): number;\n  };\n}\n\ntype GlobalEnvironment = NodeGlobal & DenoGlobal & BunGlobal & BrowserGlobal;\n\n/**\n * Detects the current JavaScript runtime platform\n */\nexport function detectPlatform(): Platform {\n  // Browser detection\n  if (typeof window !== 'undefined' && typeof window.document !== 'undefined') {\n    return 'browser';\n  }\n\n  const env = globalThis as unknown as GlobalEnvironment;\n\n  // Node.js detection\n  if (\n    typeof env.process !== 'undefined' &&\n    env.process.versions &&\n    env.process.versions.node\n  ) {\n    return 'node';\n  }\n\n  // Deno detection\n  if (typeof env.Deno !== 'undefined') {\n    return 'deno';\n  }\n\n  // Bun detection\n  if (typeof env.Bun !== 'undefined') {\n    return 'bun';\n  }\n\n  return 'unknown';\n}\n\n/**\n * Checks if Worker Threads are supported in the current environment\n */\nexport function supportsWorkerThreads(): boolean {\n  const platform = detectPlatform();\n\n  switch (platform) {\n    case 'browser':\n      return typeof Worker !== 'undefined';\n    case 'node':\n      try {\n        // Dynamic import for Node.js worker_threads\n        const env = globalThis as unknown as GlobalEnvironment;\n        const nodeRequire = env.require;\n        if (nodeRequire) {\n          nodeRequire('worker_threads');\n          return true;\n        }\n        return false;\n      } catch {\n        return false;\n      }\n    case 'deno':\n      return typeof Worker !== 'undefined';\n    case 'bun':\n      return typeof Worker !== 'undefined';\n    default:\n      return false;\n  }\n}\n\n/**\n * Checks if Transferable Objects are supported\n */\nexport function supportsTransferableObjects(): boolean {\n  const platform = detectPlatform();\n\n  switch (platform) {\n    case 'browser':\n      return (\n        typeof ArrayBuffer !== 'undefined' &&\n        typeof MessageChannel !== 'undefined'\n      );\n    case 'node':\n      return true; // Node.js supports transferable objects in worker_threads\n    case 'deno':\n      return typeof ArrayBuffer !== 'undefined';\n    case 'bun':\n      return typeof ArrayBuffer !== 'undefined';\n    default:\n      return false;\n  }\n}\n\n/**\n * Gets the optimal number of workers for the current platform\n */\nexport function getOptimalThreadCount(): number {\n  const platform = detectPlatform();\n\n  switch (platform) {\n    case 'browser': {\n      const env = globalThis as unknown as GlobalEnvironment;\n      return env.navigator?.hardwareConcurrency || 4;\n    }\n    case 'node': {\n      try {\n        const env = globalThis as unknown as GlobalEnvironment;\n        const nodeRequire = env.require;\n        if (nodeRequire) {\n          const os = nodeRequire('os');\n          return os.cpus().length;\n        }\n        return 4;\n      } catch {\n        return 4;\n      }\n    }\n    case 'deno': {\n      const denoEnv = globalThis as unknown as GlobalEnvironment;\n      return denoEnv.navigator?.hardwareConcurrency || 4;\n    }\n    case 'bun': {\n      const bunEnv = globalThis as unknown as GlobalEnvironment;\n      return bunEnv.navigator?.hardwareConcurrency || 4;\n    }\n    default:\n      return 4;\n  }\n}\n\n/**\n * Checks if the current environment supports OffscreenCanvas\n */\nexport function supportsOffscreenCanvas(): boolean {\n  return typeof OffscreenCanvas !== 'undefined';\n}\n\n/**\n * Checks if the current environment supports Web Locks API\n */\nexport function supportsWebLocks(): boolean {\n  return typeof navigator !== 'undefined' && 'locks' in navigator;\n}\n\n/**\n * Gets platform-specific performance timestamp\n */\nexport function getHighResTimestamp(): number {\n  const platform = detectPlatform();\n\n  switch (platform) {\n    case 'browser':\n      return performance.now();\n    case 'node':\n      try {\n        const env = globalThis as unknown as GlobalEnvironment;\n        const nodeRequire = env.require;\n        if (nodeRequire) {\n          const { performance: nodePerf } = nodeRequire('perf_hooks');\n          return nodePerf.now();\n        }\n        return Date.now();\n      } catch {\n        return Date.now();\n      }\n    case 'deno':\n      return performance.now();\n    case 'bun':\n      return performance.now();\n    default:\n      return Date.now();\n  }\n}\n\n/**\n * Platform-specific memory usage information\n */\nexport interface MemoryInfo {\n  used: number;\n  total: number;\n  available: number;\n}\n\n/**\n * Gets memory information for the current platform\n */\nexport function getMemoryInfo(): MemoryInfo | null {\n  const platform = detectPlatform();\n\n  switch (platform) {\n    case 'browser':\n      if (typeof performance !== 'undefined' && 'memory' in performance) {\n        const env = globalThis as unknown as GlobalEnvironment;\n        const mem = env.performance?.memory;\n        if (mem) {\n          return {\n            used: mem.usedJSHeapSize,\n            total: mem.totalJSHeapSize,\n            available: mem.jsHeapSizeLimit - mem.usedJSHeapSize,\n          };\n        }\n      }\n      return null;\n    case 'node':\n      try {\n        const env = globalThis as unknown as GlobalEnvironment;\n        const nodeProcess = env.process;\n        if (nodeProcess?.memoryUsage) {\n          const mem = nodeProcess.memoryUsage();\n          return {\n            used: mem.heapUsed,\n            total: mem.heapTotal,\n            available: mem.heapTotal - mem.heapUsed,\n          };\n        }\n        return null;\n      } catch {\n        return null;\n      }\n    case 'deno':\n      if (typeof performance !== 'undefined' && 'memory' in performance) {\n        const env = globalThis as unknown as GlobalEnvironment;\n        const mem = env.performance?.memory;\n        if (mem) {\n          return {\n            used: mem.usedJSHeapSize,\n            total: mem.totalJSHeapSize,\n            available: mem.jsHeapSizeLimit - mem.usedJSHeapSize,\n          };\n        }\n      }\n      return null;\n    default:\n      return null;\n  }\n}\n\n// Platform utilities class for easier access\nexport class PlatformUtils {\n  static detectPlatform = detectPlatform;\n  static supportsWorkerThreads = supportsWorkerThreads;\n  static supportsTransferableObjects = supportsTransferableObjects;\n  static getOptimalWorkerCount = getOptimalThreadCount;\n  static supportsOffscreenCanvas = supportsOffscreenCanvas;\n  static supportsWebLocks = supportsWebLocks;\n  static getHighResTimestamp = getHighResTimestamp;\n  static getMemoryInfo = getMemoryInfo;\n}\n","/**\n * ThreadTS Universal - Validation Utilities\n *\n * Centralized input validation for ThreadTS operations.\n * Provides reusable validation functions to ensure data integrity\n * and consistent error messages across the library.\n *\n * @module utils/validation\n * @author ThreadTS Universal Team\n */\n\nimport { SerializationError, ThreadError } from '../types';\n\n/**\n * Validation result containing success status and optional error.\n */\nexport interface ValidationResult {\n  /** Whether the validation passed */\n  valid: boolean;\n  /** Error message if validation failed */\n  error?: string;\n}\n\n/**\n * Validates that a value is a function.\n *\n * @param fn - The value to validate\n * @param paramName - Name of the parameter for error messages\n * @throws {ThreadError} If the value is not a function\n *\n * @example\n * ```typescript\n * validateFunction(myCallback, 'callback');\n * validateFunction(() => 42, 'processor');\n * ```\n */\nexport function validateFunction(fn: unknown, paramName = 'fn'): void {\n  if (typeof fn !== 'function') {\n    const receivedType = fn === null ? 'null' : typeof fn;\n    throw new ThreadError(\n      `${paramName} must be a function, received ${receivedType}`,\n      'INVALID_ARGUMENT'\n    );\n  }\n}\n\n/**\n * Validates that a value is an array.\n *\n * @param arr - The value to validate\n * @param paramName - Name of the parameter for error messages\n * @throws {ThreadError} If the value is not an array\n *\n * @example\n * ```typescript\n * validateArray([1, 2, 3], 'items');\n * validateArray(myData, 'data');\n * ```\n */\nexport function validateArray(arr: unknown, paramName = 'array'): void {\n  if (!Array.isArray(arr)) {\n    const receivedType = arr === null ? 'null' : typeof arr;\n    throw new ThreadError(\n      `${paramName} must be an array, received ${receivedType}`,\n      'INVALID_ARGUMENT'\n    );\n  }\n}\n\n/**\n * Validates that an array is not empty.\n *\n * @param arr - The array to validate\n * @param paramName - Name of the parameter for error messages\n * @throws {ThreadError} If the array is empty\n *\n * @example\n * ```typescript\n * validateNonEmptyArray([1, 2, 3], 'items');\n * ```\n */\nexport function validateNonEmptyArray(\n  arr: unknown[],\n  paramName = 'array'\n): void {\n  if (arr.length === 0) {\n    throw new ThreadError(`${paramName} cannot be empty`, 'INVALID_ARGUMENT');\n  }\n}\n\n/**\n * Validates that a number is positive.\n *\n * @param value - The value to validate\n * @param paramName - Name of the parameter for error messages\n * @throws {ThreadError} If the value is not a positive number\n *\n * @example\n * ```typescript\n * validatePositiveNumber(5, 'timeout');\n * validatePositiveNumber(batchSize, 'batchSize');\n * ```\n */\nexport function validatePositiveNumber(\n  value: unknown,\n  paramName = 'value'\n): void {\n  if (typeof value !== 'number' || isNaN(value)) {\n    throw new ThreadError(\n      `${paramName} must be a number, received ${typeof value}`,\n      'INVALID_ARGUMENT'\n    );\n  }\n\n  if (value <= 0) {\n    throw new ThreadError(\n      `${paramName} must be positive, received ${value}`,\n      'INVALID_ARGUMENT'\n    );\n  }\n}\n\n/**\n * Validates that a number is non-negative (zero or positive).\n *\n * @param value - The value to validate\n * @param paramName - Name of the parameter for error messages\n * @throws {ThreadError} If the value is negative\n *\n * @example\n * ```typescript\n * validateNonNegativeNumber(0, 'delay');\n * validateNonNegativeNumber(retryCount, 'retries');\n * ```\n */\nexport function validateNonNegativeNumber(\n  value: unknown,\n  paramName = 'value'\n): void {\n  if (typeof value !== 'number' || isNaN(value)) {\n    throw new ThreadError(\n      `${paramName} must be a number, received ${typeof value}`,\n      'INVALID_ARGUMENT'\n    );\n  }\n\n  if (value < 0) {\n    throw new ThreadError(\n      `${paramName} must be non-negative, received ${value}`,\n      'INVALID_ARGUMENT'\n    );\n  }\n}\n\n/**\n * Validates that a value is within a specified range.\n *\n * @param value - The value to validate\n * @param min - Minimum allowed value (inclusive)\n * @param max - Maximum allowed value (inclusive)\n * @param paramName - Name of the parameter for error messages\n * @throws {ThreadError} If the value is outside the range\n *\n * @example\n * ```typescript\n * validateRange(priority, 1, 3, 'priority');\n * validateRange(poolSize, 1, 100, 'poolSize');\n * ```\n */\nexport function validateRange(\n  value: number,\n  min: number,\n  max: number,\n  paramName = 'value'\n): void {\n  if (value < min || value > max) {\n    throw new ThreadError(\n      `${paramName} must be between ${min} and ${max}, received ${value}`,\n      'INVALID_ARGUMENT'\n    );\n  }\n}\n\n/**\n * Validates that a value is one of the allowed options.\n *\n * @param value - The value to validate\n * @param allowedValues - Array of allowed values\n * @param paramName - Name of the parameter for error messages\n * @throws {ThreadError} If the value is not in the allowed list\n *\n * @example\n * ```typescript\n * validateEnum(priority, ['low', 'normal', 'high'], 'priority');\n * validateEnum(strategy, ['round-robin', 'least-busy'], 'strategy');\n * ```\n */\nexport function validateEnum<T>(\n  value: T,\n  allowedValues: readonly T[],\n  paramName = 'value'\n): void {\n  if (!allowedValues.includes(value)) {\n    const allowed = allowedValues.map((v) => `\"${String(v)}\"`).join(', ');\n    throw new ThreadError(\n      `${paramName} must be one of [${allowed}], received \"${String(value)}\"`,\n      'INVALID_ARGUMENT'\n    );\n  }\n}\n\n/**\n * Internal recursive implementation of validateSerializable.\n * @internal\n */\nfunction validateSerializableImpl(value: unknown, seen: WeakSet<object>): void {\n  // Primitive types are always serializable\n  if (value === null || value === undefined) {\n    return;\n  }\n\n  const valueType = typeof value;\n\n  // Check for non-serializable primitives\n  if (valueType === 'function') {\n    throw new SerializationError(\n      'Functions cannot be transferred as task data. Pass data separately from the function.'\n    );\n  }\n\n  if (valueType === 'symbol') {\n    throw new SerializationError(\n      'Symbols cannot be serialized. Use strings instead.'\n    );\n  }\n\n  if (valueType === 'bigint') {\n    throw new SerializationError(\n      'BigInt values cannot be directly serialized. Convert to string first.'\n    );\n  }\n\n  // Primitives (string, number, boolean) are serializable\n  if (valueType !== 'object') {\n    return;\n  }\n\n  // Check for circular references\n  if (seen.has(value as object)) {\n    throw new SerializationError(\n      'Circular reference detected in task data. Remove circular references before passing data.'\n    );\n  }\n\n  seen.add(value as object);\n\n  // Handle arrays\n  if (Array.isArray(value)) {\n    for (let i = 0; i < value.length; i++) {\n      try {\n        validateSerializableImpl(value[i], seen);\n      } catch (error) {\n        if (error instanceof SerializationError) {\n          throw new SerializationError(`At array index ${i}: ${error.message}`);\n        }\n        throw error;\n      }\n    }\n    return;\n  }\n\n  // Handle special objects that are serializable\n  if (\n    value instanceof ArrayBuffer ||\n    ArrayBuffer.isView(value) ||\n    value instanceof Date ||\n    value instanceof RegExp ||\n    value instanceof Map ||\n    value instanceof Set\n  ) {\n    return; // These are handled by structured clone\n  }\n\n  // Handle plain objects\n  for (const [key, val] of Object.entries(value as Record<string, unknown>)) {\n    try {\n      validateSerializableImpl(val, seen);\n    } catch (error) {\n      if (error instanceof SerializationError) {\n        throw new SerializationError(`At property \"${key}\": ${error.message}`);\n      }\n      throw error;\n    }\n  }\n}\n\n/**\n * Validates that data is serializable (can be passed to a worker).\n *\n * Checks for:\n * - Functions (not serializable as data)\n * - Circular references\n * - Symbols (not serializable)\n * - BigInt (not directly serializable)\n *\n * @param value - The value to validate\n * @throws {SerializationError} If the data cannot be serialized\n *\n * @example\n * ```typescript\n * // Single value validation\n * validateSerializable({ name: 'test', count: 42 });\n *\n * // Batch validation\n * for (const item of items) {\n *   validateSerializable(item);\n * }\n * ```\n */\nexport function validateSerializable(value: unknown): void {\n  validateSerializableImpl(value, new WeakSet<object>());\n}\n\n/**\n * Validates thread execution options.\n *\n * @param options - The options object to validate\n * @throws {ThreadError} If any option is invalid\n *\n * @example\n * ```typescript\n * validateThreadOptions({ timeout: 5000, priority: 'high' });\n * validateThreadOptions({ maxRetries: 3 });\n * ```\n */\nexport function validateThreadOptions(options: Record<string, unknown>): void {\n  if (options.timeout !== undefined) {\n    if (typeof options.timeout !== 'number') {\n      throw new ThreadError(\n        `timeout must be a number, received ${typeof options.timeout}`,\n        'INVALID_OPTION'\n      );\n    }\n    if (isNaN(options.timeout)) {\n      throw new ThreadError(\n        'timeout must be a valid number, received NaN',\n        'INVALID_OPTION'\n      );\n    }\n    if (options.timeout <= 0) {\n      throw new ThreadError(\n        `timeout must be positive, received ${options.timeout}`,\n        'INVALID_OPTION'\n      );\n    }\n  }\n\n  if (options.maxRetries !== undefined) {\n    if (typeof options.maxRetries !== 'number') {\n      throw new ThreadError(\n        `maxRetries must be a number, received ${typeof options.maxRetries}`,\n        'INVALID_OPTION'\n      );\n    }\n    if (isNaN(options.maxRetries)) {\n      throw new ThreadError(\n        'maxRetries must be a valid number, received NaN',\n        'INVALID_OPTION'\n      );\n    }\n    if (options.maxRetries < 0) {\n      throw new ThreadError(\n        `maxRetries must be non-negative, received ${options.maxRetries}`,\n        'INVALID_OPTION'\n      );\n    }\n  }\n\n  if (options.priority !== undefined) {\n    validateEnum(\n      options.priority,\n      ['low', 'normal', 'high'] as const,\n      'priority'\n    );\n  }\n\n  if (options.batchSize !== undefined) {\n    if (typeof options.batchSize !== 'number') {\n      throw new ThreadError(\n        `batchSize must be a number, received ${typeof options.batchSize}`,\n        'INVALID_OPTION'\n      );\n    }\n    if (isNaN(options.batchSize)) {\n      throw new ThreadError(\n        'batchSize must be a valid number, received NaN',\n        'INVALID_OPTION'\n      );\n    }\n    if (options.batchSize < 1) {\n      throw new ThreadError(\n        `batchSize must be at least 1, received ${options.batchSize}`,\n        'INVALID_OPTION'\n      );\n    }\n  }\n\n  if (\n    options.signal !== undefined &&\n    !(options.signal instanceof AbortSignal)\n  ) {\n    throw new ThreadError(\n      'signal must be an AbortSignal instance',\n      'INVALID_OPTION'\n    );\n  }\n}\n\n/**\n * Validates a task definition for batch/parallel execution.\n *\n * Accepts any value but validates that it:\n * 1. Is a non-null object\n * 2. Has either 'fn' or 'func' property that is a function\n *\n * @param task - The task to validate (accepts unknown for flexibility)\n * @param index - Optional index for error messages in batch operations\n * @throws {ThreadError} If the task is invalid\n *\n * @example\n * ```typescript\n * validateTask({ fn: (x) => x * 2, data: 5 });\n * validateTask({ fn: myFunction }, 0);\n * ```\n */\nexport function validateTask(\n  task: unknown,\n  index?: number\n): asserts task is {\n  fn?: (...args: unknown[]) => unknown;\n  func?: (...args: unknown[]) => unknown;\n} {\n  const prefix = index !== undefined ? `Task at index ${index}: ` : '';\n\n  // First check: must be a non-null object\n  if (typeof task !== 'object' || task === null) {\n    throw new ThreadError(\n      `${prefix}Task must be an object with fn property`,\n      'INVALID_TASK'\n    );\n  }\n\n  // Safe to cast after null/object check\n  const taskObj = task as Record<string, unknown>;\n\n  // Support both 'fn' and 'func' property names\n  const fn = taskObj.fn ?? taskObj.func;\n\n  if (typeof fn !== 'function') {\n    throw new ThreadError(\n      `${prefix}Task must have a function property (fn or func)`,\n      'INVALID_TASK'\n    );\n  }\n}\n\n/**\n * Validates multiple tasks for batch/parallel execution.\n *\n * @param tasks - Array of tasks to validate\n * @throws {ThreadError} If any task is invalid\n *\n * @example\n * ```typescript\n * validateTasks([\n *   { fn: (x) => x * 2, data: 5 },\n *   { fn: (x) => x + 1, data: 10 }\n * ]);\n * ```\n */\nexport function validateTasks(tasks: unknown[]): void {\n  validateArray(tasks, 'tasks');\n\n  for (let i = 0; i < tasks.length; i++) {\n    validateTask(tasks[i], i);\n  }\n}\n\n/**\n * Safely coerces a value to a positive integer.\n *\n * @param value - The value to coerce\n * @param defaultValue - Default value if coercion fails\n * @param minValue - Minimum allowed value (default: 1)\n * @returns The coerced positive integer\n *\n * @example\n * ```typescript\n * const batchSize = toPositiveInt(options.batchSize, 10);\n * const poolSize = toPositiveInt(config.poolSize, 4, 1);\n * ```\n */\nexport function toPositiveInt(\n  value: unknown,\n  defaultValue: number,\n  minValue = 1\n): number {\n  if (typeof value !== 'number' || isNaN(value)) {\n    return defaultValue;\n  }\n\n  const intValue = Math.floor(value);\n  return Math.max(minValue, intValue);\n}\n\n/**\n * Safely coerces a value to a non-negative integer.\n *\n * @param value - The value to coerce\n * @param defaultValue - Default value if coercion fails\n * @returns The coerced non-negative integer\n *\n * @example\n * ```typescript\n * const retries = toNonNegativeInt(options.maxRetries, 2);\n * const delay = toNonNegativeInt(config.delay, 0);\n * ```\n */\nexport function toNonNegativeInt(value: unknown, defaultValue: number): number {\n  if (typeof value !== 'number' || isNaN(value)) {\n    return defaultValue;\n  }\n\n  const intValue = Math.floor(value);\n  return Math.max(0, intValue);\n}\n\n/**\n * Validation utilities class for easier access.\n * Groups all validation functions as static methods.\n *\n * @example\n * ```typescript\n * ValidationUtils.validateFunction(callback, 'callback');\n * ValidationUtils.validateSerializable(data);\n * ```\n */\nexport class ValidationUtils {\n  static validateFunction(fn: unknown, paramName = 'fn'): void {\n    validateFunction(fn, paramName);\n  }\n\n  static validateArray(arr: unknown, paramName = 'array'): void {\n    validateArray(arr, paramName);\n  }\n\n  static validateNonEmptyArray(arr: unknown[], paramName = 'array'): void {\n    validateNonEmptyArray(arr, paramName);\n  }\n\n  static validatePositiveNumber(value: unknown, paramName = 'value'): void {\n    validatePositiveNumber(value, paramName);\n  }\n\n  static validateNonNegativeNumber(value: unknown, paramName = 'value'): void {\n    validateNonNegativeNumber(value, paramName);\n  }\n\n  static validateRange(\n    value: number,\n    min: number,\n    max: number,\n    paramName = 'value'\n  ): void {\n    validateRange(value, min, max, paramName);\n  }\n\n  static validateEnum<T>(\n    value: T,\n    allowedValues: readonly T[],\n    paramName = 'value'\n  ): void {\n    validateEnum(value, allowedValues, paramName);\n  }\n\n  static validateSerializable(value: unknown): void {\n    validateSerializable(value);\n  }\n\n  static validateThreadOptions(options: Record<string, unknown>): void {\n    validateThreadOptions(options);\n  }\n\n  static validateTask(\n    task: unknown,\n    index?: number\n  ): asserts task is {\n    fn?: (...args: unknown[]) => unknown;\n    func?: (...args: unknown[]) => unknown;\n  } {\n    validateTask(task, index);\n  }\n\n  static validateTasks(tasks: unknown[]): void {\n    validateTasks(tasks);\n  }\n\n  static toPositiveInt(\n    value: unknown,\n    defaultValue: number,\n    minValue = 1\n  ): number {\n    return toPositiveInt(value, defaultValue, minValue);\n  }\n\n  static toNonNegativeInt(value: unknown, defaultValue: number): number {\n    return toNonNegativeInt(value, defaultValue);\n  }\n}\n","/**\n * ThreadTS Universal - Array Operations Module\n *\n * Provides extended array operation methods that were missing from the core API.\n * These operations follow the Array API conventions and support parallel execution.\n *\n * @module core/array-operations\n * @author ThreadTS Universal Team\n */\n\nimport type { MapOptions, SerializableFunction, ThreadOptions } from '../types';\n\n/**\n * Interface for array operation executor.\n * Allows this module to be used with any ThreadTS-like instance.\n */\nexport interface ArrayOperationExecutor {\n  run<T>(\n    fn: SerializableFunction,\n    data?: unknown,\n    options?: ThreadOptions\n  ): Promise<T>;\n  map<T, R>(\n    array: T[],\n    fn: SerializableFunction,\n    options?: MapOptions\n  ): Promise<R[]>;\n}\n\n/**\n * Creates array operation methods bound to a specific executor.\n * This factory pattern allows for dependency injection and testing.\n *\n * @param _executor - The executor instance (ThreadTS or compatible) - reserved for future parallel implementations\n * @returns Object containing all array operation methods\n */\nexport function createArrayOperations(_executor: ArrayOperationExecutor) {\n  /**\n   * Finds the index of the first occurrence of a value in the array.\n   * Similar to Array.prototype.indexOf but processes in parallel for equality checks.\n   *\n   * @template T - The type of array elements\n   * @param array - The array to search\n   * @param searchElement - The element to locate\n   * @param fromIndex - Optional starting index\n   * @returns The index of the first match, or -1 if not found\n   *\n   * @example\n   * ```typescript\n   * const index = await threadts.indexOf([1, 2, 3, 4, 5], 3);\n   * console.log(index); // 2\n   * ```\n   */\n  async function indexOf<T>(\n    array: T[],\n    searchElement: T,\n    fromIndex = 0\n  ): Promise<number> {\n    if (!array.length) {\n      return -1;\n    }\n\n    const startIndex =\n      fromIndex < 0 ? Math.max(0, array.length + fromIndex) : fromIndex;\n\n    if (startIndex >= array.length) {\n      return -1;\n    }\n\n    // For simple equality, use native indexOf\n    const result = array.indexOf(searchElement, startIndex);\n    return result;\n  }\n\n  /**\n   * Finds the index of the last occurrence of a value in the array.\n   * Similar to Array.prototype.lastIndexOf.\n   *\n   * @template T - The type of array elements\n   * @param array - The array to search\n   * @param searchElement - The element to locate\n   * @param fromIndex - Optional starting index (searches backwards)\n   * @returns The index of the last match, or -1 if not found\n   *\n   * @example\n   * ```typescript\n   * const index = await threadts.lastIndexOf([1, 2, 3, 2, 1], 2);\n   * console.log(index); // 3\n   * ```\n   */\n  async function lastIndexOf<T>(\n    array: T[],\n    searchElement: T,\n    fromIndex?: number\n  ): Promise<number> {\n    if (!array.length) {\n      return -1;\n    }\n\n    const startIndex = fromIndex === undefined ? array.length - 1 : fromIndex;\n    const result = array.lastIndexOf(searchElement, startIndex);\n    return result;\n  }\n\n  /**\n   * Returns the element at the specified index.\n   * Similar to Array.prototype.at with support for negative indices.\n   *\n   * @template T - The type of array elements\n   * @param array - The array to access\n   * @param index - The index (can be negative for reverse access)\n   * @returns The element at the index, or undefined\n   *\n   * @example\n   * ```typescript\n   * const last = await threadts.at([1, 2, 3, 4, 5], -1);\n   * console.log(last); // 5\n   * ```\n   */\n  async function at<T>(array: T[], index: number): Promise<T | undefined> {\n    if (!array.length) {\n      return undefined;\n    }\n\n    const normalizedIndex = index < 0 ? array.length + index : index;\n\n    if (normalizedIndex < 0 || normalizedIndex >= array.length) {\n      return undefined;\n    }\n\n    return array[normalizedIndex];\n  }\n\n  /**\n   * Creates a new array with elements from startIndex to endIndex.\n   * Similar to Array.prototype.slice but returns a Promise.\n   *\n   * @template T - The type of array elements\n   * @param array - The array to slice\n   * @param start - Optional start index (default: 0)\n   * @param end - Optional end index (default: array.length)\n   * @returns A new array containing the sliced elements\n   *\n   * @example\n   * ```typescript\n   * const sliced = await threadts.slice([1, 2, 3, 4, 5], 1, 4);\n   * console.log(sliced); // [2, 3, 4]\n   * ```\n   */\n  async function slice<T>(\n    array: T[],\n    start?: number,\n    end?: number\n  ): Promise<T[]> {\n    return array.slice(start, end);\n  }\n\n  /**\n   * Concatenates multiple arrays into one.\n   * Similar to Array.prototype.concat but returns a Promise.\n   *\n   * @template T - The type of array elements\n   * @param array - The base array\n   * @param items - Additional arrays or values to concatenate\n   * @returns A new concatenated array\n   *\n   * @example\n   * ```typescript\n   * const combined = await threadts.concat([1, 2], [3, 4], [5, 6]);\n   * console.log(combined); // [1, 2, 3, 4, 5, 6]\n   * ```\n   */\n  async function concat<T>(array: T[], ...items: (T | T[])[]): Promise<T[]> {\n    return array.concat(...items);\n  }\n\n  /**\n   * Fills array elements with a specified value in parallel.\n   * Creates a new array with filled values (immutable operation).\n   *\n   * @template T - The type of array elements\n   * @param array - The array to fill\n   * @param value - The value to fill with\n   * @param start - Optional start index (default: 0)\n   * @param end - Optional end index (default: array.length)\n   * @returns A new array with filled values\n   *\n   * @example\n   * ```typescript\n   * const filled = await threadts.fill([1, 2, 3, 4, 5], 0, 1, 4);\n   * console.log(filled); // [1, 0, 0, 0, 5]\n   * ```\n   */\n  async function fill<T>(\n    array: T[],\n    value: T,\n    start = 0,\n    end?: number\n  ): Promise<T[]> {\n    const result = [...array];\n    const actualEnd = end ?? array.length;\n    const normalizedStart =\n      start < 0 ? Math.max(0, array.length + start) : start;\n    const normalizedEnd =\n      actualEnd < 0 ? Math.max(0, array.length + actualEnd) : actualEnd;\n\n    for (let i = normalizedStart; i < normalizedEnd && i < result.length; i++) {\n      result[i] = value;\n    }\n\n    return result;\n  }\n\n  /**\n   * Checks if the array includes a specific element.\n   * Similar to Array.prototype.includes but returns a Promise.\n   *\n   * @template T - The type of array elements\n   * @param array - The array to search\n   * @param searchElement - The element to find\n   * @param fromIndex - Optional starting index\n   * @returns true if the element is found\n   *\n   * @example\n   * ```typescript\n   * const hasThree = await threadts.includes([1, 2, 3, 4, 5], 3);\n   * console.log(hasThree); // true\n   * ```\n   */\n  async function includes<T>(\n    array: T[],\n    searchElement: T,\n    fromIndex = 0\n  ): Promise<boolean> {\n    return array.includes(searchElement, fromIndex);\n  }\n\n  /**\n   * Joins all elements of an array into a string.\n   * Similar to Array.prototype.join but returns a Promise.\n   *\n   * @template T - The type of array elements\n   * @param array - The array to join\n   * @param separator - Optional separator string (default: ',')\n   * @returns The joined string\n   *\n   * @example\n   * ```typescript\n   * const joined = await threadts.join(['a', 'b', 'c'], '-');\n   * console.log(joined); // 'a-b-c'\n   * ```\n   */\n  async function join<T>(array: T[], separator = ','): Promise<string> {\n    return array.join(separator);\n  }\n\n  /**\n   * Reverses the elements of an array.\n   * Creates a new reversed array (immutable operation).\n   *\n   * @template T - The type of array elements\n   * @param array - The array to reverse\n   * @returns A new array with reversed elements\n   *\n   * @example\n   * ```typescript\n   * const reversed = await threadts.reverse([1, 2, 3, 4, 5]);\n   * console.log(reversed); // [5, 4, 3, 2, 1]\n   * ```\n   */\n  async function reverse<T>(array: T[]): Promise<T[]> {\n    return [...array].reverse();\n  }\n\n  /**\n   * Sorts the elements of an array.\n   * Creates a new sorted array (immutable operation).\n   *\n   * @template T - The type of array elements\n   * @param array - The array to sort\n   * @param compareFn - Optional comparison function\n   * @returns A new sorted array\n   *\n   * @example\n   * ```typescript\n   * const sorted = await threadts.sort([3, 1, 4, 1, 5], (a, b) => a - b);\n   * console.log(sorted); // [1, 1, 3, 4, 5]\n   * ```\n   */\n  async function sort<T>(\n    array: T[],\n    compareFn?: (a: T, b: T) => number\n  ): Promise<T[]> {\n    return [...array].sort(compareFn);\n  }\n\n  /**\n   * Creates an array containing a range of numbers.\n   * Utility method for generating test data.\n   *\n   * @param start - Start of range (inclusive)\n   * @param end - End of range (exclusive)\n   * @param step - Step between values (default: 1)\n   * @returns Array of numbers in the range\n   *\n   * @example\n   * ```typescript\n   * const range = await threadts.range(0, 10, 2);\n   * console.log(range); // [0, 2, 4, 6, 8]\n   * ```\n   */\n  async function range(\n    start: number,\n    end: number,\n    step = 1\n  ): Promise<number[]> {\n    const result: number[] = [];\n    if (step > 0) {\n      for (let i = start; i < end; i += step) {\n        result.push(i);\n      }\n    } else if (step < 0) {\n      for (let i = start; i > end; i += step) {\n        result.push(i);\n      }\n    }\n    return result;\n  }\n\n  /**\n   * Creates an array by repeating a value.\n   *\n   * @template T - The type of the value\n   * @param value - The value to repeat\n   * @param count - Number of times to repeat\n   * @returns Array of repeated values\n   *\n   * @example\n   * ```typescript\n   * const repeated = await threadts.repeat('x', 5);\n   * console.log(repeated); // ['x', 'x', 'x', 'x', 'x']\n   * ```\n   */\n  async function repeat<T>(value: T, count: number): Promise<T[]> {\n    return Array.from({ length: Math.max(0, count) }, () => value);\n  }\n\n  /**\n   * Zips multiple arrays together into an array of tuples.\n   *\n   * @param arrays - Arrays to zip together\n   * @returns Array of tuples\n   *\n   * @example\n   * ```typescript\n   * const zipped = await threadts.zip([1, 2, 3], ['a', 'b', 'c']);\n   * console.log(zipped); // [[1, 'a'], [2, 'b'], [3, 'c']]\n   * ```\n   */\n  async function zip<T extends unknown[][]>(\n    ...arrays: T\n  ): Promise<{ [K in keyof T]: T[K] extends (infer U)[] ? U : never }[]> {\n    if (arrays.length === 0) {\n      return [] as { [K in keyof T]: T[K] extends (infer U)[] ? U : never }[];\n    }\n\n    const minLength = Math.min(...arrays.map((arr) => arr.length));\n    const result: unknown[][] = [];\n\n    for (let i = 0; i < minLength; i++) {\n      result.push(arrays.map((arr) => arr[i]));\n    }\n\n    return result as { [K in keyof T]: T[K] extends (infer U)[] ? U : never }[];\n  }\n\n  /**\n   * Unzips an array of tuples into separate arrays.\n   *\n   * @template T - The tuple type\n   * @param array - Array of tuples to unzip\n   * @returns Tuple of arrays\n   *\n   * @example\n   * ```typescript\n   * const [nums, chars] = await threadts.unzip([[1, 'a'], [2, 'b'], [3, 'c']]);\n   * console.log(nums); // [1, 2, 3]\n   * console.log(chars); // ['a', 'b', 'c']\n   * ```\n   */\n  async function unzip<T extends unknown[]>(\n    array: T[]\n  ): Promise<{ [K in keyof T]: T[K][] }> {\n    if (array.length === 0) {\n      return [] as unknown as { [K in keyof T]: T[K][] };\n    }\n\n    const tupleLength = array[0].length;\n    const result: unknown[][] = Array.from({ length: tupleLength }, () => []);\n\n    for (const tuple of array) {\n      for (let i = 0; i < tupleLength; i++) {\n        result[i].push(tuple[i]);\n      }\n    }\n\n    return result as { [K in keyof T]: T[K][] };\n  }\n\n  /**\n   * Removes duplicate values from an array.\n   * Uses strict equality for comparison.\n   *\n   * @template T - The type of array elements\n   * @param array - The array to deduplicate\n   * @returns Array with unique values\n   *\n   * @example\n   * ```typescript\n   * const unique = await threadts.unique([1, 2, 2, 3, 3, 3]);\n   * console.log(unique); // [1, 2, 3]\n   * ```\n   */\n  async function unique<T>(array: T[]): Promise<T[]> {\n    return [...new Set(array)];\n  }\n\n  /**\n   * Removes duplicate values using a key function.\n   *\n   * @template T - The type of array elements\n   * @template K - The type of the key\n   * @param array - The array to deduplicate\n   * @param keyFn - Function to extract the key for comparison\n   * @returns Array with unique values by key\n   *\n   * @example\n   * ```typescript\n   * const users = [{ id: 1, name: 'a' }, { id: 2, name: 'b' }, { id: 1, name: 'c' }];\n   * const unique = await threadts.uniqueBy(users, u => u.id);\n   * console.log(unique); // [{ id: 1, name: 'a' }, { id: 2, name: 'b' }]\n   * ```\n   */\n  async function uniqueBy<T, K>(\n    array: T[],\n    keyFn: (item: T) => K\n  ): Promise<T[]> {\n    const seen = new Set<K>();\n    const result: T[] = [];\n\n    for (const item of array) {\n      const key = keyFn(item);\n      if (!seen.has(key)) {\n        seen.add(key);\n        result.push(item);\n      }\n    }\n\n    return result;\n  }\n\n  /**\n   * Flattens a nested array to a specified depth.\n   *\n   * @template T - The type of array elements\n   * @param array - The nested array to flatten\n   * @param depth - How deep to flatten (default: 1)\n   * @returns Flattened array\n   *\n   * @example\n   * ```typescript\n   * const flat = await threadts.flat([[1, 2], [3, [4, 5]]], 2);\n   * console.log(flat); // [1, 2, 3, 4, 5]\n   * ```\n   */\n  async function flat<T>(array: T[], depth = 1): Promise<unknown[]> {\n    return array.flat(depth);\n  }\n\n  /**\n   * Splits an array into chunks of the specified size.\n   *\n   * @template T - The type of array elements\n   * @param array - The array to chunk\n   * @param size - Size of each chunk\n   * @returns Array of chunks\n   *\n   * @example\n   * ```typescript\n   * const chunks = await threadts.chunk([1, 2, 3, 4, 5], 2);\n   * console.log(chunks); // [[1, 2], [3, 4], [5]]\n   * ```\n   */\n  async function chunk<T>(array: T[], size: number): Promise<T[][]> {\n    if (size <= 0) {\n      return [];\n    }\n\n    const result: T[][] = [];\n    for (let i = 0; i < array.length; i += size) {\n      result.push(array.slice(i, i + size));\n    }\n    return result;\n  }\n\n  // ==================== ES2023+ Array Methods ====================\n\n  /**\n   * Finds the last element that satisfies the predicate.\n   * Similar to Array.prototype.findLast (ES2023).\n   *\n   * @template T - The type of array elements\n   * @param array - The array to search\n   * @param predicate - Function to test each element\n   * @returns The last matching element or undefined\n   *\n   * @example\n   * ```typescript\n   * const last = await threadts.findLast([1, 2, 3, 4, 5], x => x < 4);\n   * console.log(last); // 3\n   * ```\n   */\n  async function findLast<T>(\n    array: T[],\n    predicate: (value: T, index: number, array: T[]) => boolean\n  ): Promise<T | undefined> {\n    for (let i = array.length - 1; i >= 0; i--) {\n      if (predicate(array[i], i, array)) {\n        return array[i];\n      }\n    }\n    return undefined;\n  }\n\n  /**\n   * Finds the index of the last element that satisfies the predicate.\n   * Similar to Array.prototype.findLastIndex (ES2023).\n   *\n   * @template T - The type of array elements\n   * @param array - The array to search\n   * @param predicate - Function to test each element\n   * @returns The index of the last matching element or -1\n   *\n   * @example\n   * ```typescript\n   * const index = await threadts.findLastIndex([1, 2, 3, 2, 1], x => x === 2);\n   * console.log(index); // 3\n   * ```\n   */\n  async function findLastIndex<T>(\n    array: T[],\n    predicate: (value: T, index: number, array: T[]) => boolean\n  ): Promise<number> {\n    for (let i = array.length - 1; i >= 0; i--) {\n      if (predicate(array[i], i, array)) {\n        return i;\n      }\n    }\n    return -1;\n  }\n\n  /**\n   * Returns a new sorted array (immutable).\n   * Similar to Array.prototype.toSorted (ES2023).\n   *\n   * @template T - The type of array elements\n   * @param array - The array to sort\n   * @param compareFn - Optional comparison function\n   * @returns A new sorted array\n   *\n   * @example\n   * ```typescript\n   * const sorted = await threadts.toSorted([3, 1, 2]);\n   * console.log(sorted); // [1, 2, 3]\n   * ```\n   */\n  async function toSorted<T>(\n    array: T[],\n    compareFn?: (a: T, b: T) => number\n  ): Promise<T[]> {\n    return [...array].sort(compareFn);\n  }\n\n  /**\n   * Returns a new reversed array (immutable).\n   * Similar to Array.prototype.toReversed (ES2023).\n   *\n   * @template T - The type of array elements\n   * @param array - The array to reverse\n   * @returns A new reversed array\n   *\n   * @example\n   * ```typescript\n   * const reversed = await threadts.toReversed([1, 2, 3]);\n   * console.log(reversed); // [3, 2, 1]\n   * ```\n   */\n  async function toReversed<T>(array: T[]): Promise<T[]> {\n    return [...array].reverse();\n  }\n\n  /**\n   * Returns a new array with the element at the given index replaced.\n   * Similar to Array.prototype.with (ES2023).\n   *\n   * @template T - The type of array elements\n   * @param array - The array to modify\n   * @param index - The index to replace (supports negative indices)\n   * @param value - The new value\n   * @returns A new array with the replaced element\n   *\n   * @example\n   * ```typescript\n   * const modified = await threadts.withElement([1, 2, 3], 1, 10);\n   * console.log(modified); // [1, 10, 3]\n   * ```\n   */\n  async function withElement<T>(\n    array: T[],\n    index: number,\n    value: T\n  ): Promise<T[]> {\n    const normalizedIndex = index < 0 ? array.length + index : index;\n\n    if (normalizedIndex < 0 || normalizedIndex >= array.length) {\n      throw new RangeError(`Invalid index: ${index}`);\n    }\n\n    const result = [...array];\n    result[normalizedIndex] = value;\n    return result;\n  }\n\n  /**\n   * Returns a new array with elements removed/replaced/added at a given index.\n   * Similar to Array.prototype.toSpliced (ES2023).\n   *\n   * @template T - The type of array elements\n   * @param array - The array to modify\n   * @param start - The index at which to start changing the array\n   * @param deleteCount - The number of elements to remove\n   * @param items - The elements to add\n   * @returns A new spliced array\n   *\n   * @example\n   * ```typescript\n   * const spliced = await threadts.toSpliced([1, 2, 3, 4], 1, 2, 'a', 'b');\n   * console.log(spliced); // [1, 'a', 'b', 4]\n   * ```\n   */\n  async function toSpliced<T>(\n    array: T[],\n    start: number,\n    deleteCount?: number,\n    ...items: T[]\n  ): Promise<T[]> {\n    const result = [...array];\n    if (deleteCount === undefined) {\n      result.splice(start);\n    } else {\n      result.splice(start, deleteCount, ...items);\n    }\n    return result;\n  }\n\n  /**\n   * Groups elements of an array based on a callback function.\n   * Similar to Object.groupBy (ES2024).\n   *\n   * @template T - The type of array elements\n   * @template K - The type of the group key\n   * @param array - The array to group\n   * @param keyFn - Function that returns the group key for each element\n   * @returns An object with grouped elements\n   *\n   * @example\n   * ```typescript\n   * const grouped = await threadts.groupByObject(\n   *   [{ type: 'a', v: 1 }, { type: 'b', v: 2 }, { type: 'a', v: 3 }],\n   *   item => item.type\n   * );\n   * // { a: [{type: 'a', v: 1}, {type: 'a', v: 3}], b: [{type: 'b', v: 2}] }\n   * ```\n   */\n  async function groupByObject<T, K extends PropertyKey>(\n    array: T[],\n    keyFn: (item: T, index: number) => K\n  ): Promise<Partial<Record<K, T[]>>> {\n    const result: Partial<Record<K, T[]>> = {};\n\n    for (let i = 0; i < array.length; i++) {\n      const key = keyFn(array[i], i);\n      if (!result[key]) {\n        result[key] = [];\n      }\n      result[key]!.push(array[i]);\n    }\n\n    return result;\n  }\n\n  return {\n    indexOf,\n    lastIndexOf,\n    at,\n    slice,\n    concat,\n    fill,\n    includes,\n    join,\n    reverse,\n    sort,\n    range,\n    repeat,\n    zip,\n    unzip,\n    unique,\n    uniqueBy,\n    flat,\n    chunk,\n    // ES2023+ methods\n    findLast,\n    findLastIndex,\n    toSorted,\n    toReversed,\n    withElement,\n    toSpliced,\n    groupByObject,\n  };\n}\n\n/**\n * Type for the array operations object returned by createArrayOperations.\n */\nexport type ArrayOperations = ReturnType<typeof createArrayOperations>;\n","/**\n * ThreadTS Universal - Array Helper Utilities\n *\n * Shared array operations reused in multiple places in the library.\n * Follows the DRY principle (Don't Repeat Yourself).\n *\n * @module utils/array-helpers\n * @author ThreadTS Universal Team\n */\n\n/**\n * Fisher-Yates (Knuth) shuffle algorithm.\n *\n * Shuffles an array in-place with a uniform random distribution.\n * Time complexity: O(n), space complexity: O(1)\n *\n * @template T - Array element type\n * @param array - Array to shuffle (mutated)\n * @returns The same array, shuffled\n *\n * @example\n * ```typescript\n * const arr = [1, 2, 3, 4, 5];\n * fisherYatesShuffle(arr);\n * console.log(arr); // e.g. [3, 1, 5, 2, 4]\n * ```\n */\nexport function fisherYatesShuffle<T>(array: T[]): T[] {\n  for (let i = array.length - 1; i > 0; i--) {\n    const j = Math.floor(Math.random() * (i + 1));\n    [array[i], array[j]] = [array[j], array[i]];\n  }\n  return array;\n}\n\n/**\n * Creates a shuffled copy of an array.\n *\n * Unlike {@link fisherYatesShuffle}, this function does not mutate the\n * original array.\n *\n * @template T - Array element type\n * @param array - Array to shuffle (not mutated)\n * @returns A new, shuffled array\n *\n * @example\n * ```typescript\n * const arr = [1, 2, 3, 4, 5];\n * const shuffled = shuffleCopy(arr);\n * console.log(arr);      // [1, 2, 3, 4, 5] - unchanged\n * console.log(shuffled); // e.g. [3, 1, 5, 2, 4]\n * ```\n */\nexport function shuffleCopy<T>(array: T[]): T[] {\n  return fisherYatesShuffle([...array]);\n}\n\n/**\n * Takes a random sample of n elements from an array.\n *\n * Uses Fisher-Yates shuffle for efficient random selection.\n * Returns at most array.length elements.\n *\n * @template T - Array element type\n * @param array - Array to sample from\n * @param count - Number of elements to sample\n * @returns Array of randomly selected elements\n *\n * @example\n * ```typescript\n * const arr = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];\n * const sample = randomSample(arr, 3);\n * console.log(sample); // e.g. [7, 2, 9]\n * ```\n */\nexport function randomSample<T>(array: T[], count: number): T[] {\n  const sampleSize = Math.min(Math.max(0, count), array.length);\n  if (sampleSize === 0) {\n    return [];\n  }\n  return shuffleCopy(array).slice(0, sampleSize);\n}\n\n/**\n * Splits an array into chunks (sub-arrays) of a given size.\n *\n * @template T - Array element type\n * @param array - Array to split\n * @param size - Size of each chunk (must be > 0)\n * @returns Array of chunks\n *\n * @example\n * ```typescript\n * const arr = [1, 2, 3, 4, 5];\n * const chunks = chunkArray(arr, 2);\n * console.log(chunks); // [[1, 2], [3, 4], [5]]\n * ```\n */\nexport function chunkArray<T>(array: T[], size: number): T[][] {\n  if (size <= 0) {\n    return [];\n  }\n  const result: T[][] = [];\n  for (let i = 0; i < array.length; i += size) {\n    result.push(array.slice(i, i + size));\n  }\n  return result;\n}\n\n/**\n * Creates sliding windows over an array.\n *\n * @template T - Array element type\n * @param array - Array to create windows over\n * @param size - Window size\n * @param step - Step between windows (default: 1)\n * @returns Array of windows\n *\n * @example\n * ```typescript\n * const arr = [1, 2, 3, 4, 5];\n * const windows = slidingWindow(arr, 3);\n * console.log(windows); // [[1, 2, 3], [2, 3, 4], [3, 4, 5]]\n *\n * const steppedWindows = slidingWindow(arr, 2, 2);\n * console.log(steppedWindows); // [[1, 2], [3, 4]]\n * ```\n */\nexport function slidingWindow<T>(array: T[], size: number, step = 1): T[][] {\n  if (size <= 0 || step <= 0 || array.length < size) {\n    return size <= 0 || step <= 0 ? [] : [];\n  }\n  const result: T[][] = [];\n  for (let i = 0; i <= array.length - size; i += step) {\n    result.push(array.slice(i, i + size));\n  }\n  return result;\n}\n\n/**\n * Interleaves two arrays.\n *\n * @template T - Array element type\n * @param array1 - First array\n * @param array2 - Second array\n * @returns Interleaved array\n *\n * @example\n * ```typescript\n * const a = [1, 3, 5];\n * const b = [2, 4, 6];\n * console.log(interleaveArrays(a, b)); // [1, 2, 3, 4, 5, 6]\n * ```\n */\nexport function interleaveArrays<T>(array1: T[], array2: T[]): T[] {\n  const result: T[] = [];\n  const maxLen = Math.max(array1.length, array2.length);\n  for (let i = 0; i < maxLen; i++) {\n    if (i < array1.length) result.push(array1[i]);\n    if (i < array2.length) result.push(array2[i]);\n  }\n  return result;\n}\n\n/**\n * Rotates an array by n positions.\n *\n * Positive n rotates right (end -> start),\n * negative n rotates left (start -> end).\n *\n * @template T - Array element type\n * @param array - Array to rotate\n * @param positions - Positions to rotate (positive = right, negative = left)\n * @returns New rotated array\n *\n * @example\n * ```typescript\n * const arr = [1, 2, 3, 4, 5];\n * console.log(rotateArray(arr, 2));  // [4, 5, 1, 2, 3]\n * console.log(rotateArray(arr, -2)); // [3, 4, 5, 1, 2]\n * ```\n */\nexport function rotateArray<T>(array: T[], positions: number): T[] {\n  if (array.length === 0 || positions === 0) {\n    return [...array];\n  }\n  const n = ((positions % array.length) + array.length) % array.length;\n  return [...array.slice(-n), ...array.slice(0, -n)];\n}\n\n/**\n * Finds unique elements based on a key function.\n *\n * @template T - Array element type\n * @template K - Key type\n * @param array - Array to scan\n * @param keyFn - Function that extracts the comparison key\n * @returns Array of unique elements (keeps the first occurrence)\n *\n * @example\n * ```typescript\n * const users = [\n *   { id: 1, name: 'Alice' },\n *   { id: 2, name: 'Bob' },\n *   { id: 1, name: 'Alice Clone' }\n * ];\n * const unique = uniqueBy(users, u => u.id);\n * // [{ id: 1, name: 'Alice' }, { id: 2, name: 'Bob' }]\n * ```\n */\nexport function uniqueBy<T, K>(array: T[], keyFn: (item: T) => K): T[] {\n  const seen = new Set<K>();\n  const result: T[] = [];\n  for (const item of array) {\n    const key = keyFn(item);\n    if (!seen.has(key)) {\n      seen.add(key);\n      result.push(item);\n    }\n  }\n  return result;\n}\n\n/**\n * Finds unique elements using JSON stringification as the key.\n *\n * @template T - Array element type\n * @param array - Array to scan\n * @param keyFn - Optional function to extract the value to stringify\n * @returns Array of unique elements\n */\nexport function uniqueByJson<T>(array: T[], keyFn?: (item: T) => unknown): T[] {\n  const seen = new Set<string>();\n  const result: T[] = [];\n  for (const item of array) {\n    const key = JSON.stringify(keyFn ? keyFn(item) : item);\n    if (!seen.has(key)) {\n      seen.add(key);\n      result.push(item);\n    }\n  }\n  return result;\n}\n","/**\n * ThreadTS Universal - Pipeline Operations Module\n *\n * Shared operation execution logic for Pipeline and TerminalPipeline classes.\n * Extracts common functionality to follow DRY principles.\n *\n * @module core/pipeline-operations\n * @author ThreadTS Universal Team\n */\n\nimport type { MapOptions, SerializableFunction, ThreadOptions } from '../types';\nimport {\n  chunkArray,\n  interleaveArrays,\n  randomSample,\n  rotateArray,\n  shuffleCopy,\n  slidingWindow,\n  uniqueBy,\n  uniqueByJson,\n} from '../utils/array-helpers';\nimport type { ThreadTS } from './threadts';\n\n/**\n * Pipeline operation definition for lazy evaluation.\n */\nexport interface PipelineOperation {\n  type: string;\n  fn?: SerializableFunction;\n  options?: MapOptions | ThreadOptions;\n  initialValue?: unknown;\n  count?: number;\n  /** Step for window operations */\n  step?: number;\n}\n\n/**\n * List of terminal operation types\n */\nexport const TERMINAL_OPERATIONS = [\n  'reduce',\n  'forEach',\n  'find',\n  'findIndex',\n  'findLast',\n  'findLastIndex',\n  'some',\n  'every',\n  'count',\n  'groupBy',\n  'partition',\n  'first',\n  'last',\n  'isEmpty',\n  'sum',\n  'average',\n  'min',\n  'max',\n  'join',\n  'includes',\n] as const;\n\nexport type TerminalOperationType = (typeof TERMINAL_OPERATIONS)[number];\n\n/**\n * Check if an operation type is a terminal operation.\n */\nexport function isTerminalOperation(type: string): boolean {\n  return TERMINAL_OPERATIONS.includes(type as TerminalOperationType);\n}\n\n/**\n * Executes an intermediate pipeline operation.\n * Shared between Pipeline and TerminalPipeline to avoid code duplication.\n *\n * @param data - Current pipeline data\n * @param op - Operation to execute\n * @param threadts - ThreadTS instance for parallel operations\n * @returns Transformed data array\n */\nexport async function executeIntermediateOperation(\n  data: unknown[],\n  op: PipelineOperation,\n  threadts: ThreadTS\n): Promise<unknown[]> {\n  switch (op.type) {\n    case 'map':\n      return threadts.map(data, op.fn!, op.options as MapOptions);\n\n    case 'filter':\n      return threadts.filter(data, op.fn!, op.options as MapOptions);\n\n    case 'flatMap':\n      return threadts.flatMap(data, op.fn!, op.options as MapOptions);\n\n    case 'take':\n      return data.slice(0, op.count ?? 0);\n\n    case 'skip':\n      return data.slice(op.count ?? 0);\n\n    case 'chunk': {\n      const chunkSize = op.count ?? 1;\n      return chunkArray(data, chunkSize);\n    }\n\n    case 'tap':\n    case 'peek': {\n      // Execute side-effect function without modifying data.\n      // 'peek' is an alias for 'tap' - both are used for debugging/logging.\n      if (op.fn) {\n        for (const item of data) {\n          op.fn(item);\n        }\n      }\n      return data;\n    }\n\n    case 'window': {\n      const windowSize = op.count ?? 1;\n      const step = op.step ?? 1;\n      return slidingWindow(data, windowSize, step);\n    }\n\n    case 'unique': {\n      // Uses JSON stringification for comparison (deep equality)\n      return uniqueByJson(\n        data,\n        op.fn as ((item: unknown) => unknown) | undefined\n      );\n    }\n\n    case 'distinct': {\n      // Uses strict equality or a custom key function\n      // Unlike 'unique', no JSON serialization is used here\n      if (op.fn) {\n        return uniqueBy(data, op.fn as (item: unknown) => unknown);\n      }\n      // Without a key function: use Set for primitive values\n      return [...new Set(data)];\n    }\n\n    case 'reverse':\n      return [...data].reverse();\n\n    case 'sort':\n      return [...data].sort(\n        op.fn as ((a: unknown, b: unknown) => number) | undefined\n      );\n\n    case 'zip': {\n      // Zip with another array stored in initialValue\n      const other = op.initialValue as unknown[];\n      if (!Array.isArray(other)) return data;\n      const zipped: unknown[][] = [];\n      const maxLen = Math.min(data.length, other.length);\n      for (let i = 0; i < maxLen; i++) {\n        zipped.push([data[i], other[i]]);\n      }\n      return zipped;\n    }\n\n    case 'zipWith': {\n      // Zip with a combiner function\n      const other = op.initialValue as unknown[];\n      if (!Array.isArray(other) || !op.fn) return data;\n      const zippedWith: unknown[] = [];\n      const maxLen = Math.min(data.length, other.length);\n      for (let i = 0; i < maxLen; i++) {\n        zippedWith.push(op.fn(data[i], other[i], i));\n      }\n      return zippedWith;\n    }\n\n    case 'interleave': {\n      // Interleave with another array\n      const other = op.initialValue as unknown[];\n      if (!Array.isArray(other)) return data;\n      return interleaveArrays(data, other);\n    }\n\n    case 'compact': {\n      // Remove null, undefined, and optionally falsy values\n      return data.filter((item) => {\n        if (op.fn) {\n          return op.fn(item);\n        }\n        return item != null;\n      });\n    }\n\n    case 'flatten': {\n      // Flatten nested arrays to specified depth\n      const depth = op.count ?? 1;\n      return data.flat(depth);\n    }\n\n    case 'shuffle': {\n      // Fisher-Yates shuffle - uses utility function\n      return shuffleCopy(data);\n    }\n\n    case 'sample': {\n      // Random sample of n elements - uses utility function\n      return randomSample(data, op.count ?? 1);\n    }\n\n    case 'dropWhile': {\n      // Drop elements while predicate is true\n      if (!op.fn) return data;\n      let dropIndex = 0;\n      for (let i = 0; i < data.length; i++) {\n        if (!op.fn(data[i], i, data)) {\n          dropIndex = i;\n          break;\n        }\n        if (i === data.length - 1) {\n          return [];\n        }\n      }\n      return data.slice(dropIndex);\n    }\n\n    case 'takeWhile': {\n      // Take elements while predicate is true\n      if (!op.fn) return data;\n      const result: unknown[] = [];\n      for (let i = 0; i < data.length; i++) {\n        if (op.fn(data[i], i, data)) {\n          result.push(data[i]);\n        } else {\n          break;\n        }\n      }\n      return result;\n    }\n\n    case 'slice': {\n      // Slice from start to end (stored in count and step)\n      const start = op.count ?? 0;\n      const end = op.step;\n      return data.slice(start, end);\n    }\n\n    case 'concat': {\n      // Concatenate with another array\n      const other = op.initialValue as unknown[];\n      if (!Array.isArray(other)) return data;\n      return [...data, ...other];\n    }\n\n    case 'rotate': {\n      // Rotate array by n positions - uses utility function\n      return rotateArray(data, op.count ?? 0);\n    }\n\n    case 'truthy': {\n      // Keep only truthy values\n      return data.filter(Boolean);\n    }\n\n    case 'falsy': {\n      // Keep only falsy values\n      return data.filter((item) => !item);\n    }\n\n    default:\n      return data;\n  }\n}\n\n/**\n * Executes a terminal pipeline operation.\n * Shared between Pipeline and TerminalPipeline to avoid code duplication.\n *\n * @param data - Current pipeline data\n * @param op - Operation to execute\n * @param threadts - ThreadTS instance for parallel operations\n * @returns Final result value\n */\nexport async function executeTerminalOperation<R>(\n  data: unknown[],\n  op: PipelineOperation,\n  threadts: ThreadTS\n): Promise<R> {\n  switch (op.type) {\n    case 'reduce':\n      return threadts.reduce(\n        data,\n        op.fn!,\n        op.initialValue as R,\n        op.options as ThreadOptions\n      );\n\n    case 'forEach':\n      await threadts.forEach(data, op.fn!, op.options as MapOptions);\n      return undefined as R;\n\n    case 'find':\n      return threadts.find(\n        data,\n        op.fn!,\n        op.options as MapOptions\n      ) as Promise<R>;\n\n    case 'findIndex':\n      return threadts.findIndex(\n        data,\n        op.fn!,\n        op.options as MapOptions\n      ) as Promise<R>;\n\n    case 'findLast': {\n      // Find last element matching predicate\n      if (!op.fn) return undefined as R;\n      for (let i = data.length - 1; i >= 0; i--) {\n        if (op.fn(data[i], i, data)) {\n          return data[i] as R;\n        }\n      }\n      return undefined as R;\n    }\n\n    case 'findLastIndex': {\n      // Find last index matching predicate\n      if (!op.fn) return -1 as R;\n      for (let i = data.length - 1; i >= 0; i--) {\n        if (op.fn(data[i], i, data)) {\n          return i as R;\n        }\n      }\n      return -1 as R;\n    }\n\n    case 'some':\n      return threadts.some(\n        data,\n        op.fn!,\n        op.options as MapOptions\n      ) as Promise<R>;\n\n    case 'every':\n      return threadts.every(\n        data,\n        op.fn!,\n        op.options as MapOptions\n      ) as Promise<R>;\n\n    case 'count':\n      return threadts.count(\n        data,\n        op.fn!,\n        op.options as MapOptions\n      ) as Promise<R>;\n\n    case 'groupBy':\n      return threadts.groupBy(\n        data,\n        op.fn!,\n        op.options as MapOptions\n      ) as Promise<R>;\n\n    case 'partition':\n      return threadts.partition(\n        data,\n        op.fn!,\n        op.options as MapOptions\n      ) as Promise<R>;\n\n    case 'first':\n      return (data.length > 0 ? data[0] : undefined) as R;\n\n    case 'last':\n      return (data.length > 0 ? data[data.length - 1] : undefined) as R;\n\n    case 'isEmpty':\n      return (data.length === 0) as R;\n\n    case 'sum':\n      return data.reduce(\n        (acc: number, val) => acc + (typeof val === 'number' ? val : 0),\n        0\n      ) as R;\n\n    case 'average': {\n      if (data.length === 0) return NaN as R;\n      const sumValue = data.reduce(\n        (acc: number, val) => acc + (typeof val === 'number' ? val : 0),\n        0\n      );\n      return (sumValue / data.length) as R;\n    }\n\n    case 'min': {\n      if (data.length === 0) return undefined as R;\n      const minCompareFn = op.fn as\n        ((a: unknown, b: unknown) => number) | undefined;\n      return [...data].sort(\n        minCompareFn ??\n          ((a, b) => {\n            if (a === b) return 0;\n            return (a as number) < (b as number) ? -1 : 1;\n          })\n      )[0] as R;\n    }\n\n    case 'max': {\n      if (data.length === 0) return undefined as R;\n      const maxCompareFn = op.fn as\n        ((a: unknown, b: unknown) => number) | undefined;\n      return [...data].sort(\n        maxCompareFn ??\n          ((a, b) => {\n            if (a === b) return 0;\n            return (a as number) > (b as number) ? -1 : 1;\n          })\n      )[0] as R;\n    }\n\n    case 'join': {\n      const separator = (op.initialValue as string) ?? ',';\n      return data.join(separator) as R;\n    }\n\n    case 'includes': {\n      const searchValue = op.initialValue;\n      return data.includes(searchValue) as R;\n    }\n\n    default:\n      return data as R;\n  }\n}\n","/**\n * ThreadTS Universal - Pipeline Module\n *\n * Provides fluent chaining of parallel operations with lazy evaluation.\n * Operations are only executed when execute() is called.\n *\n * @module core/pipeline\n */\n\nimport type { MapOptions, SerializableFunction, ThreadOptions } from '../types';\nimport {\n  executeIntermediateOperation,\n  executeTerminalOperation,\n  isTerminalOperation,\n  type PipelineOperation,\n} from './pipeline-operations';\nimport type { ThreadTS } from './threadts';\n\n// Re-export PipelineOperation for backward compatibility\nexport type { PipelineOperation };\n\n/**\n * Pipeline class for fluent chaining of parallel operations.\n * Supports lazy evaluation - operations are only executed when execute() is called.\n *\n * @template T - The current type of array elements\n *\n * @example\n * ```typescript\n * const result = await ThreadTS.pipe([1, 2, 3, 4, 5])\n *   .map(x => x * 2)\n *   .filter(x => x > 4)\n *   .reduce((acc, x) => acc + x, 0)\n *   .execute();\n * ```\n */\nexport class Pipeline<T> {\n  protected operations: PipelineOperation[] = [];\n\n  constructor(\n    protected array: T[],\n    protected threadts: ThreadTS\n  ) {}\n\n  /**\n   * Adds a map operation to the pipeline.\n   */\n  map<R>(fn: SerializableFunction, options?: MapOptions): Pipeline<R> {\n    this.operations.push({ type: 'map', fn, options });\n    return this as unknown as Pipeline<R>;\n  }\n\n  /**\n   * Adds a filter operation to the pipeline.\n   */\n  filter(fn: SerializableFunction, options?: MapOptions): Pipeline<T> {\n    this.operations.push({ type: 'filter', fn, options });\n    return this;\n  }\n\n  /**\n   * Adds a flatMap operation to the pipeline.\n   */\n  flatMap<R>(fn: SerializableFunction, options?: MapOptions): Pipeline<R> {\n    this.operations.push({ type: 'flatMap', fn, options });\n    return this as unknown as Pipeline<R>;\n  }\n\n  /**\n   * Takes the first n elements from the pipeline.\n   * This is a synchronous operation that limits results.\n   *\n   * @param count - Number of elements to take\n   * @returns Pipeline with limited elements\n   *\n   * @example\n   * ```typescript\n   * const first3 = await ThreadTS.pipe([1, 2, 3, 4, 5])\n   *   .take(3)\n   *   .execute();\n   * // Result: [1, 2, 3]\n   * ```\n   */\n  take(count: number): Pipeline<T> {\n    this.operations.push({\n      type: 'take',\n      count: Math.max(0, Math.floor(count)),\n    });\n    return this;\n  }\n\n  /**\n   * Skips the first n elements from the pipeline.\n   * This is a synchronous operation that offsets results.\n   *\n   * @param count - Number of elements to skip\n   * @returns Pipeline with offset elements\n   *\n   * @example\n   * ```typescript\n   * const afterFirst2 = await ThreadTS.pipe([1, 2, 3, 4, 5])\n   *   .skip(2)\n   *   .execute();\n   * // Result: [3, 4, 5]\n   * ```\n   */\n  skip(count: number): Pipeline<T> {\n    this.operations.push({\n      type: 'skip',\n      count: Math.max(0, Math.floor(count)),\n    });\n    return this;\n  }\n\n  /**\n   * Splits the array into chunks of the specified size.\n   * Returns a pipeline of arrays.\n   *\n   * @param size - Size of each chunk\n   * @returns Pipeline with chunked arrays\n   *\n   * @example\n   * ```typescript\n   * const chunks = await ThreadTS.pipe([1, 2, 3, 4, 5])\n   *   .chunk(2)\n   *   .execute();\n   * // Result: [[1, 2], [3, 4], [5]]\n   * ```\n   */\n  chunk(size: number): Pipeline<T[]> {\n    this.operations.push({\n      type: 'chunk',\n      count: Math.max(1, Math.floor(size)),\n    });\n    return this as unknown as Pipeline<T[]>;\n  }\n\n  /**\n   * Executes a side-effect function for each element without modifying the pipeline.\n   * Useful for debugging, logging, or triggering side effects.\n   *\n   * @param fn - Function to execute for each element (return value is ignored)\n   * @returns Pipeline unchanged\n   *\n   * @example\n   * ```typescript\n   * const result = await ThreadTS.pipe([1, 2, 3])\n   *   .tap(x => console.log('Processing:', x))\n   *   .map(x => x * 2)\n   *   .execute();\n   * // Logs: Processing: 1, Processing: 2, Processing: 3\n   * // Result: [2, 4, 6]\n   * ```\n   */\n  tap(fn: SerializableFunction): Pipeline<T> {\n    this.operations.push({ type: 'tap', fn });\n    return this;\n  }\n\n  /**\n   * Creates sliding windows of elements.\n   * Each window contains `size` consecutive elements.\n   *\n   * @param size - Size of each window\n   * @param step - Number of elements to slide (default: 1)\n   * @returns Pipeline with arrays of windowed elements\n   *\n   * @example\n   * ```typescript\n   * const windows = await ThreadTS.pipe([1, 2, 3, 4, 5])\n   *   .window(3)\n   *   .execute();\n   * // Result: [[1, 2, 3], [2, 3, 4], [3, 4, 5]]\n   * ```\n   */\n  window(size: number, step: number = 1): Pipeline<T[]> {\n    this.operations.push({\n      type: 'window',\n      count: Math.max(1, Math.floor(size)),\n      step: Math.max(1, Math.floor(step)),\n    });\n    return this as unknown as Pipeline<T[]>;\n  }\n\n  /**\n   * Removes duplicate elements from the pipeline.\n   * Uses JSON.stringify for comparison by default.\n   *\n   * @param keyFn - Optional function to extract comparison key\n   * @returns Pipeline with unique elements\n   *\n   * @example\n   * ```typescript\n   * const unique = await ThreadTS.pipe([1, 2, 2, 3, 3, 3])\n   *   .unique()\n   *   .execute();\n   * // Result: [1, 2, 3]\n   * ```\n   */\n  unique(keyFn?: SerializableFunction): Pipeline<T> {\n    this.operations.push({ type: 'unique', fn: keyFn });\n    return this;\n  }\n\n  /**\n   * Removes duplicate elements using strict equality or a key function.\n   * Similar to unique but uses Set-based comparison for primitives.\n   *\n   * @param keyFn - Optional function to extract comparison key\n   * @returns Pipeline with distinct elements\n   */\n  distinct(keyFn?: SerializableFunction): Pipeline<T> {\n    this.operations.push({ type: 'distinct', fn: keyFn });\n    return this;\n  }\n\n  /**\n   * Reverses the order of elements in the pipeline.\n   *\n   * @returns Pipeline with reversed elements\n   *\n   * @example\n   * ```typescript\n   * const reversed = await ThreadTS.pipe([1, 2, 3])\n   *   .reverse()\n   *   .execute();\n   * // Result: [3, 2, 1]\n   * ```\n   */\n  reverse(): Pipeline<T> {\n    this.operations.push({ type: 'reverse' });\n    return this;\n  }\n\n  /**\n   * Sorts elements in the pipeline.\n   *\n   * @param compareFn - Optional comparison function\n   * @returns Pipeline with sorted elements\n   *\n   * @example\n   * ```typescript\n   * const sorted = await ThreadTS.pipe([3, 1, 2])\n   *   .sort((a, b) => a - b)\n   *   .execute();\n   * // Result: [1, 2, 3]\n   * ```\n   */\n  sort(compareFn?: SerializableFunction): Pipeline<T> {\n    this.operations.push({ type: 'sort', fn: compareFn });\n    return this;\n  }\n\n  /**\n   * Zips this pipeline with another array, creating pairs.\n   *\n   * @param other - Array to zip with\n   * @returns Pipeline of tuples [thisElement, otherElement]\n   *\n   * @example\n   * ```typescript\n   * const zipped = await ThreadTS.pipe([1, 2, 3])\n   *   .zip(['a', 'b', 'c'])\n   *   .execute();\n   * // Result: [[1, 'a'], [2, 'b'], [3, 'c']]\n   * ```\n   */\n  zip<U>(other: U[]): Pipeline<[T, U]> {\n    this.operations.push({ type: 'zip', initialValue: other });\n    return this as unknown as Pipeline<[T, U]>;\n  }\n\n  /**\n   * Zips this pipeline with another array using a combiner function.\n   *\n   * @param other - Array to zip with\n   * @param fn - Function to combine elements: (thisEl, otherEl, index) => result\n   * @returns Pipeline of combined results\n   *\n   * @example\n   * ```typescript\n   * const zipped = await ThreadTS.pipe([1, 2, 3])\n   *   .zipWith([10, 20, 30], (a, b) => a + b)\n   *   .execute();\n   * // Result: [11, 22, 33]\n   * ```\n   */\n  zipWith<U, R>(other: U[], fn: SerializableFunction): Pipeline<R> {\n    this.operations.push({ type: 'zipWith', initialValue: other, fn });\n    return this as unknown as Pipeline<R>;\n  }\n\n  /**\n   * Interleaves this pipeline's elements with another array.\n   *\n   * @param other - Array to interleave with\n   * @returns Pipeline with interleaved elements\n   *\n   * @example\n   * ```typescript\n   * const interleaved = await ThreadTS.pipe([1, 3, 5])\n   *   .interleave([2, 4, 6])\n   *   .execute();\n   * // Result: [1, 2, 3, 4, 5, 6]\n   * ```\n   */\n  interleave(other: T[]): Pipeline<T> {\n    this.operations.push({ type: 'interleave', initialValue: other });\n    return this;\n  }\n\n  /**\n   * Removes null and undefined values from the pipeline.\n   *\n   * @param predicate - Optional custom filter function\n   * @returns Pipeline without null/undefined values\n   *\n   * @example\n   * ```typescript\n   * const compacted = await ThreadTS.pipe([1, null, 2, undefined, 3])\n   *   .compact()\n   *   .execute();\n   * // Result: [1, 2, 3]\n   * ```\n   */\n  compact(predicate?: SerializableFunction): Pipeline<NonNullable<T>> {\n    this.operations.push({ type: 'compact', fn: predicate });\n    return this as unknown as Pipeline<NonNullable<T>>;\n  }\n\n  /**\n   * Flattens nested arrays to the specified depth.\n   *\n   * @param depth - Depth to flatten (default: 1)\n   * @returns Pipeline with flattened arrays\n   *\n   * @example\n   * ```typescript\n   * const flat = await ThreadTS.pipe([[1, 2], [3, [4, 5]]])\n   *   .flatten(2)\n   *   .execute();\n   * // Result: [1, 2, 3, 4, 5]\n   * ```\n   */\n  flatten(depth: number = 1): Pipeline<unknown> {\n    this.operations.push({ type: 'flatten', count: depth });\n    return this as unknown as Pipeline<unknown>;\n  }\n\n  /**\n   * Randomly shuffles elements in the pipeline.\n   *\n   * @returns Pipeline with shuffled elements\n   */\n  shuffle(): Pipeline<T> {\n    this.operations.push({ type: 'shuffle' });\n    return this;\n  }\n\n  /**\n   * Takes a random sample of n elements.\n   *\n   * @param count - Number of elements to sample\n   * @returns Pipeline with sampled elements\n   */\n  sample(count: number): Pipeline<T> {\n    this.operations.push({ type: 'sample', count: Math.max(0, count) });\n    return this;\n  }\n\n  /**\n   * Drops elements from the beginning while predicate returns true.\n   *\n   * @param predicate - Function to test each element\n   * @returns Pipeline without dropped elements\n   *\n   * @example\n   * ```typescript\n   * const result = await ThreadTS.pipe([1, 2, 3, 4, 5])\n   *   .dropWhile(x => x < 3)\n   *   .execute();\n   * // Result: [3, 4, 5]\n   * ```\n   */\n  dropWhile(predicate: SerializableFunction): Pipeline<T> {\n    this.operations.push({ type: 'dropWhile', fn: predicate });\n    return this;\n  }\n\n  /**\n   * Takes elements from the beginning while predicate returns true.\n   *\n   * @param predicate - Function to test each element\n   * @returns Pipeline with taken elements\n   *\n   * @example\n   * ```typescript\n   * const result = await ThreadTS.pipe([1, 2, 3, 4, 5])\n   *   .takeWhile(x => x < 3)\n   *   .execute();\n   * // Result: [1, 2]\n   * ```\n   */\n  takeWhile(predicate: SerializableFunction): Pipeline<T> {\n    this.operations.push({ type: 'takeWhile', fn: predicate });\n    return this;\n  }\n\n  /**\n   * Slices the pipeline from start to end index.\n   *\n   * @param start - Start index (default: 0)\n   * @param end - End index (default: array length)\n   * @returns Pipeline with sliced elements\n   *\n   * @example\n   * ```typescript\n   * const result = await ThreadTS.pipe([1, 2, 3, 4, 5])\n   *   .slice(1, 4)\n   *   .execute();\n   * // Result: [2, 3, 4]\n   * ```\n   */\n  slicePipe(start?: number, end?: number): Pipeline<T> {\n    this.operations.push({\n      type: 'slice',\n      count: start,\n      step: end,\n    });\n    return this;\n  }\n\n  /**\n   * Concatenates another array to the pipeline.\n   *\n   * @param other - Array to concatenate\n   * @returns Pipeline with concatenated elements\n   *\n   * @example\n   * ```typescript\n   * const result = await ThreadTS.pipe([1, 2, 3])\n   *   .concatPipe([4, 5, 6])\n   *   .execute();\n   * // Result: [1, 2, 3, 4, 5, 6]\n   * ```\n   */\n  concatPipe(other: T[]): Pipeline<T> {\n    this.operations.push({\n      type: 'concat',\n      initialValue: other,\n    });\n    return this;\n  }\n\n  /**\n   * Rotates array elements by n positions.\n   * Positive n rotates right, negative n rotates left.\n   *\n   * @param n - Number of positions to rotate\n   * @returns Pipeline with rotated elements\n   *\n   * @example\n   * ```typescript\n   * const result = await ThreadTS.pipe([1, 2, 3, 4, 5])\n   *   .rotate(2)\n   *   .execute();\n   * // Result: [4, 5, 1, 2, 3]\n   * ```\n   */\n  rotate(n: number): Pipeline<T> {\n    this.operations.push({\n      type: 'rotate',\n      count: n,\n    });\n    return this;\n  }\n\n  /**\n   * Removes falsy values from the pipeline.\n   * Keeps only truthy values (removes false, 0, '', null, undefined, NaN).\n   *\n   * @returns Pipeline without falsy values\n   *\n   * @example\n   * ```typescript\n   * const result = await ThreadTS.pipe([1, 0, 2, '', 3, null, 4])\n   *   .truthy()\n   *   .execute();\n   * // Result: [1, 2, 3, 4]\n   * ```\n   */\n  truthy(): Pipeline<T> {\n    this.operations.push({ type: 'truthy' });\n    return this;\n  }\n\n  /**\n   * Keeps only falsy values from the pipeline.\n   *\n   * @returns Pipeline with only falsy values\n   *\n   * @example\n   * ```typescript\n   * const result = await ThreadTS.pipe([1, 0, 2, '', 3, null, 4])\n   *   .falsy()\n   *   .execute();\n   * // Result: [0, '', null]\n   * ```\n   */\n  falsy(): Pipeline<T> {\n    this.operations.push({ type: 'falsy' });\n    return this;\n  }\n\n  /**\n   * Executes a side-effect function for debugging without modifying the pipeline.\n   * Alias for tap().\n   *\n   * @param fn - Function to execute for each element\n   * @returns Pipeline unchanged\n   */\n  peek(fn: SerializableFunction): Pipeline<T> {\n    this.operations.push({ type: 'peek', fn });\n    return this;\n  }\n\n  /**\n   * Adds a reduce operation to the pipeline. This is a terminal operation.\n   */\n  reduce<R>(\n    fn: SerializableFunction,\n    initialValue: R,\n    options?: ThreadOptions\n  ): TerminalPipeline<R> {\n    this.operations.push({ type: 'reduce', fn, initialValue, options });\n    return new TerminalPipeline<R>(this.array, this.operations, this.threadts);\n  }\n\n  /**\n   * Adds a forEach operation to the pipeline. This is a terminal operation.\n   */\n  forEach(\n    fn: SerializableFunction,\n    options?: MapOptions\n  ): TerminalPipeline<void> {\n    this.operations.push({ type: 'forEach', fn, options });\n    return new TerminalPipeline<void>(\n      this.array,\n      this.operations,\n      this.threadts\n    );\n  }\n\n  /**\n   * Adds a find operation to the pipeline. This is a terminal operation.\n   */\n  find(\n    fn: SerializableFunction,\n    options?: MapOptions\n  ): TerminalPipeline<T | undefined> {\n    this.operations.push({ type: 'find', fn, options });\n    return new TerminalPipeline<T | undefined>(\n      this.array,\n      this.operations,\n      this.threadts\n    );\n  }\n\n  /**\n   * Adds a findIndex operation to the pipeline. This is a terminal operation.\n   */\n  findIndex(\n    fn: SerializableFunction,\n    options?: MapOptions\n  ): TerminalPipeline<number> {\n    this.operations.push({ type: 'findIndex', fn, options });\n    return new TerminalPipeline<number>(\n      this.array,\n      this.operations,\n      this.threadts\n    );\n  }\n\n  /**\n   * Finds the last element that satisfies the predicate. This is a terminal operation.\n   * Similar to Array.prototype.findLast (ES2023).\n   *\n   * @param fn - Function to test each element\n   * @param options - Execution options\n   * @returns TerminalPipeline that resolves to the last matching element or undefined\n   *\n   * @example\n   * ```typescript\n   * const last = await threadts.pipe([1, 2, 3, 4, 5])\n   *   .findLast(x => x < 4)\n   *   .execute();\n   * // Result: 3\n   * ```\n   */\n  findLast(\n    fn: SerializableFunction,\n    options?: MapOptions\n  ): TerminalPipeline<T | undefined> {\n    this.operations.push({ type: 'findLast', fn, options });\n    return new TerminalPipeline<T | undefined>(\n      this.array,\n      this.operations,\n      this.threadts\n    );\n  }\n\n  /**\n   * Finds the index of the last element that satisfies the predicate. This is a terminal operation.\n   * Similar to Array.prototype.findLastIndex (ES2023).\n   *\n   * @param fn - Function to test each element\n   * @param options - Execution options\n   * @returns TerminalPipeline that resolves to the last matching index or -1\n   *\n   * @example\n   * ```typescript\n   * const index = await threadts.pipe([1, 2, 3, 2, 1])\n   *   .findLastIndex(x => x === 2)\n   *   .execute();\n   * // Result: 3\n   * ```\n   */\n  findLastIndex(\n    fn: SerializableFunction,\n    options?: MapOptions\n  ): TerminalPipeline<number> {\n    this.operations.push({ type: 'findLastIndex', fn, options });\n    return new TerminalPipeline<number>(\n      this.array,\n      this.operations,\n      this.threadts\n    );\n  }\n\n  /**\n   * Adds a some operation to the pipeline. This is a terminal operation.\n   */\n  some(\n    fn: SerializableFunction,\n    options?: MapOptions\n  ): TerminalPipeline<boolean> {\n    this.operations.push({ type: 'some', fn, options });\n    return new TerminalPipeline<boolean>(\n      this.array,\n      this.operations,\n      this.threadts\n    );\n  }\n\n  /**\n   * Adds an every operation to the pipeline. This is a terminal operation.\n   */\n  every(\n    fn: SerializableFunction,\n    options?: MapOptions\n  ): TerminalPipeline<boolean> {\n    this.operations.push({ type: 'every', fn, options });\n    return new TerminalPipeline<boolean>(\n      this.array,\n      this.operations,\n      this.threadts\n    );\n  }\n\n  /**\n   * Adds a count operation to the pipeline. This is a terminal operation.\n   * If no predicate is provided, counts all elements.\n   */\n  count(\n    fn?: SerializableFunction,\n    options?: MapOptions\n  ): TerminalPipeline<number> {\n    const countFn = fn ?? (() => true);\n    this.operations.push({ type: 'count', fn: countFn, options });\n    return new TerminalPipeline<number>(\n      this.array,\n      this.operations,\n      this.threadts\n    );\n  }\n\n  /**\n   * Groups elements by a key function. This is a terminal operation.\n   *\n   * @param keyFn - Function that returns the group key for each element\n   * @param options - Execution options\n   * @returns TerminalPipeline that resolves to a Map of grouped elements\n   *\n   * @example\n   * ```typescript\n   * const grouped = await ThreadTS.pipe(users)\n   *   .groupBy(user => user.role)\n   *   .execute();\n   * ```\n   */\n  groupBy<K extends string | number | symbol>(\n    keyFn: SerializableFunction,\n    options?: MapOptions\n  ): TerminalPipeline<Map<K, T[]>> {\n    this.operations.push({ type: 'groupBy', fn: keyFn, options });\n    return new TerminalPipeline<Map<K, T[]>>(\n      this.array,\n      this.operations,\n      this.threadts\n    );\n  }\n\n  /**\n   * Partitions elements into two arrays based on a predicate. This is a terminal operation.\n   *\n   * @param predicate - Function that returns true for elements in the first partition\n   * @param options - Execution options\n   * @returns TerminalPipeline that resolves to a tuple of [matching, non-matching]\n   *\n   * @example\n   * ```typescript\n   * const [evens, odds] = await ThreadTS.pipe([1, 2, 3, 4, 5])\n   *   .partition(x => x % 2 === 0)\n   *   .execute();\n   * ```\n   */\n  partition(\n    predicate: SerializableFunction,\n    options?: MapOptions\n  ): TerminalPipeline<[T[], T[]]> {\n    this.operations.push({ type: 'partition', fn: predicate, options });\n    return new TerminalPipeline<[T[], T[]]>(\n      this.array,\n      this.operations,\n      this.threadts\n    );\n  }\n\n  /**\n   * Gets the first element of the pipeline. This is a terminal operation.\n   *\n   * @returns TerminalPipeline that resolves to the first element or undefined\n   */\n  first(): TerminalPipeline<T | undefined> {\n    this.operations.push({ type: 'first' });\n    return new TerminalPipeline<T | undefined>(\n      this.array,\n      this.operations,\n      this.threadts\n    );\n  }\n\n  /**\n   * Gets the last element of the pipeline. This is a terminal operation.\n   *\n   * @returns TerminalPipeline that resolves to the last element or undefined\n   */\n  last(): TerminalPipeline<T | undefined> {\n    this.operations.push({ type: 'last' });\n    return new TerminalPipeline<T | undefined>(\n      this.array,\n      this.operations,\n      this.threadts\n    );\n  }\n\n  /**\n   * Checks if the pipeline contains no elements. This is a terminal operation.\n   *\n   * @returns TerminalPipeline that resolves to true if empty\n   */\n  isEmpty(): TerminalPipeline<boolean> {\n    this.operations.push({ type: 'isEmpty' });\n    return new TerminalPipeline<boolean>(\n      this.array,\n      this.operations,\n      this.threadts\n    );\n  }\n\n  /**\n   * Calculates the sum of numeric elements. This is a terminal operation.\n   *\n   * @returns TerminalPipeline that resolves to the sum\n   */\n  sum(): TerminalPipeline<number> {\n    this.operations.push({ type: 'sum' });\n    return new TerminalPipeline<number>(\n      this.array,\n      this.operations,\n      this.threadts\n    );\n  }\n\n  /**\n   * Calculates the average of numeric elements. This is a terminal operation.\n   *\n   * @returns TerminalPipeline that resolves to the average or NaN if empty\n   */\n  average(): TerminalPipeline<number> {\n    this.operations.push({ type: 'average' });\n    return new TerminalPipeline<number>(\n      this.array,\n      this.operations,\n      this.threadts\n    );\n  }\n\n  /**\n   * Finds the minimum element. This is a terminal operation.\n   *\n   * @param compareFn - Optional comparison function\n   * @returns TerminalPipeline that resolves to the minimum element\n   */\n  min(compareFn?: SerializableFunction): TerminalPipeline<T | undefined> {\n    this.operations.push({ type: 'min', fn: compareFn });\n    return new TerminalPipeline<T | undefined>(\n      this.array,\n      this.operations,\n      this.threadts\n    );\n  }\n\n  /**\n   * Finds the maximum element. This is a terminal operation.\n   *\n   * @param compareFn - Optional comparison function\n   * @returns TerminalPipeline that resolves to the maximum element\n   */\n  max(compareFn?: SerializableFunction): TerminalPipeline<T | undefined> {\n    this.operations.push({ type: 'max', fn: compareFn });\n    return new TerminalPipeline<T | undefined>(\n      this.array,\n      this.operations,\n      this.threadts\n    );\n  }\n\n  /**\n   * Joins all elements into a string with the specified separator. This is a terminal operation.\n   *\n   * @param separator - The separator to use between elements (default: ',')\n   * @returns TerminalPipeline that resolves to the joined string\n   *\n   * @example\n   * ```typescript\n   * const result = await thread.pipe(['a', 'b', 'c'])\n   *   .join('-')\n   *   .execute(); // 'a-b-c'\n   * ```\n   */\n  join(separator = ','): TerminalPipeline<string> {\n    this.operations.push({ type: 'join', initialValue: separator });\n    return new TerminalPipeline<string>(\n      this.array,\n      this.operations,\n      this.threadts\n    );\n  }\n\n  /**\n   * Checks if the pipeline contains a specific element. This is a terminal operation.\n   *\n   * @param searchElement - The element to search for\n   * @returns TerminalPipeline that resolves to true if found, false otherwise\n   *\n   * @example\n   * ```typescript\n   * const hasThree = await thread.pipe([1, 2, 3, 4])\n   *   .includes(3)\n   *   .execute(); // true\n   * ```\n   */\n  includes(searchElement: T): TerminalPipeline<boolean> {\n    this.operations.push({ type: 'includes', initialValue: searchElement });\n    return new TerminalPipeline<boolean>(\n      this.array,\n      this.operations,\n      this.threadts\n    );\n  }\n\n  /**\n   * Executes all operations in the pipeline and returns the result array.\n   */\n  async execute(): Promise<T[]> {\n    let result: unknown[] = this.array;\n\n    for (const op of this.operations) {\n      result = await executeIntermediateOperation(result, op, this.threadts);\n    }\n\n    return result as T[];\n  }\n\n  /**\n   * Collects the pipeline results into an array.\n   * Alias for execute().\n   */\n  async toArray(): Promise<T[]> {\n    return this.execute();\n  }\n\n  /**\n   * Collects the pipeline results into a Set.\n   */\n  async toSet(): Promise<Set<T>> {\n    const result = await this.execute();\n    return new Set(result);\n  }\n\n  /**\n   * Collects the pipeline results into a Map using a key function.\n   *\n   * @param keyFn - Function that returns the key for each element\n   * @returns Promise that resolves to a Map\n   */\n  async toMap<K>(keyFn: (item: T) => K): Promise<Map<K, T>> {\n    const result = await this.execute();\n    const map = new Map<K, T>();\n    for (const item of result) {\n      map.set(keyFn(item), item);\n    }\n    return map;\n  }\n}\n\n/**\n * Terminal pipeline for operations that produce a single value.\n */\nexport class TerminalPipeline<R> {\n  constructor(\n    private array: unknown[],\n    private operations: PipelineOperation[],\n    private threadts: ThreadTS\n  ) {}\n\n  /**\n   * Executes all operations in the pipeline and returns the final result.\n   */\n  async execute(): Promise<R> {\n    let result: unknown[] = this.array;\n\n    for (let i = 0; i < this.operations.length; i++) {\n      const op = this.operations[i];\n      const isLast = i === this.operations.length - 1;\n\n      if (isLast && isTerminalOperation(op.type)) {\n        return executeTerminalOperation<R>(result, op, this.threadts);\n      }\n\n      result = await executeIntermediateOperation(result, op, this.threadts);\n    }\n\n    return result as R;\n  }\n}\n","/**\n * ThreadTS Universal - Core ThreadTS Class\n *\n * The main entry point for parallel computing in ThreadTS Universal.\n * Provides a simple, powerful API for executing functions in parallel\n * across all JavaScript runtimes (Browser, Node.js, Deno, Bun).\n *\n * @module core/threadts\n * @author ThreadTS Universal Team\n *\n * @example\n * ```typescript\n * import threadts from 'threadts-universal';\n *\n * // Simple parallel execution\n * const result = await threadts.run((x) => x * 2, 21);\n * console.log(result); // 42\n *\n * // Parallel array processing\n * const squares = await threadts.map([1, 2, 3], (x) => x * x);\n * console.log(squares); // [1, 4, 9]\n * ```\n */\n\nimport type {\n  MapOptions,\n  SerializableData,\n  SerializableFunction,\n  TaskResult,\n  ThreadConfig,\n  ThreadOptions,\n  ThreadTask,\n} from '../types';\nimport { ThreadError, TimeoutError, WorkerError } from '../types';\nimport { PlatformUtils } from '../utils/platform';\nimport {\n  toPositiveInt,\n  validateFunction,\n  validateSerializable,\n} from '../utils/validation';\nimport {\n  createArrayOperations,\n  type ArrayOperations,\n} from './array-operations';\nimport { Pipeline, TerminalPipeline } from './pipeline';\n\n/**\n * Default batch size for search operations (find, findIndex, some, every).\n * A smaller batch size provides better early termination behavior.\n */\nconst DEFAULT_SEARCH_BATCH_SIZE = 10;\n\n/**\n * Calculates the default batch size for search operations.\n * Uses a smaller batch size for better early termination behavior.\n *\n * @param arrayLength - The length of the array being processed\n * @returns The calculated batch size\n */\nfunction getDefaultSearchBatchSize(arrayLength: number): number {\n  return Math.min(arrayLength, DEFAULT_SEARCH_BATCH_SIZE);\n}\n\n/**\n * Event map for ThreadTS event system.\n * Defines all events that can be emitted by the ThreadTS instance.\n */\ninterface ThreadEventMap {\n  /** Emitted when a task completes successfully */\n  'task-complete': {\n    taskId: string;\n    result: SerializableData;\n    duration: number;\n  };\n  /** Emitted when a task fails with an error */\n  'task-error': { taskId: string; error: string; duration: number };\n  /** Emitted when the worker pool size changes */\n  'pool-resize': { oldSize: number; newSize: number };\n  /** Emitted when a new worker is spawned */\n  'worker-spawn': { workerId: string; poolSize: number };\n  /** Emitted when a worker is terminated */\n  'worker-terminate': { workerId: string; poolSize: number };\n}\n\n/** Type for event listener functions */\ntype ThreadEventListener<K extends keyof ThreadEventMap> = (\n  detail: ThreadEventMap[K]\n) => void;\n\n/** Internal key used to identify args payloads */\nconst INTERNAL_ARGS_KEY = '__THREADTS_ARGS__' as const;\n\n/** Internal type for passing multiple arguments to workers */\ntype InternalArgsPayload = {\n  [INTERNAL_ARGS_KEY]: unknown[];\n};\n\n/**\n * Legacy task format for backwards compatibility.\n * Supports both 'fn' and 'func' property names.\n */\ntype LegacyTask = {\n  fn?: SerializableFunction;\n  func?: SerializableFunction;\n  data?: SerializableData;\n  options?: ThreadOptions;\n};\n\n/**\n * Normalized task format with required function.\n */\ninterface NormalizedTask {\n  fn: SerializableFunction;\n  data?: SerializableData;\n  options?: ThreadOptions;\n}\n\n/**\n * ThreadTS - The main class for parallel computing.\n *\n * Implements a singleton pattern for resource sharing while allowing\n * configuration customization. Provides methods for executing functions\n * in parallel, including map, filter, reduce, and batch operations.\n *\n * @extends EventTarget - Enables event-based communication\n *\n * @example\n * ```typescript\n * // Get the singleton instance\n * const instance = ThreadTS.getInstance();\n *\n * // Execute a function in parallel\n * const result = await instance.run((x) => x * 2, 21);\n *\n * // Process arrays in parallel\n * const doubled = await instance.map([1, 2, 3], (x) => x * 2);\n * ```\n */\n\nexport class ThreadTS extends EventTarget {\n  private static _instance: ThreadTS | null = null;\n  private config!: ThreadConfig;\n  private isReady: boolean = false;\n  private taskCounter: number = 0;\n  private completedTasks: number = 0;\n  private failedTasks: number = 0;\n  private totalExecutionTime: number = 0;\n  private eventListeners: Map<\n    keyof ThreadEventMap,\n    Set<ThreadEventListener<keyof ThreadEventMap>>\n  > = new Map();\n\n  /** Extended array operations */\n  private arrayOps: ArrayOperations | null = null;\n\n  constructor(config: Partial<ThreadConfig> = {}) {\n    super();\n\n    if (ThreadTS._instance && Object.keys(config).length === 0) {\n      return ThreadTS._instance;\n    }\n\n    this.config = this.mergeConfig(config);\n\n    if (!ThreadTS._instance) {\n      ThreadTS._instance = this;\n    }\n\n    this.initialize();\n  }\n\n  private mergeConfig(userConfig: Partial<ThreadConfig>): ThreadConfig {\n    const defaultConfig: ThreadConfig = {\n      poolSize: PlatformUtils.getOptimalWorkerCount(),\n      timeout: 30000,\n      retries: 2,\n      autoResize: true,\n      debug: false,\n      serializationStrategy: 'auto',\n      enableDecorators: true,\n      enableMetrics: false,\n      maxQueueSize: 1000,\n      workerIdleTimeout: 60000,\n      taskPriority: 'normal',\n    };\n\n    return { ...defaultConfig, ...userConfig };\n  }\n\n  static getInstance(config?: Partial<ThreadConfig>): ThreadTS {\n    if (!ThreadTS._instance) {\n      ThreadTS._instance = new ThreadTS(config);\n    }\n    return ThreadTS._instance;\n  }\n\n  private async initialize(): Promise<void> {\n    try {\n      this.isReady = true;\n      // Initialize array operations\n      this.arrayOps = createArrayOperations(this);\n      this.emitEvent('pool-resize', {\n        oldSize: 0,\n        newSize: this.config.poolSize,\n      });\n    } catch (error) {\n      console.error('Failed to initialize ThreadTS:', error);\n      throw error;\n    }\n  }\n\n  /**\n   * Returns the extended array operations module.\n   * Provides additional array methods like indexOf, lastIndexOf, at, slice, etc.\n   *\n   * @returns The ArrayOperations object with extended methods\n   *\n   * @example\n   * ```typescript\n   * const ops = threadts.getArrayOps();\n   * const index = await ops.indexOf([1, 2, 3], 2);\n   * const chunk = await ops.chunk([1, 2, 3, 4, 5], 2);\n   * ```\n   */\n  getArrayOps(): ArrayOperations {\n    if (!this.arrayOps) {\n      this.arrayOps = createArrayOperations(this);\n    }\n    return this.arrayOps;\n  }\n\n  // ==================== Extended Array Methods ====================\n\n  /**\n   * Finds the index of the first occurrence of a value in the array.\n   * @see ArrayOperations.indexOf\n   */\n  async indexOf<T>(\n    array: T[],\n    searchElement: T,\n    fromIndex = 0\n  ): Promise<number> {\n    return this.getArrayOps().indexOf(array, searchElement, fromIndex);\n  }\n\n  /**\n   * Finds the index of the last occurrence of a value in the array.\n   * @see ArrayOperations.lastIndexOf\n   */\n  async lastIndexOf<T>(\n    array: T[],\n    searchElement: T,\n    fromIndex?: number\n  ): Promise<number> {\n    return this.getArrayOps().lastIndexOf(array, searchElement, fromIndex);\n  }\n\n  /**\n   * Returns the element at the specified index.\n   * @see ArrayOperations.at\n   */\n  async at<T>(array: T[], index: number): Promise<T | undefined> {\n    return this.getArrayOps().at(array, index);\n  }\n\n  /**\n   * Creates a new array with elements from startIndex to endIndex.\n   * @see ArrayOperations.slice\n   */\n  async slice<T>(array: T[], start?: number, end?: number): Promise<T[]> {\n    return this.getArrayOps().slice(array, start, end);\n  }\n\n  /**\n   * Concatenates multiple arrays into one.\n   * @see ArrayOperations.concat\n   */\n  async concat<T>(array: T[], ...items: (T | T[])[]): Promise<T[]> {\n    return this.getArrayOps().concat(array, ...items);\n  }\n\n  /**\n   * Creates an array containing a range of numbers.\n   * @see ArrayOperations.range\n   */\n  async range(start: number, end: number, step = 1): Promise<number[]> {\n    return this.getArrayOps().range(start, end, step);\n  }\n\n  /**\n   * Creates an array by repeating a value.\n   * @see ArrayOperations.repeat\n   */\n  async repeat<T>(value: T, count: number): Promise<T[]> {\n    return this.getArrayOps().repeat(value, count);\n  }\n\n  /**\n   * Removes duplicate values from an array.\n   * @see ArrayOperations.unique\n   */\n  async unique<T>(array: T[]): Promise<T[]> {\n    return this.getArrayOps().unique(array);\n  }\n\n  /**\n   * Removes duplicate values using a key function.\n   * @see ArrayOperations.uniqueBy\n   */\n  async uniqueBy<T, K>(array: T[], keyFn: (item: T) => K): Promise<T[]> {\n    return this.getArrayOps().uniqueBy(array, keyFn);\n  }\n\n  /**\n   * Splits an array into chunks of the specified size.\n   * @see ArrayOperations.chunk\n   */\n  async chunk<T>(array: T[], size: number): Promise<T[][]> {\n    return this.getArrayOps().chunk(array, size);\n  }\n\n  /**\n   * Zips multiple arrays together into an array of tuples.\n   * @see ArrayOperations.zip\n   */\n  async zip<T extends unknown[][]>(\n    ...arrays: T\n  ): Promise<{ [K in keyof T]: T[K] extends (infer U)[] ? U : never }[]> {\n    return this.getArrayOps().zip(...arrays);\n  }\n\n  // ==================== ES2023+ Array Methods ====================\n\n  /**\n   * Finds the last element that satisfies the predicate.\n   * @see ArrayOperations.findLast\n   */\n  async findLast<T>(\n    array: T[],\n    predicate: (value: T, index: number, array: T[]) => boolean\n  ): Promise<T | undefined> {\n    return this.getArrayOps().findLast(array, predicate);\n  }\n\n  /**\n   * Finds the index of the last element that satisfies the predicate.\n   * @see ArrayOperations.findLastIndex\n   */\n  async findLastIndex<T>(\n    array: T[],\n    predicate: (value: T, index: number, array: T[]) => boolean\n  ): Promise<number> {\n    return this.getArrayOps().findLastIndex(array, predicate);\n  }\n\n  /**\n   * Returns a new sorted array (immutable).\n   * @see ArrayOperations.toSorted\n   */\n  async toSorted<T>(\n    array: T[],\n    compareFn?: (a: T, b: T) => number\n  ): Promise<T[]> {\n    return this.getArrayOps().toSorted(array, compareFn);\n  }\n\n  /**\n   * Returns a new reversed array (immutable).\n   * @see ArrayOperations.toReversed\n   */\n  async toReversed<T>(array: T[]): Promise<T[]> {\n    return this.getArrayOps().toReversed(array);\n  }\n\n  /**\n   * Returns a new array with the element at the given index replaced.\n   * @see ArrayOperations.withElement\n   */\n  async withElement<T>(array: T[], index: number, value: T): Promise<T[]> {\n    return this.getArrayOps().withElement(array, index, value);\n  }\n\n  /**\n   * Returns a new array with elements removed/replaced/added at a given index.\n   * @see ArrayOperations.toSpliced\n   */\n  async toSpliced<T>(\n    array: T[],\n    start: number,\n    deleteCount?: number,\n    ...items: T[]\n  ): Promise<T[]> {\n    return this.getArrayOps().toSpliced(array, start, deleteCount, ...items);\n  }\n\n  /**\n   * Groups elements of an array based on a callback function.\n   * @see ArrayOperations.groupByObject\n   */\n  async groupByObject<T, K extends PropertyKey>(\n    array: T[],\n    keyFn: (item: T, index: number) => K\n  ): Promise<Partial<Record<K, T[]>>> {\n    return this.getArrayOps().groupByObject(array, keyFn);\n  }\n\n  private emitEvent<K extends keyof ThreadEventMap>(\n    type: K,\n    detail: ThreadEventMap[K]\n  ): void {\n    const listeners = this.eventListeners.get(type);\n    if (listeners) {\n      listeners.forEach((listener) => {\n        try {\n          (listener as ThreadEventListener<K>)(detail);\n        } catch (error) {\n          if (this.config.debug) {\n            console.error(`Error in event listener for ${type}:`, error);\n          }\n        }\n      });\n    }\n  }\n\n  on<K extends keyof ThreadEventMap>(\n    event: K,\n    listener: ThreadEventListener<K>\n  ): void {\n    if (!this.eventListeners.has(event)) {\n      this.eventListeners.set(event, new Set());\n    }\n    this.eventListeners\n      .get(event)!\n      .add(listener as ThreadEventListener<keyof ThreadEventMap>);\n  }\n\n  off<K extends keyof ThreadEventMap>(\n    event: K,\n    listener: ThreadEventListener<K>\n  ): void {\n    const listeners = this.eventListeners.get(event);\n    if (listeners) {\n      listeners.delete(listener as ThreadEventListener<keyof ThreadEventMap>);\n    }\n  }\n\n  private isArgsPayload(value: unknown): value is InternalArgsPayload {\n    return (\n      typeof value === 'object' &&\n      value !== null &&\n      INTERNAL_ARGS_KEY in (value as Record<string, unknown>) &&\n      Array.isArray((value as Record<string, unknown>)[INTERNAL_ARGS_KEY])\n    );\n  }\n\n  private createArgsPayload(...args: unknown[]): InternalArgsPayload {\n    return {\n      [INTERNAL_ARGS_KEY]: args,\n    };\n  }\n\n  private prepareArguments(\n    data?: SerializableData | InternalArgsPayload\n  ): unknown[] {\n    if (typeof data === 'undefined') {\n      return [];\n    }\n\n    if (this.isArgsPayload(data)) {\n      return [...data[INTERNAL_ARGS_KEY]];\n    }\n\n    return [data];\n  }\n\n  private async executeWithControls<T>(\n    func: SerializableFunction,\n    args: unknown[],\n    options: ThreadOptions\n  ): Promise<T> {\n    if (options.signal?.aborted) {\n      throw new WorkerError('Operation was aborted before execution');\n    }\n\n    const execution = Promise.resolve().then(() => func(...args)) as Promise<T>;\n    const controlled = this.wrapWithAbort(execution, options.signal);\n\n    if (typeof options.timeout === 'number') {\n      return this.withTimeout(controlled, options.timeout);\n    }\n\n    return controlled;\n  }\n\n  private wrapWithAbort<T>(\n    promise: Promise<T>,\n    signal?: AbortSignal\n  ): Promise<T> {\n    if (!signal) {\n      return promise;\n    }\n\n    if (signal.aborted) {\n      return Promise.reject(new WorkerError('Operation was aborted'));\n    }\n\n    return new Promise<T>((resolve, reject) => {\n      const onAbort = () => {\n        signal.removeEventListener('abort', onAbort);\n        reject(new WorkerError('Operation was aborted'));\n      };\n\n      signal.addEventListener('abort', onAbort, { once: true });\n\n      promise.then(\n        (value) => {\n          signal.removeEventListener('abort', onAbort);\n          resolve(value);\n        },\n        (error) => {\n          signal.removeEventListener('abort', onAbort);\n          reject(error);\n        }\n      );\n    });\n  }\n\n  private withTimeout<T>(promise: Promise<T>, timeout: number): Promise<T> {\n    if (timeout <= 0) {\n      return promise;\n    }\n\n    let timeoutId: ReturnType<typeof setTimeout> | undefined;\n\n    return new Promise<T>((resolve, reject) => {\n      timeoutId = setTimeout(() => {\n        reject(new TimeoutError(timeout));\n      }, timeout);\n\n      promise.then(\n        (value) => {\n          if (timeoutId) {\n            clearTimeout(timeoutId);\n          }\n          resolve(value);\n        },\n        (error) => {\n          if (timeoutId) {\n            clearTimeout(timeoutId);\n          }\n          reject(error);\n        }\n      );\n    });\n  }\n\n  private normalizeTask(task: ThreadTask | LegacyTask): NormalizedTask {\n    const candidateFn =\n      typeof task.fn === 'function'\n        ? task.fn\n        : typeof (task as LegacyTask).func === 'function'\n          ? (task as LegacyTask).func\n          : undefined;\n\n    if (typeof candidateFn !== 'function') {\n      throw new ThreadError(\n        'Invalid task definition: missing function',\n        'INVALID_TASK'\n      );\n    }\n\n    return {\n      fn: candidateFn,\n      data: task.data,\n      options: task.options,\n    };\n  }\n\n  async run<T = unknown>(\n    func: SerializableFunction,\n    data?: SerializableData | InternalArgsPayload,\n    options: ThreadOptions = {}\n  ): Promise<T> {\n    if (!this.isReady) {\n      await this.initialize();\n    }\n\n    // Validate the function using the utility\n    validateFunction(func, 'func');\n\n    const taskId = this.generateTaskId();\n    const startTime = PlatformUtils.getHighResTimestamp();\n    const args = this.prepareArguments(data);\n\n    // Validate each argument for serializability\n    for (const arg of args) {\n      validateSerializable(arg);\n    }\n\n    const maxRetries = Math.max(\n      0,\n      options.maxRetries ?? this.config.retries ?? 0\n    );\n    let attempt = 0;\n\n    // Retry loop with configurable attempts\n    while (true) {\n      try {\n        const result = await this.executeWithControls<T>(func, args, options);\n\n        const duration = PlatformUtils.getHighResTimestamp() - startTime;\n        this.completedTasks += 1;\n        this.totalExecutionTime += duration;\n\n        this.emitEvent('task-complete', {\n          taskId,\n          result: result as SerializableData,\n          duration,\n        });\n\n        return result;\n      } catch (error) {\n        if (attempt >= maxRetries) {\n          const duration = PlatformUtils.getHighResTimestamp() - startTime;\n          const errorMessage =\n            error instanceof Error ? error.message : String(error);\n\n          this.failedTasks += 1;\n          this.emitEvent('task-error', {\n            taskId,\n            error: errorMessage,\n            duration,\n          });\n\n          throw error;\n        }\n\n        attempt += 1;\n\n        if (this.config.debug) {\n          console.warn(\n            `ThreadTS retrying task ${taskId} (attempt ${attempt} of ${maxRetries})`,\n            error\n          );\n        }\n      }\n    }\n  }\n\n  async map<T, R = T>(\n    array: T[],\n    func: SerializableFunction,\n    options: MapOptions = {}\n  ): Promise<R[]> {\n    if (!array.length) {\n      return [];\n    }\n\n    const { batchSize = array.length, ...runOptions } = options;\n    const executionOptions: ThreadOptions = { ...runOptions };\n    const normalizedBatchSize = Math.max(1, Math.floor(batchSize));\n    const results: R[] = [];\n\n    for (let index = 0; index < array.length; index += normalizedBatchSize) {\n      const chunk = array.slice(index, index + normalizedBatchSize);\n      const chunkResults = await Promise.all(\n        chunk.map((item, offset) =>\n          this.run<R>(\n            func,\n            this.createArgsPayload(item, index + offset, array),\n            executionOptions\n          )\n        )\n      );\n      results.push(...chunkResults);\n    }\n\n    return results;\n  }\n\n  async filter<T>(\n    array: T[],\n    predicate: SerializableFunction,\n    options: MapOptions = {}\n  ): Promise<T[]> {\n    if (!array.length) {\n      return [];\n    }\n\n    const results = await this.map<T, boolean>(array, predicate, options);\n    return array.filter((_, index) => Boolean(results[index]));\n  }\n\n  async reduce<T, R>(\n    array: T[],\n    reducer: SerializableFunction,\n    initialValue: R,\n    options: ThreadOptions = {}\n  ): Promise<R> {\n    let accumulator = initialValue;\n\n    if (!array.length) {\n      return accumulator;\n    }\n\n    for (let index = 0; index < array.length; index++) {\n      accumulator = await this.run<R>(\n        reducer,\n        this.createArgsPayload(accumulator, array[index], index, array),\n        options\n      );\n    }\n\n    return accumulator;\n  }\n\n  /**\n   * Iterates over an array, executing the function for each element.\n   * Similar to Array.prototype.forEach but runs in parallel.\n   *\n   * @template T - The type of array elements\n   * @param array - The array to iterate over\n   * @param func - Function to execute for each element: (item, index, array) => void\n   * @param options - Execution options including batchSize\n   *\n   * @example\n   * ```typescript\n   * await threadts.forEach([1, 2, 3], (item) => {\n   *   console.log(item);\n   * });\n   * ```\n   */\n  async forEach<T>(\n    array: T[],\n    func: SerializableFunction,\n    options: MapOptions = {}\n  ): Promise<void> {\n    await this.map<T, void>(array, func, options);\n  }\n\n  /**\n   * Finds the first element that satisfies the predicate function.\n   * Similar to Array.prototype.find but processes elements in parallel batches.\n   *\n   * Note: Due to parallel processing, this may check more elements than\n   * a sequential find, but returns the first matching element by index.\n   *\n   * @template T - The type of array elements\n   * @param array - The array to search\n   * @param predicate - Function to test each element: (item, index, array) => boolean\n   * @param options - Execution options including batchSize\n   * @returns The first element that satisfies the predicate, or undefined\n   *\n   * @example\n   * ```typescript\n   * const found = await threadts.find(\n   *   [1, 2, 3, 4, 5],\n   *   (x) => x > 3\n   * );\n   * console.log(found); // 4\n   * ```\n   */\n  async find<T>(\n    array: T[],\n    predicate: SerializableFunction,\n    options: MapOptions = {}\n  ): Promise<T | undefined> {\n    if (!array.length) {\n      return undefined;\n    }\n\n    // Process in batches to allow early termination\n    const batchSize = toPositiveInt(\n      options.batchSize,\n      getDefaultSearchBatchSize(array.length)\n    );\n    const executionOptions: ThreadOptions = { ...options };\n\n    for (let i = 0; i < array.length; i += batchSize) {\n      const chunk = array.slice(i, i + batchSize);\n      const results = await Promise.all(\n        chunk.map((item, offset) =>\n          this.run<boolean>(\n            predicate,\n            this.createArgsPayload(item, i + offset, array),\n            executionOptions\n          )\n        )\n      );\n\n      // Find the first true result in this batch\n      const foundIndex = results.findIndex((result) => Boolean(result));\n      if (foundIndex !== -1) {\n        return chunk[foundIndex];\n      }\n    }\n\n    return undefined;\n  }\n\n  /**\n   * Finds the index of the first element that satisfies the predicate.\n   * Similar to Array.prototype.findIndex but processes in parallel batches.\n   *\n   * @template T - The type of array elements\n   * @param array - The array to search\n   * @param predicate - Function to test each element: (item, index, array) => boolean\n   * @param options - Execution options including batchSize\n   * @returns The index of the first matching element, or -1 if not found\n   *\n   * @example\n   * ```typescript\n   * const index = await threadts.findIndex(\n   *   [1, 2, 3, 4, 5],\n   *   (x) => x > 3\n   * );\n   * console.log(index); // 3\n   * ```\n   */\n  async findIndex<T>(\n    array: T[],\n    predicate: SerializableFunction,\n    options: MapOptions = {}\n  ): Promise<number> {\n    if (!array.length) {\n      return -1;\n    }\n\n    const batchSize = toPositiveInt(\n      options.batchSize,\n      getDefaultSearchBatchSize(array.length)\n    );\n    const executionOptions: ThreadOptions = { ...options };\n\n    for (let i = 0; i < array.length; i += batchSize) {\n      const chunk = array.slice(i, i + batchSize);\n      const results = await Promise.all(\n        chunk.map((item, offset) =>\n          this.run<boolean>(\n            predicate,\n            this.createArgsPayload(item, i + offset, array),\n            executionOptions\n          )\n        )\n      );\n\n      const foundIndex = results.findIndex((result) => Boolean(result));\n      if (foundIndex !== -1) {\n        return i + foundIndex;\n      }\n    }\n\n    return -1;\n  }\n\n  /**\n   * Tests whether at least one element satisfies the predicate.\n   * Similar to Array.prototype.some but processes in parallel batches.\n   *\n   * @template T - The type of array elements\n   * @param array - The array to test\n   * @param predicate - Function to test each element: (item, index, array) => boolean\n   * @param options - Execution options including batchSize\n   * @returns true if at least one element passes the test\n   *\n   * @example\n   * ```typescript\n   * const hasEven = await threadts.some(\n   *   [1, 3, 5, 6, 7],\n   *   (x) => x % 2 === 0\n   * );\n   * console.log(hasEven); // true\n   * ```\n   */\n  async some<T>(\n    array: T[],\n    predicate: SerializableFunction,\n    options: MapOptions = {}\n  ): Promise<boolean> {\n    if (!array.length) {\n      return false;\n    }\n\n    const batchSize = toPositiveInt(\n      options.batchSize,\n      getDefaultSearchBatchSize(array.length)\n    );\n    const executionOptions: ThreadOptions = { ...options };\n\n    for (let i = 0; i < array.length; i += batchSize) {\n      const chunk = array.slice(i, i + batchSize);\n      const results = await Promise.all(\n        chunk.map((item, offset) =>\n          this.run<boolean>(\n            predicate,\n            this.createArgsPayload(item, i + offset, array),\n            executionOptions\n          )\n        )\n      );\n\n      // If any result is true, return early\n      if (results.some((result) => Boolean(result))) {\n        return true;\n      }\n    }\n\n    return false;\n  }\n\n  /**\n   * Tests whether all elements satisfy the predicate.\n   * Similar to Array.prototype.every but processes in parallel batches.\n   *\n   * @template T - The type of array elements\n   * @param array - The array to test\n   * @param predicate - Function to test each element: (item, index, array) => boolean\n   * @param options - Execution options including batchSize\n   * @returns true if all elements pass the test\n   *\n   * @example\n   * ```typescript\n   * const allPositive = await threadts.every(\n   *   [1, 2, 3, 4, 5],\n   *   (x) => x > 0\n   * );\n   * console.log(allPositive); // true\n   * ```\n   */\n  async every<T>(\n    array: T[],\n    predicate: SerializableFunction,\n    options: MapOptions = {}\n  ): Promise<boolean> {\n    if (!array.length) {\n      return true; // Empty arrays return true for every()\n    }\n\n    const batchSize = toPositiveInt(\n      options.batchSize,\n      getDefaultSearchBatchSize(array.length)\n    );\n    const executionOptions: ThreadOptions = { ...options };\n\n    for (let i = 0; i < array.length; i += batchSize) {\n      const chunk = array.slice(i, i + batchSize);\n      const results = await Promise.all(\n        chunk.map((item, offset) =>\n          this.run<boolean>(\n            predicate,\n            this.createArgsPayload(item, i + offset, array),\n            executionOptions\n          )\n        )\n      );\n\n      // If any result is false, return early\n      if (!results.every((result) => Boolean(result))) {\n        return false;\n      }\n    }\n\n    return true;\n  }\n\n  /**\n   * Maps each element to an array and flattens the result.\n   * Similar to Array.prototype.flatMap but processes in parallel.\n   *\n   * @template T - The type of array elements\n   * @template R - The type of result array elements\n   * @param array - The array to process\n   * @param func - Function that returns an array for each element: (item, index, array) => R[]\n   * @param options - Execution options including batchSize\n   * @returns Flattened array of results\n   *\n   * @example\n   * ```typescript\n   * const result = await threadts.flatMap(\n   *   [1, 2, 3],\n   *   (x) => [x, x * 2]\n   * );\n   * console.log(result); // [1, 2, 2, 4, 3, 6]\n   * ```\n   */\n  async flatMap<T, R>(\n    array: T[],\n    func: SerializableFunction,\n    options: MapOptions = {}\n  ): Promise<R[]> {\n    if (!array.length) {\n      return [];\n    }\n\n    const results = await this.map<T, R[]>(array, func, options);\n    return results.flat() as R[];\n  }\n\n  /**\n   * Reduces an array from right to left.\n   * Similar to Array.prototype.reduceRight but processes in parallel where possible.\n   *\n   * @template T - The type of array elements\n   * @template R - The type of the accumulator\n   * @param array - The array to reduce\n   * @param reducer - Function to execute on each element: (acc, item, index, array) => R\n   * @param initialValue - Initial value for the accumulator\n   * @param options - Execution options\n   * @returns The final accumulated value\n   *\n   * @example\n   * ```typescript\n   * const result = await threadts.reduceRight(\n   *   ['a', 'b', 'c'],\n   *   (acc, item) => acc + item,\n   *   ''\n   * );\n   * console.log(result); // 'cba'\n   * ```\n   */\n  async reduceRight<T, R>(\n    array: T[],\n    reducer: SerializableFunction,\n    initialValue: R,\n    options: ThreadOptions = {}\n  ): Promise<R> {\n    let accumulator = initialValue;\n\n    if (!array.length) {\n      return accumulator;\n    }\n\n    // Process from right to left\n    for (let index = array.length - 1; index >= 0; index--) {\n      accumulator = await this.run<R>(\n        reducer,\n        this.createArgsPayload(accumulator, array[index], index, array),\n        options\n      );\n    }\n\n    return accumulator;\n  }\n\n  /**\n   * Groups array elements by a key returned from the function.\n   * Processes the grouping function in parallel for performance.\n   *\n   * @template T - The type of array elements\n   * @template K - The type of the grouping key\n   * @param array - The array to group\n   * @param keyFn - Function that returns the group key: (item, index, array) => K\n   * @param options - Execution options including batchSize\n   * @returns Map of grouped elements\n   *\n   * @example\n   * ```typescript\n   * const grouped = await threadts.groupBy(\n   *   [{ type: 'a', value: 1 }, { type: 'b', value: 2 }, { type: 'a', value: 3 }],\n   *   (item) => item.type\n   * );\n   * // Map { 'a' => [{type: 'a', value: 1}, {type: 'a', value: 3}], 'b' => [{type: 'b', value: 2}] }\n   * ```\n   */\n  async groupBy<T, K extends string | number | symbol>(\n    array: T[],\n    keyFn: SerializableFunction,\n    options: MapOptions = {}\n  ): Promise<Map<K, T[]>> {\n    if (!array.length) {\n      return new Map();\n    }\n\n    const keys = await this.map<T, K>(array, keyFn, options);\n    const result = new Map<K, T[]>();\n\n    for (let i = 0; i < array.length; i++) {\n      const key = keys[i];\n      if (!result.has(key)) {\n        result.set(key, []);\n      }\n      result.get(key)!.push(array[i]);\n    }\n\n    return result;\n  }\n\n  /**\n   * Partitions an array into two arrays based on a predicate.\n   * Elements that satisfy the predicate go to the first array,\n   * elements that don't go to the second array.\n   *\n   * @template T - The type of array elements\n   * @param array - The array to partition\n   * @param predicate - Function to test each element: (item, index, array) => boolean\n   * @param options - Execution options including batchSize\n   * @returns Tuple of [matching elements, non-matching elements]\n   *\n   * @example\n   * ```typescript\n   * const [evens, odds] = await threadts.partition(\n   *   [1, 2, 3, 4, 5],\n   *   (x) => x % 2 === 0\n   * );\n   * console.log(evens); // [2, 4]\n   * console.log(odds);  // [1, 3, 5]\n   * ```\n   */\n  async partition<T>(\n    array: T[],\n    predicate: SerializableFunction,\n    options: MapOptions = {}\n  ): Promise<[T[], T[]]> {\n    if (!array.length) {\n      return [[], []];\n    }\n\n    const results = await this.map<T, boolean>(array, predicate, options);\n    const truthy: T[] = [];\n    const falsy: T[] = [];\n\n    for (let i = 0; i < array.length; i++) {\n      if (results[i]) {\n        truthy.push(array[i]);\n      } else {\n        falsy.push(array[i]);\n      }\n    }\n\n    return [truthy, falsy];\n  }\n\n  /**\n   * Counts elements that satisfy a predicate.\n   * Like filter().length but more efficient as it doesn't store filtered elements.\n   *\n   * @template T - The type of array elements\n   * @param array - The array to count\n   * @param predicate - Function to test each element: (item, index, array) => boolean\n   * @param options - Execution options including batchSize\n   * @returns The count of matching elements\n   *\n   * @example\n   * ```typescript\n   * const count = await threadts.count(\n   *   [1, 2, 3, 4, 5],\n   *   (x) => x > 2\n   * );\n   * console.log(count); // 3\n   * ```\n   */\n  async count<T>(\n    array: T[],\n    predicate: SerializableFunction,\n    options: MapOptions = {}\n  ): Promise<number> {\n    if (!array.length) {\n      return 0;\n    }\n\n    const results = await this.map<T, boolean>(array, predicate, options);\n    return results.filter(Boolean).length;\n  }\n\n  /**\n   * Creates a pipeline for chaining parallel operations.\n   * Returns a fluent interface for building complex data transformations.\n   *\n   * @template T - The type of initial array elements\n   * @param array - The initial array to process\n   * @returns A Pipeline instance for chaining operations\n   *\n   * @example\n   * ```typescript\n   * const result = await threadts.pipe([1, 2, 3, 4, 5])\n   *   .map((x) => x * 2)\n   *   .filter((x) => x > 4)\n   *   .reduce((acc, x) => acc + x, 0)\n   *   .execute();\n   * console.log(result); // 24 (6 + 8 + 10)\n   * ```\n   */\n  pipe<T>(array: T[]): Pipeline<T> {\n    return new Pipeline<T>(array, this);\n  }\n\n  /**\n   * Executes multiple tasks as a batch with configurable batch size.\n   * Tasks within a batch run in parallel, batches run sequentially.\n   *\n   * @param tasks - Array of tasks to execute\n   * @param batchSize - Number of tasks to run in parallel (default: all)\n   * @returns Array of task results with success/error information\n   *\n   * @example\n   * ```typescript\n   * const results = await threadts.batch([\n   *   { fn: (x) => x * 2, data: 5 },\n   *   { fn: (x) => x + 1, data: 10 }\n   * ], 2);\n   * ```\n   */\n  async batch(\n    tasks: Array<ThreadTask | LegacyTask>,\n    batchSize: number = tasks.length\n  ): Promise<TaskResult[]> {\n    if (!tasks.length) {\n      return [];\n    }\n\n    const normalizedBatchSize = Math.max(1, Math.floor(batchSize));\n    const results: TaskResult[] = [];\n\n    for (let index = 0; index < tasks.length; index += normalizedBatchSize) {\n      const chunk = tasks.slice(index, index + normalizedBatchSize);\n\n      const chunkResults = await Promise.all(\n        chunk.map(async (task) => {\n          try {\n            const normalized = this.normalizeTask(task);\n            const result = await this.run(\n              normalized.fn,\n              normalized.data as\n                SerializableData | InternalArgsPayload | undefined,\n              normalized.options ?? {}\n            );\n\n            return {\n              success: true,\n              result: result as SerializableData,\n              error: null,\n            } satisfies TaskResult;\n          } catch (error) {\n            return {\n              success: false,\n              result: null,\n              error: error instanceof Error ? error.message : String(error),\n            } satisfies TaskResult;\n          }\n        })\n      );\n\n      results.push(...chunkResults);\n    }\n\n    return results;\n  }\n\n  async parallel<T = unknown>(\n    tasks: Array<ThreadTask | LegacyTask>\n  ): Promise<T[]> {\n    const results = await this.batch(tasks);\n    const failures = results.filter((result) => !result.success);\n\n    if (failures.length > 0) {\n      const message = failures\n        .map((failure) => failure.error)\n        .filter((error): error is string => Boolean(error))\n        .join('; ');\n\n      throw new WorkerError(\n        message || 'Parallel execution failed for one or more tasks'\n      );\n    }\n\n    return results.map((result) => result.result as T);\n  }\n\n  async resize(newSize: number): Promise<void> {\n    const oldSize = this.config.poolSize;\n    this.config.poolSize = newSize;\n    this.emitEvent('pool-resize', { oldSize, newSize });\n  }\n\n  getPoolSize(): number {\n    return this.config.poolSize;\n  }\n\n  getActiveWorkers(): number {\n    return 0;\n  }\n\n  getQueueLength(): number {\n    return 0; // Simplified\n  }\n\n  isInitialized(): boolean {\n    return this.isReady;\n  }\n\n  getConfig(): ThreadConfig {\n    return { ...this.config };\n  }\n\n  updateConfig(newConfig: Partial<ThreadConfig>): void {\n    this.config = { ...this.config, ...newConfig };\n  }\n\n  getStats(): {\n    activeWorkers: number;\n    idleWorkers: number;\n    queuedTasks: number;\n    completedTasks: number;\n    averageExecutionTime: number;\n  } {\n    return {\n      activeWorkers: this.getActiveWorkers(),\n      idleWorkers: Math.max(0, this.config.poolSize - this.getActiveWorkers()),\n      queuedTasks: this.getQueueLength(),\n      completedTasks: this.completedTasks,\n      averageExecutionTime:\n        this.completedTasks > 0\n          ? this.totalExecutionTime / this.completedTasks\n          : 0,\n    };\n  }\n\n  getPlatform(): string {\n    return PlatformUtils.detectPlatform();\n  }\n\n  isSupported(): boolean {\n    return PlatformUtils.supportsWorkerThreads();\n  }\n\n  private generateTaskId(): string {\n    return `task-${++this.taskCounter}-${Date.now()}`;\n  }\n\n  async terminate(): Promise<void> {\n    this.isReady = false;\n    this.completedTasks = 0;\n    this.failedTasks = 0;\n    this.totalExecutionTime = 0;\n    this.taskCounter = 0;\n    this.eventListeners.clear();\n\n    if (ThreadTS._instance === this) {\n      ThreadTS._instance = null;\n    }\n  }\n\n  static async terminateAll(): Promise<void> {\n    if (ThreadTS._instance) {\n      await ThreadTS._instance.terminate();\n    }\n  }\n\n  // Static methods for backward compatibility\n  static async run<T = unknown>(\n    func: SerializableFunction,\n    data?: SerializableData,\n    options: ThreadOptions = {}\n  ): Promise<T> {\n    const instance = ThreadTS.getInstance();\n    return instance.run<T>(func, data, options);\n  }\n\n  static async map<T, R = T>(\n    array: T[],\n    func: SerializableFunction,\n    options: MapOptions = {}\n  ): Promise<R[]> {\n    const instance = ThreadTS.getInstance();\n    return instance.map<T, R>(array, func, options);\n  }\n\n  static async filter<T>(\n    array: T[],\n    func: SerializableFunction,\n    options: MapOptions = {}\n  ): Promise<T[]> {\n    const instance = ThreadTS.getInstance();\n    return instance.filter(array, func, options);\n  }\n\n  static async reduce<T, R>(\n    array: T[],\n    func: SerializableFunction,\n    initialValue: R,\n    options: ThreadOptions = {}\n  ): Promise<R> {\n    const instance = ThreadTS.getInstance();\n    return instance.reduce(array, func, initialValue, options);\n  }\n\n  static async forEach<T>(\n    array: T[],\n    func: SerializableFunction,\n    options: MapOptions = {}\n  ): Promise<void> {\n    const instance = ThreadTS.getInstance();\n    return instance.forEach(array, func, options);\n  }\n\n  /**\n   * Static method to find the first element satisfying the predicate.\n   * @see {@link ThreadTS.find} for instance method documentation\n   */\n  static async find<T>(\n    array: T[],\n    predicate: SerializableFunction,\n    options: MapOptions = {}\n  ): Promise<T | undefined> {\n    const instance = ThreadTS.getInstance();\n    return instance.find(array, predicate, options);\n  }\n\n  /**\n   * Static method to find the index of the first element satisfying the predicate.\n   * @see {@link ThreadTS.findIndex} for instance method documentation\n   */\n  static async findIndex<T>(\n    array: T[],\n    predicate: SerializableFunction,\n    options: MapOptions = {}\n  ): Promise<number> {\n    const instance = ThreadTS.getInstance();\n    return instance.findIndex(array, predicate, options);\n  }\n\n  /**\n   * Static method to test if any element satisfies the predicate.\n   * @see {@link ThreadTS.some} for instance method documentation\n   */\n  static async some<T>(\n    array: T[],\n    predicate: SerializableFunction,\n    options: MapOptions = {}\n  ): Promise<boolean> {\n    const instance = ThreadTS.getInstance();\n    return instance.some(array, predicate, options);\n  }\n\n  /**\n   * Static method to test if all elements satisfy the predicate.\n   * @see {@link ThreadTS.every} for instance method documentation\n   */\n  static async every<T>(\n    array: T[],\n    predicate: SerializableFunction,\n    options: MapOptions = {}\n  ): Promise<boolean> {\n    const instance = ThreadTS.getInstance();\n    return instance.every(array, predicate, options);\n  }\n\n  static async batch(\n    tasks: Array<ThreadTask | LegacyTask>,\n    batchSize?: number\n  ): Promise<TaskResult[]> {\n    const instance = ThreadTS.getInstance();\n    return instance.batch(tasks, batchSize);\n  }\n\n  static async parallel<T = unknown>(\n    tasks: Array<ThreadTask | LegacyTask>\n  ): Promise<T[]> {\n    const instance = ThreadTS.getInstance();\n    return instance.parallel(tasks);\n  }\n\n  static async resize(newSize: number): Promise<void> {\n    const instance = ThreadTS.getInstance();\n    return instance.resize(newSize);\n  }\n\n  static getPoolSize(): number {\n    const instance = ThreadTS.getInstance();\n    return instance.getPoolSize();\n  }\n\n  static getActiveWorkers(): number {\n    const instance = ThreadTS.getInstance();\n    return instance.getActiveWorkers();\n  }\n\n  static getQueueLength(): number {\n    const instance = ThreadTS.getInstance();\n    return instance.getQueueLength();\n  }\n\n  static isInitialized(): boolean {\n    const instance = ThreadTS.getInstance();\n    return instance.isInitialized();\n  }\n\n  static getConfig(): ThreadConfig {\n    const instance = ThreadTS.getInstance();\n    return instance.getConfig();\n  }\n\n  static updateConfig(newConfig: Partial<ThreadConfig>): void {\n    const instance = ThreadTS.getInstance();\n    return instance.updateConfig(newConfig);\n  }\n\n  static getStats(): {\n    activeWorkers: number;\n    idleWorkers: number;\n    queuedTasks: number;\n    completedTasks: number;\n    averageExecutionTime: number;\n  } {\n    const instance = ThreadTS.getInstance();\n    return instance.getStats();\n  }\n\n  static getPlatform(): string {\n    return PlatformUtils.detectPlatform();\n  }\n\n  static isSupported(): boolean {\n    return PlatformUtils.supportsWorkerThreads();\n  }\n\n  /**\n   * Static method to create a flatMap operation.\n   * @see {@link ThreadTS.flatMap} for instance method documentation\n   */\n  static async flatMap<T, R>(\n    array: T[],\n    func: SerializableFunction,\n    options: MapOptions = {}\n  ): Promise<R[]> {\n    const instance = ThreadTS.getInstance();\n    return instance.flatMap<T, R>(array, func, options);\n  }\n\n  /**\n   * Static method to reduce an array from right to left.\n   * @see {@link ThreadTS.reduceRight} for instance method documentation\n   */\n  static async reduceRight<T, R>(\n    array: T[],\n    reducer: SerializableFunction,\n    initialValue: R,\n    options: ThreadOptions = {}\n  ): Promise<R> {\n    const instance = ThreadTS.getInstance();\n    return instance.reduceRight<T, R>(array, reducer, initialValue, options);\n  }\n\n  /**\n   * Static method to group array elements by a key.\n   * @see {@link ThreadTS.groupBy} for instance method documentation\n   */\n  static async groupBy<T, K extends string | number | symbol>(\n    array: T[],\n    keyFn: SerializableFunction,\n    options: MapOptions = {}\n  ): Promise<Map<K, T[]>> {\n    const instance = ThreadTS.getInstance();\n    return instance.groupBy<T, K>(array, keyFn, options);\n  }\n\n  /**\n   * Static method to partition an array into two arrays.\n   * @see {@link ThreadTS.partition} for instance method documentation\n   */\n  static async partition<T>(\n    array: T[],\n    predicate: SerializableFunction,\n    options: MapOptions = {}\n  ): Promise<[T[], T[]]> {\n    const instance = ThreadTS.getInstance();\n    return instance.partition<T>(array, predicate, options);\n  }\n\n  /**\n   * Static method to count elements matching a predicate.\n   * @see {@link ThreadTS.count} for instance method documentation\n   */\n  static async count<T>(\n    array: T[],\n    predicate: SerializableFunction,\n    options: MapOptions = {}\n  ): Promise<number> {\n    const instance = ThreadTS.getInstance();\n    return instance.count<T>(array, predicate, options);\n  }\n\n  /**\n   * Static method to create a pipeline for chaining operations.\n   * @see {@link ThreadTS.pipe} for instance method documentation\n   */\n  static pipe<T>(array: T[]): Pipeline<T> {\n    const instance = ThreadTS.getInstance();\n    return instance.pipe<T>(array);\n  }\n\n  // ==================== Static Extended Array Methods ====================\n\n  /**\n   * Static method to find the index of an element.\n   * @see {@link ThreadTS.indexOf} for instance method documentation\n   */\n  static async indexOf<T>(\n    array: T[],\n    searchElement: T,\n    fromIndex = 0\n  ): Promise<number> {\n    const instance = ThreadTS.getInstance();\n    return instance.indexOf(array, searchElement, fromIndex);\n  }\n\n  /**\n   * Static method to find the last index of an element.\n   * @see {@link ThreadTS.lastIndexOf} for instance method documentation\n   */\n  static async lastIndexOf<T>(\n    array: T[],\n    searchElement: T,\n    fromIndex?: number\n  ): Promise<number> {\n    const instance = ThreadTS.getInstance();\n    return instance.lastIndexOf(array, searchElement, fromIndex);\n  }\n\n  /**\n   * Static method to get an element at a specific index.\n   * @see {@link ThreadTS.at} for instance method documentation\n   */\n  static async at<T>(array: T[], index: number): Promise<T | undefined> {\n    const instance = ThreadTS.getInstance();\n    return instance.at(array, index);\n  }\n\n  /**\n   * Static method to slice an array.\n   * @see {@link ThreadTS.slice} for instance method documentation\n   */\n  static async slice<T>(\n    array: T[],\n    start?: number,\n    end?: number\n  ): Promise<T[]> {\n    const instance = ThreadTS.getInstance();\n    return instance.slice(array, start, end);\n  }\n\n  /**\n   * Static method to concatenate arrays.\n   * @see {@link ThreadTS.concat} for instance method documentation\n   */\n  static async concat<T>(array: T[], ...items: (T | T[])[]): Promise<T[]> {\n    const instance = ThreadTS.getInstance();\n    return instance.concat(array, ...items);\n  }\n\n  /**\n   * Static method to create a range of numbers.\n   * @see {@link ThreadTS.range} for instance method documentation\n   */\n  static async range(start: number, end: number, step = 1): Promise<number[]> {\n    const instance = ThreadTS.getInstance();\n    return instance.range(start, end, step);\n  }\n\n  /**\n   * Static method to repeat a value.\n   * @see {@link ThreadTS.repeat} for instance method documentation\n   */\n  static async repeat<T>(value: T, count: number): Promise<T[]> {\n    const instance = ThreadTS.getInstance();\n    return instance.repeat(value, count);\n  }\n\n  /**\n   * Static method to get unique values.\n   * @see {@link ThreadTS.unique} for instance method documentation\n   */\n  static async unique<T>(array: T[]): Promise<T[]> {\n    const instance = ThreadTS.getInstance();\n    return instance.unique(array);\n  }\n\n  /**\n   * Static method to get unique values by key.\n   * @see {@link ThreadTS.uniqueBy} for instance method documentation\n   */\n  static async uniqueBy<T, K>(array: T[], keyFn: (item: T) => K): Promise<T[]> {\n    const instance = ThreadTS.getInstance();\n    return instance.uniqueBy(array, keyFn);\n  }\n\n  /**\n   * Static method to chunk an array.\n   * @see {@link ThreadTS.chunk} for instance method documentation\n   */\n  static async chunk<T>(array: T[], size: number): Promise<T[][]> {\n    const instance = ThreadTS.getInstance();\n    return instance.chunk(array, size);\n  }\n\n  /**\n   * Static method to zip arrays.\n   * @see {@link ThreadTS.zip} for instance method documentation\n   */\n  static async zip<T extends unknown[][]>(\n    ...arrays: T\n  ): Promise<{ [K in keyof T]: T[K] extends (infer U)[] ? U : never }[]> {\n    const instance = ThreadTS.getInstance();\n    return instance.zip(...arrays);\n  }\n\n  /**\n   * Static method to get the array operations module.\n   * @see {@link ThreadTS.getArrayOps} for instance method documentation\n   */\n  static getArrayOps(): ArrayOperations {\n    const instance = ThreadTS.getInstance();\n    return instance.getArrayOps();\n  }\n}\n\n// Re-export Pipeline classes from pipeline module\nexport { Pipeline, TerminalPipeline };\n\nexport default ThreadTS;\n","/**\n * ThreadTS Universal - Decorator Utilities\n *\n * Shared utilities for creating decorators that work with both\n * legacy (experimentalDecorators) and Stage-3 decorator syntax.\n *\n * @module decorators/utils\n * @author ThreadTS Universal Team\n */\n\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport type AnyFunction = (...args: any[]) => any;\n\n/**\n * Type for Stage-3 decorator context.\n * Provides metadata about the decorated element.\n */\nexport interface DecoratorContext {\n  /** The kind of element being decorated */\n  kind: 'method' | 'getter' | 'setter' | 'field' | 'class' | 'accessor';\n  /** The name of the decorated element */\n  name: string | symbol;\n  /** Whether the element is static */\n  static: boolean;\n  /** Whether the element is private */\n  private: boolean;\n  /** Access object for getting/setting the value */\n  access?: {\n    get?(): unknown;\n    set?(value: unknown): void;\n  };\n  /** Function to add an initializer */\n  addInitializer?(initializer: () => void): void;\n}\n\n/**\n * Return type for decorated methods.\n * Can be the wrapped function or a property descriptor.\n */\nexport type DecoratorReturnType<T extends AnyFunction> =\n  T | PropertyDescriptor | void;\n\n/**\n * Helper to create method decorators compatible with both legacy and Stage-3 syntax.\n *\n * This factory function abstracts away the differences between the two decorator\n * syntaxes, allowing decorator authors to focus on the decoration logic.\n *\n * @template T - The function type being decorated\n * @param decoratorLogic - Function that wraps the original method\n * @returns A decorator function that works with both syntaxes\n *\n * @example\n * ```typescript\n * // Creating a simple logging decorator\n * function logCalls() {\n *   return createMethodDecorator((originalMethod, methodName) => {\n *     return async function(...args: unknown[]) {\n *       console.log(`Calling ${methodName}`);\n *       const result = await originalMethod.apply(this, args);\n *       console.log(`${methodName} returned:`, result);\n *       return result;\n *     } as typeof originalMethod;\n *   });\n * }\n * ```\n */\nexport function createMethodDecorator<T extends AnyFunction>(\n  decoratorLogic: (originalMethod: T, methodName: string) => T\n): (\n  targetOrMethod: unknown,\n  propertyKeyOrContext?: string | symbol | DecoratorContext,\n  descriptor?: PropertyDescriptor\n) => DecoratorReturnType<T> {\n  return function (\n    targetOrMethod: unknown,\n    propertyKeyOrContext?: string | symbol | DecoratorContext,\n    descriptor?: PropertyDescriptor\n  ): DecoratorReturnType<T> {\n    // Stage-3 decorator syntax: (method, context)\n    if (\n      typeof targetOrMethod === 'function' &&\n      propertyKeyOrContext &&\n      typeof propertyKeyOrContext === 'object' &&\n      'kind' in propertyKeyOrContext\n    ) {\n      const context = propertyKeyOrContext as DecoratorContext;\n      if (context.kind !== 'method') {\n        throw new Error('Decorator can only be applied to methods');\n      }\n      const methodName = String(context.name);\n      return decoratorLogic(targetOrMethod as T, methodName);\n    }\n\n    // Legacy decorator syntax: (target, propertyKey, descriptor)\n    if (descriptor && typeof descriptor.value === 'function') {\n      const methodName = String(propertyKeyOrContext);\n      descriptor.value = decoratorLogic(descriptor.value as T, methodName);\n      return descriptor;\n    }\n\n    throw new Error('Decorator can only be applied to methods');\n  };\n}\n\n/**\n * Helper to create method decorators that also receive the class name.\n * Compatible with both legacy and Stage-3 syntax.\n *\n * This is useful for logging and observability decorators that need\n * to know which class the method belongs to.\n *\n * @template T - The function type being decorated\n * @param decoratorLogic - Function that wraps the original method, receiving class name\n * @returns A decorator function that works with both syntaxes\n *\n * @example\n * ```typescript\n * function logMethod() {\n *   return createMethodDecoratorWithClass((method, methodName, className) => {\n *     return async function(...args: unknown[]) {\n *       console.log(`[${className}.${methodName}] called`);\n *       return method.apply(this, args);\n *     } as typeof method;\n *   });\n * }\n * ```\n */\nexport function createMethodDecoratorWithClass<T extends AnyFunction>(\n  decoratorLogic: (\n    originalMethod: T,\n    methodName: string,\n    className: string\n  ) => T\n): (\n  targetOrMethod: unknown,\n  propertyKeyOrContext?: string | symbol | DecoratorContext,\n  descriptor?: PropertyDescriptor\n) => DecoratorReturnType<T> {\n  return function (\n    targetOrMethod: unknown,\n    propertyKeyOrContext?: string | symbol | DecoratorContext,\n    descriptor?: PropertyDescriptor\n  ): DecoratorReturnType<T> {\n    // Stage-3 decorator syntax: (method, context)\n    if (\n      typeof targetOrMethod === 'function' &&\n      propertyKeyOrContext &&\n      typeof propertyKeyOrContext === 'object' &&\n      'kind' in propertyKeyOrContext\n    ) {\n      const context = propertyKeyOrContext as DecoratorContext;\n      if (context.kind !== 'method') {\n        throw new Error('Decorator can only be applied to methods');\n      }\n      const methodName = String(context.name);\n      // In Stage-3, class name isn't directly available in context\n      return decoratorLogic(targetOrMethod as T, methodName, 'Unknown');\n    }\n\n    // Legacy decorator syntax: (target, propertyKey, descriptor)\n    if (descriptor && typeof descriptor.value === 'function') {\n      const methodName = String(propertyKeyOrContext);\n      const className =\n        (targetOrMethod as { constructor?: { name?: string } })?.constructor\n          ?.name || 'Unknown';\n      descriptor.value = decoratorLogic(\n        descriptor.value as T,\n        methodName,\n        className\n      );\n      return descriptor;\n    }\n\n    throw new Error('Decorator can only be applied to methods');\n  };\n}\n\n/**\n * Helper to create class decorators compatible with both legacy and Stage-3 syntax.\n *\n * @template T - The class constructor type\n * @param decoratorLogic - Function that wraps the original class\n * @returns A decorator function that works with both syntaxes\n */\nexport function createClassDecorator<\n  T extends new (...args: unknown[]) => object,\n>(\n  decoratorLogic: (originalClass: T, className: string) => T\n): (target: T) => T {\n  return function (target: T): T {\n    const className = target.name || 'AnonymousClass';\n    return decoratorLogic(target, className);\n  };\n}\n\n/**\n * Type guard to check if a value is an async function.\n *\n * @param fn - The value to check\n * @returns true if the value is an async function\n */\nexport function isAsyncFunction(\n  fn: unknown\n): fn is (...args: unknown[]) => Promise<unknown> {\n  return (\n    typeof fn === 'function' &&\n    (fn.constructor.name === 'AsyncFunction' ||\n      fn.toString().startsWith('async'))\n  );\n}\n\n/**\n * Ensures a function returns a Promise.\n * Wraps synchronous functions to return Promise.resolve(result).\n *\n * @param fn - The function to wrap\n * @returns A function that always returns a Promise\n */\nexport function ensureAsync<T extends AnyFunction>(\n  fn: T\n): (...args: Parameters<T>) => Promise<ReturnType<T>> {\n  return async function (\n    this: unknown,\n    ...args: Parameters<T>\n  ): Promise<ReturnType<T>> {\n    return fn.apply(this, args);\n  };\n}\n","/**\n * ThreadTS Universal - Parallel Decorators\n *\n * Decorators for automatic parallelization of method execution.\n * Supports both legacy (experimentalDecorators) and Stage-3 decorator syntax.\n *\n * @module decorators/parallel\n */\n\nimport { ThreadTS } from '../core/threadts';\nimport type { ParallelMethodOptions } from '../types';\nimport { createMethodDecorator } from './utils';\n\n/**\n * Method decorator that automatically parallelizes method execution\n */\nexport function parallelMethod(options: ParallelMethodOptions = {}) {\n  // Cache for results if enabled\n  const resultCache = new Map<string, unknown>();\n\n  return createMethodDecorator((originalMethod) => {\n    const wrappedMethod = async function (\n      this: unknown,\n      ...args: unknown[]\n    ): Promise<unknown> {\n      // Generate cache key if caching is enabled\n      const cacheKey = options.cacheResults ? JSON.stringify(args) : null;\n\n      // Check cache first\n      if (cacheKey && resultCache.has(cacheKey)) {\n        return resultCache.get(cacheKey);\n      }\n\n      // Create thread pool instance with custom config if specified\n      const threadts = options.poolSize\n        ? ThreadTS.getInstance({ poolSize: options.poolSize })\n        : ThreadTS.getInstance();\n\n      // Execute method in worker thread\n      const result = await threadts.run(\n        originalMethod,\n        { context: this, args },\n        {\n          timeout: options.timeout,\n          maxRetries: options.maxRetries,\n          priority: options.priority,\n        }\n      );\n\n      // Cache result if enabled\n      if (cacheKey && options.cacheResults) {\n        resultCache.set(cacheKey, result);\n      }\n\n      return result;\n    };\n\n    return wrappedMethod as typeof originalMethod;\n  });\n}\n\n/**\n * Class decorator that auto-parallelizes all marked methods\n */\nexport function parallelClass() {\n  return function <T extends new (...args: unknown[]) => object>(\n    constructor: T\n  ): T {\n    const parallelMethods =\n      (constructor as unknown as { parallelMethods?: string[] })\n        .parallelMethods || [];\n\n    // Return the same constructor but with modified prototype methods\n    for (const methodName of parallelMethods) {\n      const originalMethod = constructor.prototype[methodName];\n      if (typeof originalMethod === 'function') {\n        constructor.prototype[methodName] = async function (\n          ...args: unknown[]\n        ) {\n          const threadts = ThreadTS.getInstance();\n          return threadts.run(originalMethod.bind(this), args);\n        };\n      }\n    }\n\n    return constructor;\n  };\n}\n\n/**\n * Mark a method for auto-parallelization in parallel classes\n */\nexport function parallel() {\n  return createMethodDecorator((originalMethod) => {\n    (originalMethod as { _parallel?: boolean })._parallel = true;\n    return originalMethod;\n  });\n}\n\n/**\n * Decorator for parallel computation with automatic batching\n */\nexport function parallelBatch(batchSize: number = 4) {\n  return createMethodDecorator((originalMethod) => {\n    const wrappedMethod = async function (\n      this: unknown,\n      data: unknown[],\n      ...otherArgs: unknown[]\n    ): Promise<unknown[]> {\n      if (!Array.isArray(data)) {\n        throw new Error('First argument must be an array for @parallelBatch');\n      }\n\n      const threadts = ThreadTS.getInstance();\n\n      // Split data into batches\n      const batches: unknown[][] = [];\n      for (let i = 0; i < data.length; i += batchSize) {\n        batches.push(data.slice(i, i + batchSize));\n      }\n\n      // Process each batch in parallel\n      const batchPromises = batches.map((batch) =>\n        threadts.run(originalMethod.bind(this), [batch, ...otherArgs])\n      );\n\n      const batchResults = await Promise.all(batchPromises);\n      return batchResults.flat();\n    };\n\n    return wrappedMethod as typeof originalMethod;\n  });\n}\n\n/**\n * Decorator for parallel map operations\n */\nexport function parallelMap() {\n  return createMethodDecorator((originalMethod) => {\n    const wrappedMethod = async function (\n      this: unknown,\n      data: unknown[]\n    ): Promise<unknown[]> {\n      if (!Array.isArray(data)) {\n        throw new Error('First argument must be an array for @parallelMap');\n      }\n\n      const threadts = ThreadTS.getInstance();\n\n      // Execute parallel operations using Promise.all for parallel execution\n      const promises = data.map((item) =>\n        threadts.run(originalMethod.bind(this), [item])\n      );\n\n      return Promise.all(promises);\n    };\n\n    return wrappedMethod as typeof originalMethod;\n  });\n}\n","/**\n * ThreadTS Universal - Cache Utilities\n *\n * Shared cache implementations for decorators.\n * Follows the DRY principle by extracting common cache logic.\n *\n * @module utils/cache\n * @author ThreadTS Universal Team\n */\n\n/**\n * Cache entry containing a value and an optional expiration timestamp.\n *\n * @template T - Type of the cached value\n */\nexport interface CacheEntry<T> {\n  /** Cached value */\n  value: T;\n  /** Expiration timestamp in milliseconds (optional) */\n  expiry?: number;\n}\n\n/**\n * Configuration for the LRU cache.\n */\nexport interface LRUCacheConfig {\n  /** Maximum number of entries in the cache */\n  maxSize: number;\n  /** Time-to-live in milliseconds (optional, 0 = no expiration) */\n  ttlMs?: number;\n}\n\n/**\n * LRU (Least Recently Used) Cache Implementierung.\n *\n * Features:\n * - Bounded size with automatic eviction\n * - Optional TTL (time-to-live) for entries\n * - Efficient O(1) operations via a Map-based implementation\n *\n * @template K - Key type\n * @template V - Value type\n *\n * @example\n * ```typescript\n * const cache = new LRUCache<string, number>({ maxSize: 100, ttlMs: 60000 });\n * cache.set('key1', 42);\n * const value = cache.get('key1'); // 42\n * ```\n */\nexport class LRUCache<K, V> {\n  /** Internal map for cache entries */\n  private readonly cache: Map<K, CacheEntry<V>>;\n\n  /** Maximum cache size */\n  private readonly maxSize: number;\n\n  /** Time-to-live in milliseconds (0 = no expiration) */\n  private readonly ttlMs: number;\n\n  /**\n   * Creates a new LRU cache.\n   *\n   * @param config - Cache configuration\n   */\n  constructor(config: LRUCacheConfig) {\n    this.cache = new Map();\n    this.maxSize = Math.max(1, config.maxSize);\n    this.ttlMs = config.ttlMs ?? 0;\n  }\n\n  /**\n   * Retrieves a value from the cache.\n   *\n   * Updates the LRU order (most recently used -> end of the Map).\n   * Returns undefined if the key does not exist or has expired.\n   *\n   * @param key - The key\n   * @returns The cached value or undefined\n   */\n  get(key: K): V | undefined {\n    const entry = this.cache.get(key);\n\n    if (!entry) {\n      return undefined;\n    }\n\n    // Check expiration\n    if (entry.expiry !== undefined && Date.now() > entry.expiry) {\n      this.cache.delete(key);\n      return undefined;\n    }\n\n    // LRU update: move entry to the end\n    this.cache.delete(key);\n    this.cache.set(key, entry);\n\n    return entry.value;\n  }\n\n  /**\n   * Stores a value in the cache.\n   *\n   * When reaching maximum capacity, the oldest entry is evicted.\n   *\n   * @param key - The key\n   * @param value - The value to store\n   */\n  set(key: K, value: V): void {\n    // If the key already exists, delete it (to maintain correct LRU ordering)\n    if (this.cache.has(key)) {\n      this.cache.delete(key);\n    }\n\n    // Evict oldest entry when at capacity\n    if (this.cache.size >= this.maxSize) {\n      const oldestKey = this.cache.keys().next().value;\n      if (oldestKey !== undefined) {\n        this.cache.delete(oldestKey);\n      }\n    }\n\n    // Add new entry\n    const entry: CacheEntry<V> = {\n      value,\n      expiry: this.ttlMs > 0 ? Date.now() + this.ttlMs : undefined,\n    };\n    this.cache.set(key, entry);\n  }\n\n  /**\n   * Checks whether a key exists in the cache and is still valid.\n   *\n   * @param key - The key\n   * @returns true if the key exists and has not expired\n   */\n  has(key: K): boolean {\n    const entry = this.cache.get(key);\n\n    if (!entry) {\n      return false;\n    }\n\n    // Check expiration\n    if (entry.expiry !== undefined && Date.now() > entry.expiry) {\n      this.cache.delete(key);\n      return false;\n    }\n\n    return true;\n  }\n\n  /**\n   * Removes an entry from the cache.\n   *\n   * @param key - The key to remove\n   * @returns true if the key existed and was removed\n   */\n  delete(key: K): boolean {\n    return this.cache.delete(key);\n  }\n\n  /**\n   * Clears the entire cache.\n   */\n  clear(): void {\n    this.cache.clear();\n  }\n\n  /**\n   * Returns the current number of entries.\n   *\n   * @returns Number of entries in the cache\n   */\n  get size(): number {\n    return this.cache.size;\n  }\n\n  /**\n   * Removes all expired entries from the cache.\n   *\n   * This method is not called automatically to avoid impacting get/set\n   * performance. Call it manually if needed (e.g. periodically).\n   *\n   * @returns Number of removed entries\n   */\n  prune(): number {\n    if (this.ttlMs === 0) {\n      return 0;\n    }\n\n    const now = Date.now();\n    let removed = 0;\n\n    for (const [key, entry] of this.cache) {\n      if (entry.expiry !== undefined && now > entry.expiry) {\n        this.cache.delete(key);\n        removed++;\n      }\n    }\n\n    return removed;\n  }\n\n  /**\n   * Returns cache statistics.\n   *\n   * @returns Cache statistics object\n   */\n  stats(): CacheStats {\n    return {\n      size: this.cache.size,\n      maxSize: this.maxSize,\n      ttlMs: this.ttlMs,\n    };\n  }\n}\n\n/**\n * Cache statistics.\n */\nexport interface CacheStats {\n  /** Current number of entries */\n  size: number;\n  /** Maximum number of entries */\n  maxSize: number;\n  /** Time-to-live in milliseconds */\n  ttlMs: number;\n}\n\n/**\n * Creates a string cache key from function arguments.\n *\n * Uses JSON.stringify for serializable arguments.\n * Warning: functions and circular references are not supported.\n *\n * @param args - Arguments to serialize\n * @returns A string key for the cache\n *\n * @example\n * ```typescript\n * const key = createCacheKey([1, 'test', { a: 1 }]);\n * // '[[1,\"test\",{\"a\":1}]]' or similar\n * ```\n */\nexport function createCacheKey(args: unknown[]): string {\n  try {\n    return JSON.stringify(args);\n  } catch {\n    // Fallback for non-serializable values\n    return args.map((arg) => String(arg)).join('::');\n  }\n}\n\n/**\n * Lazy initialization state.\n *\n * Manages state for one-time initialization with support for concurrent\n * callers while initialization is in progress.\n *\n * @template T - Type of the initialized value\n */\nexport class LazyInitializer<T> {\n  /** Initialized value */\n  private value: T | undefined = undefined;\n\n  /** Whether initialization has completed */\n  private initialized = false;\n\n  /** Promise for ongoing initialization (prevents race conditions) */\n  private initializing: Promise<T> | null = null;\n\n  /**\n   * Returns the value, initializing it if needed.\n   *\n   * If called concurrently while initialization is in progress, the same\n   * Promise is returned to prevent duplicate initialization.\n   *\n   * @param initializer - Function that initializes the value\n   * @returns Promise resolving to the initialized value\n   */\n  async get(initializer: () => Promise<T>): Promise<T> {\n    // Already initialized?\n    if (this.initialized) {\n      return this.value as T;\n    }\n\n    // Initialization already in progress?\n    if (this.initializing !== null) {\n      return this.initializing;\n    }\n\n    // Start a new initialization\n    this.initializing = (async () => {\n      try {\n        this.value = await initializer();\n        this.initialized = true;\n        return this.value;\n      } finally {\n        this.initializing = null;\n      }\n    })();\n\n    return this.initializing;\n  }\n\n  /**\n   * Resets the lazy state.\n   *\n   * After reset, the next call to get() will initialize again.\n   */\n  reset(): void {\n    this.value = undefined;\n    this.initialized = false;\n    this.initializing = null;\n  }\n\n  /**\n   * Checks whether the value has already been initialized.\n   *\n   * @returns true if initialized\n   */\n  isInitialized(): boolean {\n    return this.initialized;\n  }\n}\n","/**\n * ThreadTS Universal - Caching Decorators\n *\n * Decorators for caching and memoization of method results.\n * Supports both legacy (experimentalDecorators) and Stage-3 decorator syntax.\n *\n * Uses the shared LRUCache class for consistent caching behavior\n * and follows the DRY principle (Don't Repeat Yourself).\n *\n * @module decorators/caching\n * @author ThreadTS Universal Team\n */\n\nimport { createCacheKey, LazyInitializer, LRUCache } from '../utils/cache';\nimport { createMethodDecorator } from './utils';\n\n/**\n * Type for augmented methods with cache controls.\n */\nexport interface CacheableMethod {\n  /** Clears the method's cache */\n  clearCache?: () => void;\n  /** Returns cache statistics */\n  getCacheStats?: () => { size: number; maxSize: number };\n}\n\n/**\n * Type for augmented methods with reset controls.\n */\nexport interface LazyMethod {\n  /** Resets the lazy state */\n  reset?: () => void;\n  /** Checks whether it's already initialized */\n  isInitialized?: () => boolean;\n}\n\n/**\n * Decorator for memoization with an optional cache size limit.\n *\n * Caches method results based on arguments. If called with the same\n * arguments, the cached result is returned. Uses LRU (Least Recently Used)\n * eviction when the maximum size is reached.\n *\n * @param maxCacheSize - Maximum number of cached entries (default: 100)\n * @returns Method Decorator\n *\n * @example\n * ```typescript\n * class Calculator {\n *   @memoize(50) // Cache up to 50 inputs\n *   async computeExpensive(input: number): Promise<number> {\n *     // Expensive computation...\n *     return result;\n *   }\n * }\n * ```\n */\nexport function memoize(maxCacheSize: number = 100) {\n  // Use the shared LRUCache class\n  const lruCache = new LRUCache<string, unknown>({\n    maxSize: maxCacheSize,\n    ttlMs: 0, // No expiration for memoize\n  });\n\n  return createMethodDecorator((originalMethod) => {\n    const wrappedMethod = async function (\n      this: unknown,\n      ...args: unknown[]\n    ): Promise<unknown> {\n      const key = createCacheKey(args);\n\n      // Check cache hit\n      if (lruCache.has(key)) {\n        return lruCache.get(key);\n      }\n\n      // Execute method and cache\n      const result = await originalMethod.apply(this, args);\n      lruCache.set(key, result);\n      return result;\n    };\n\n    // Augment method with cache controls\n    const cacheableMethod = wrappedMethod as typeof originalMethod &\n      CacheableMethod;\n    cacheableMethod.clearCache = () => lruCache.clear();\n    cacheableMethod.getCacheStats = () => ({\n      size: lruCache.size,\n      maxSize: maxCacheSize,\n    });\n\n    return cacheableMethod;\n  });\n}\n\n/**\n * Decorator for caching with TTL (time-to-live) support.\n *\n * Similar to memoize, but with automatic expiration of cache entries.\n * Ideal for data that may change periodically.\n *\n * @param ttlMs - Time-to-live in milliseconds (default: 60000 = 1 minute)\n * @param maxSize - Maximum cache size (default: 100)\n * @returns Method Decorator\n *\n * @example\n * ```typescript\n * class DataService {\n *   @cache(30000, 50) // Cache for 30 seconds, max 50 entries\n *   async fetchData(id: string): Promise<Data> {\n *     return await api.getData(id);\n *   }\n *\n *   refreshData(id: string) {\n *     // Manual clear if needed\n *     (this.fetchData as any).clearCache();\n *   }\n * }\n * ```\n */\nexport function cache(ttlMs: number = 60000, maxSize: number = 100) {\n  // Use the shared LRUCache class with TTL\n  const lruCache = new LRUCache<string, unknown>({\n    maxSize,\n    ttlMs,\n  });\n\n  return createMethodDecorator((originalMethod) => {\n    const wrappedMethod = async function (\n      this: unknown,\n      ...args: unknown[]\n    ): Promise<unknown> {\n      const key = createCacheKey(args);\n\n      // Check cache hit (LRUCache handles expiration automatically)\n      const cached = lruCache.get(key);\n      if (cached !== undefined) {\n        return cached;\n      }\n\n      // Execute method and cache\n      const result = await originalMethod.apply(this, args);\n      lruCache.set(key, result);\n      return result;\n    };\n\n    // Augment method with cache controls\n    const cacheableMethod = wrappedMethod as typeof originalMethod &\n      CacheableMethod;\n    cacheableMethod.clearCache = () => lruCache.clear();\n    cacheableMethod.getCacheStats = () => ({\n      size: lruCache.size,\n      maxSize,\n    });\n\n    return cacheableMethod;\n  });\n}\n\n/**\n * Decorator for lazy initialization.\n *\n * The method is executed only once on the first call.\n * All subsequent calls return the stored result.\n * Supports concurrent calls during initialization without race conditions.\n *\n * @returns Method Decorator\n *\n * @example\n * ```typescript\n * class ConfigService {\n *   @lazy()\n *   async loadConfig(): Promise<Config> {\n *     console.log('Loading config...'); // Printed only once\n *     return await fetchConfig();\n *   }\n *\n *   async resetAndReload() {\n *     (this.loadConfig as any).reset();\n *     return await this.loadConfig();\n *   }\n * }\n * ```\n */\nexport function lazy() {\n  // Use the shared LazyInitializer class\n  const initializer = new LazyInitializer<unknown>();\n\n  return createMethodDecorator((originalMethod) => {\n    const wrappedMethod = async function (\n      this: unknown,\n      ...args: unknown[]\n    ): Promise<unknown> {\n      return initializer.get(() => originalMethod.apply(this, args));\n    };\n\n    // Augment method with controls\n    const lazyMethod = wrappedMethod as typeof originalMethod & LazyMethod;\n    lazyMethod.reset = () => initializer.reset();\n    lazyMethod.isInitialized = () => initializer.isInitialized();\n\n    return lazyMethod;\n  });\n}\n","/**\n * ThreadTS Universal - Flow Control Decorators\n *\n * Decorators for controlling method execution flow:\n * retry, rate limiting, timeout, debounce, throttle, circuit breaker, concurrent.\n * Supports both legacy (experimentalDecorators) and Stage-3 decorator syntax.\n *\n * @module decorators/flow-control\n */\n\nimport { createMethodDecorator } from './utils';\n\n/**\n * Decorator for retry logic with exponential backoff\n */\nexport function retry(maxAttempts: number = 3, baseDelay: number = 1000) {\n  return createMethodDecorator((originalMethod) => {\n    const wrappedMethod = async function (\n      this: unknown,\n      ...args: unknown[]\n    ): Promise<unknown> {\n      let lastError: Error = new Error('Max attempts reached');\n\n      for (let attempt = 1; attempt <= maxAttempts; attempt++) {\n        try {\n          return await originalMethod.apply(this, args);\n        } catch (error) {\n          lastError = error instanceof Error ? error : new Error(String(error));\n\n          if (attempt === maxAttempts) {\n            throw lastError;\n          }\n\n          // Exponential backoff\n          const delay = baseDelay * Math.pow(2, attempt - 1);\n          await new Promise((resolve) => setTimeout(resolve, delay));\n        }\n      }\n\n      throw lastError;\n    };\n\n    return wrappedMethod as typeof originalMethod;\n  });\n}\n\n/**\n * Decorator for rate limiting method calls\n */\nexport function rateLimit(callsPerSecond: number = 10) {\n  const queue: Array<{\n    resolve: (value: unknown) => void;\n    reject: (error: Error) => void;\n    args: unknown[];\n    context: unknown;\n  }> = [];\n  const interval = 1000 / callsPerSecond;\n  let lastCall = 0;\n  let processing = false;\n\n  return createMethodDecorator((originalMethod) => {\n    async function processQueue() {\n      if (processing || queue.length === 0) return;\n      processing = true;\n\n      while (queue.length > 0) {\n        const now = Date.now();\n        const timeSinceLastCall = now - lastCall;\n\n        if (timeSinceLastCall >= interval) {\n          const { resolve, reject, args, context } = queue.shift()!;\n          lastCall = Date.now();\n\n          try {\n            const result = await originalMethod.apply(context, args);\n            resolve(result);\n          } catch (error) {\n            reject(error instanceof Error ? error : new Error(String(error)));\n          }\n        } else {\n          // Wait for the remaining time\n          await new Promise((resolve) =>\n            setTimeout(resolve, interval - timeSinceLastCall)\n          );\n        }\n      }\n\n      processing = false;\n    }\n\n    const wrappedMethod = async function (\n      this: unknown,\n      ...args: unknown[]\n    ): Promise<unknown> {\n      return new Promise((resolve, reject) => {\n        queue.push({ resolve, reject, args, context: this });\n        processQueue();\n      });\n    };\n\n    return wrappedMethod as typeof originalMethod;\n  });\n}\n\n/**\n * Decorator for timeout handling\n * Automatically rejects if execution exceeds the specified timeout\n */\nexport function timeout(ms: number = 5000) {\n  return createMethodDecorator((originalMethod) => {\n    const wrappedMethod = async function (\n      this: unknown,\n      ...args: unknown[]\n    ): Promise<unknown> {\n      return Promise.race([\n        originalMethod.apply(this, args),\n        new Promise((_, reject) =>\n          setTimeout(\n            () => reject(new Error(`Operation timed out after ${ms}ms`)),\n            ms\n          )\n        ),\n      ]);\n    };\n\n    return wrappedMethod as typeof originalMethod;\n  });\n}\n\n/**\n * Decorator for debouncing method calls\n * Delays execution until no calls have been made for the specified duration\n */\nexport function debounce(ms: number = 300) {\n  let timeoutId: ReturnType<typeof setTimeout> | null = null;\n  let pendingResolve: ((value: unknown) => void) | null = null;\n  let pendingReject: ((error: Error) => void) | null = null;\n\n  return createMethodDecorator((originalMethod) => {\n    const wrappedMethod = async function (\n      this: unknown,\n      ...args: unknown[]\n    ): Promise<unknown> {\n      return new Promise((resolve, reject) => {\n        // Clear previous timeout and reject pending promise\n        if (timeoutId) {\n          clearTimeout(timeoutId);\n          if (pendingReject) {\n            pendingReject(new Error('Debounced: superseded by new call'));\n          }\n        }\n\n        pendingResolve = resolve;\n        pendingReject = reject;\n\n        timeoutId = setTimeout(async () => {\n          try {\n            const result = await originalMethod.apply(this, args);\n            if (pendingResolve) {\n              pendingResolve(result);\n            }\n          } catch (error) {\n            if (pendingReject) {\n              pendingReject(\n                error instanceof Error ? error : new Error(String(error))\n              );\n            }\n          } finally {\n            timeoutId = null;\n            pendingResolve = null;\n            pendingReject = null;\n          }\n        }, ms);\n      });\n    };\n\n    return wrappedMethod as typeof originalMethod;\n  });\n}\n\n/**\n * Decorator for throttling method calls\n * Ensures the method is called at most once per specified interval\n */\nexport function throttle(ms: number = 300) {\n  let lastCall = 0;\n  let lastResult: unknown = undefined;\n\n  return createMethodDecorator((originalMethod) => {\n    const wrappedMethod = async function (\n      this: unknown,\n      ...args: unknown[]\n    ): Promise<unknown> {\n      const now = Date.now();\n\n      if (now - lastCall >= ms) {\n        lastCall = now;\n        lastResult = await originalMethod.apply(this, args);\n      }\n\n      return lastResult;\n    };\n\n    return wrappedMethod as typeof originalMethod;\n  });\n}\n\n/**\n * Decorator for limiting concurrent executions of a method.\n * Useful for controlling resource usage when calling expensive operations.\n *\n * @param maxConcurrent - Maximum number of concurrent executions (default: 1)\n *\n * @example\n * ```typescript\n * class FileProcessor {\n *   @concurrent(3) // Max 3 concurrent file operations\n *   async processFile(path: string): Promise<void> {\n *     await heavyFileOperation(path);\n *   }\n * }\n * ```\n */\nexport function concurrent(maxConcurrent: number = 1) {\n  let currentCount = 0;\n  const queue: Array<{\n    resolve: () => void;\n    reject: (error: Error) => void;\n  }> = [];\n\n  const tryNext = () => {\n    if (queue.length > 0 && currentCount < maxConcurrent) {\n      currentCount++;\n      const { resolve } = queue.shift()!;\n      resolve();\n    }\n  };\n\n  return createMethodDecorator((originalMethod) => {\n    const wrappedMethod = async function (\n      this: unknown,\n      ...args: unknown[]\n    ): Promise<unknown> {\n      // Wait for a slot to become available\n      if (currentCount >= maxConcurrent) {\n        await new Promise<void>((resolve, reject) => {\n          queue.push({ resolve, reject });\n        });\n      } else {\n        currentCount++;\n      }\n\n      try {\n        return await originalMethod.apply(this, args);\n      } finally {\n        currentCount--;\n        tryNext();\n      }\n    };\n\n    return wrappedMethod as typeof originalMethod;\n  });\n}\n\n/**\n * Circuit breaker state type\n */\nexport type CircuitState = 'closed' | 'open' | 'half-open';\n\n/**\n * Circuit breaker options\n */\nexport interface CircuitBreakerOptions {\n  /** Number of failures before opening circuit (default: 5) */\n  failureThreshold?: number;\n  /** Time in ms before attempting to close circuit (default: 30000) */\n  resetTimeout?: number;\n  /** Number of test requests allowed in half-open state (default: 1) */\n  halfOpenRequests?: number;\n}\n\n/**\n * Decorator for circuit breaker pattern.\n * Prevents repeated calls to a failing service.\n *\n * @param options - Circuit breaker configuration\n *\n * @example\n * ```typescript\n * class ApiService {\n *   @circuitBreaker({ failureThreshold: 5, resetTimeout: 30000 })\n *   async callExternalApi(): Promise<Data> {\n *     return await externalApi.getData();\n *   }\n * }\n * ```\n */\nexport function circuitBreaker(options: CircuitBreakerOptions = {}) {\n  const {\n    failureThreshold = 5,\n    resetTimeout = 30000,\n    halfOpenRequests = 1,\n  } = options;\n\n  let failures = 0;\n  let lastFailureTime = 0;\n  let state: CircuitState = 'closed';\n  let halfOpenAttempts = 0;\n\n  return createMethodDecorator((originalMethod, methodName) => {\n    const wrappedMethod = async function (\n      this: unknown,\n      ...args: unknown[]\n    ): Promise<unknown> {\n      const now = Date.now();\n\n      // Check if circuit should be reset to half-open\n      if (state === 'open' && now - lastFailureTime >= resetTimeout) {\n        state = 'half-open';\n        halfOpenAttempts = 0;\n      }\n\n      // Reject if circuit is open\n      if (state === 'open') {\n        throw new Error(\n          `Circuit breaker is open for ${methodName}. Try again later.`\n        );\n      }\n\n      // Limit requests in half-open state\n      if (state === 'half-open' && halfOpenAttempts >= halfOpenRequests) {\n        throw new Error(\n          `Circuit breaker is half-open for ${methodName}. Too many test requests.`\n        );\n      }\n\n      if (state === 'half-open') {\n        halfOpenAttempts++;\n      }\n\n      try {\n        const result = await originalMethod.apply(this, args);\n\n        // Success - reset failures\n        if (state === 'half-open') {\n          state = 'closed';\n        }\n        failures = 0;\n\n        return result;\n      } catch (error) {\n        failures++;\n        lastFailureTime = now;\n\n        if (state === 'half-open' || failures >= failureThreshold) {\n          state = 'open';\n          console.warn(\n            `Circuit breaker opened for ${methodName} after ${failures} failures`\n          );\n        }\n\n        throw error;\n      }\n    };\n\n    // Add method to get circuit state\n    (wrappedMethod as { getState?: () => CircuitState }).getState = () => state;\n\n    // Add method to reset circuit\n    (wrappedMethod as { reset?: () => void }).reset = () => {\n      state = 'closed';\n      failures = 0;\n      halfOpenAttempts = 0;\n    };\n\n    return wrappedMethod as typeof originalMethod;\n  });\n}\n","/**\n * ThreadTS Universal - Observability Decorators\n *\n * Decorators for logging, measuring, and validating method execution.\n * Supports both legacy (experimentalDecorators) and Stage-3 decorator syntax.\n *\n * @module decorators/observability\n */\n\nimport { createMethodDecorator, createMethodDecoratorWithClass } from './utils';\n\n/**\n * Decorator for logging method execution\n * Logs method calls, arguments, results, and execution time\n */\nexport function logged(\n  options: { logArgs?: boolean; logResult?: boolean; logTiming?: boolean } = {}\n) {\n  const { logArgs = true, logResult = true, logTiming = true } = options;\n\n  return createMethodDecoratorWithClass(\n    (originalMethod, methodName, className) => {\n      const wrappedMethod = async function (\n        this: unknown,\n        ...args: unknown[]\n      ): Promise<unknown> {\n        const startTime = Date.now();\n        const argsLog = logArgs ? ` with args: ${JSON.stringify(args)}` : '';\n\n        console.log(`[${className}.${methodName}] Starting${argsLog}`);\n\n        try {\n          const result = await originalMethod.apply(this, args);\n          const duration = Date.now() - startTime;\n          const timingLog = logTiming ? ` in ${duration}ms` : '';\n          const resultLog = logResult\n            ? ` Result: ${JSON.stringify(result)}`\n            : '';\n\n          console.log(\n            `[${className}.${methodName}] Completed${timingLog}.${resultLog}`\n          );\n\n          return result;\n        } catch (error) {\n          const duration = Date.now() - startTime;\n          const timingLog = logTiming ? ` after ${duration}ms` : '';\n          console.error(\n            `[${className}.${methodName}] Failed${timingLog}:`,\n            error\n          );\n          throw error;\n        }\n      };\n\n      return wrappedMethod as typeof originalMethod;\n    }\n  );\n}\n\n/**\n * Performance statistics type\n */\nexport interface PerformanceStats {\n  count: number;\n  min: number;\n  max: number;\n  avg: number;\n  median: number;\n  p95: number;\n  p99: number;\n}\n\n/**\n * Decorator for measuring method performance.\n * Collects timing statistics across multiple calls.\n *\n * @example\n * ```typescript\n * class Calculator {\n *   @measure()\n *   async compute(data: number[]): Promise<number> {\n *     return data.reduce((a, b) => a + b, 0);\n *   }\n * }\n * // Access stats: Calculator.prototype.compute.getStats()\n * ```\n */\nexport function measure() {\n  const timings: number[] = [];\n\n  return createMethodDecorator((originalMethod) => {\n    const wrappedMethod = async function (\n      this: unknown,\n      ...args: unknown[]\n    ): Promise<unknown> {\n      const start = performance.now();\n\n      try {\n        return await originalMethod.apply(this, args);\n      } finally {\n        const duration = performance.now() - start;\n        timings.push(duration);\n\n        // Keep only last 100 measurements\n        if (timings.length > 100) {\n          timings.shift();\n        }\n      }\n    };\n\n    // Add method to get statistics\n    (wrappedMethod as { getStats?: () => PerformanceStats }).getStats = () => {\n      if (timings.length === 0) {\n        return {\n          count: 0,\n          min: 0,\n          max: 0,\n          avg: 0,\n          median: 0,\n          p95: 0,\n          p99: 0,\n        };\n      }\n\n      const sorted = [...timings].sort((a, b) => a - b);\n      const sum = sorted.reduce((a, b) => a + b, 0);\n\n      return {\n        count: sorted.length,\n        min: sorted[0],\n        max: sorted[sorted.length - 1],\n        avg: sum / sorted.length,\n        median: sorted[Math.floor(sorted.length / 2)],\n        p95: sorted[Math.floor(sorted.length * 0.95)],\n        p99: sorted[Math.floor(sorted.length * 0.99)],\n      };\n    };\n\n    // Add method to clear statistics\n    (wrappedMethod as { clearStats?: () => void }).clearStats = () => {\n      timings.length = 0;\n    };\n\n    return wrappedMethod as typeof originalMethod;\n  });\n}\n\n/**\n * Validator function type\n */\nexport type ValidatorFn = (arg: unknown) => boolean | string;\n\n/**\n * Decorator for validating method arguments.\n * Throws an error if validation fails.\n *\n * @param validators - Array of validator functions for each argument\n *\n * @example\n * ```typescript\n * class UserService {\n *   @validate([\n *     (id) => typeof id === 'string' && id.length > 0,\n *     (data) => data && typeof data.name === 'string'\n *   ])\n *   async updateUser(id: string, data: UserData): Promise<void> {\n *     await api.updateUser(id, data);\n *   }\n * }\n * ```\n */\nexport function validate(validators: ValidatorFn[]) {\n  return createMethodDecorator((originalMethod, methodName) => {\n    const wrappedMethod = async function (\n      this: unknown,\n      ...args: unknown[]\n    ): Promise<unknown> {\n      for (let i = 0; i < validators.length; i++) {\n        if (i >= args.length) break;\n\n        const result = validators[i](args[i]);\n        if (result === false) {\n          throw new Error(\n            `Validation failed for argument ${i} in ${methodName}`\n          );\n        }\n        if (typeof result === 'string') {\n          throw new Error(result);\n        }\n      }\n\n      return originalMethod.apply(this, args);\n    };\n\n    return wrappedMethod as typeof originalMethod;\n  });\n}\n","/**\n * ThreadTS Universal - Serialization Utilities\n * Handles function and data serialization across different platforms\n */\n\nimport {\n  SerializableData,\n  SerializableFunction,\n  SerializationError,\n  TypedArray,\n} from '../types';\n\n/**\n * Serializes a function for worker execution\n */\nexport function serializeFunction(fn: SerializableFunction): string {\n  if (typeof fn !== 'function') {\n    throw new SerializationError('Input must be a function');\n  }\n\n  const fnString = fn.toString();\n\n  // Handle arrow functions and regular functions\n  if (fnString.includes('=>') || fnString.startsWith('function')) {\n    return fnString;\n  }\n\n  // Handle method definitions\n  if (fnString.includes('(') && fnString.includes('{')) {\n    return `function ${fnString}`;\n  }\n\n  throw new SerializationError('Unable to serialize function');\n}\n\n/**\n * Deserializes a function string back to a function\n */\nexport function deserializeFunction(fnString: string): SerializableFunction {\n  try {\n    // Use Function constructor for safe evaluation\n    return new Function('return (' + fnString + ')')();\n  } catch (error) {\n    throw new SerializationError(\n      'Failed to deserialize function',\n      error as Error\n    );\n  }\n}\n\n/**\n * Serializes data for worker transfer\n */\nexport function serializeData(data: SerializableData): {\n  serialized: string;\n  transferables: Transferable[];\n} {\n  const transferables: Transferable[] = [];\n\n  try {\n    // Handle transferable objects\n    const processed = processTransferables(data, transferables);\n\n    return {\n      serialized: JSON.stringify(processed),\n      transferables,\n    };\n  } catch (error) {\n    throw new SerializationError('Failed to serialize data', error as Error);\n  }\n}\n\n/**\n * Deserializes data from worker\n */\nexport function deserializeData(serialized: string): unknown {\n  try {\n    return JSON.parse(serialized);\n  } catch (error) {\n    throw new SerializationError('Failed to deserialize data', error as Error);\n  }\n}\n\n/**\n * Processes data to extract transferable objects\n */\nfunction processTransferables(\n  obj: unknown,\n  transferables: Transferable[]\n): unknown {\n  if (obj === null || typeof obj !== 'object') {\n    return obj;\n  }\n\n  // Handle ArrayBuffer\n  if (obj instanceof ArrayBuffer) {\n    transferables.push(obj);\n    return { __type: 'ArrayBuffer', __data: obj };\n  }\n\n  // Handle TypedArrays\n  if (ArrayBuffer.isView(obj)) {\n    const typedArray = obj as TypedArray;\n    const buffer = typedArray.buffer.slice(\n      typedArray.byteOffset,\n      typedArray.byteOffset + typedArray.byteLength\n    );\n    transferables.push(buffer);\n    return {\n      __type: typedArray.constructor.name,\n      __data: buffer,\n      __byteOffset: typedArray.byteOffset,\n      __length: typedArray.length,\n    };\n  }\n\n  // Handle MessagePort\n  if (typeof MessagePort !== 'undefined' && obj instanceof MessagePort) {\n    transferables.push(obj);\n    return { __type: 'MessagePort', __data: obj };\n  }\n\n  // Handle OffscreenCanvas\n  if (\n    typeof OffscreenCanvas !== 'undefined' &&\n    obj instanceof OffscreenCanvas\n  ) {\n    transferables.push(obj);\n    return { __type: 'OffscreenCanvas', __data: obj };\n  }\n\n  // Handle ImageBitmap\n  if (typeof ImageBitmap !== 'undefined' && obj instanceof ImageBitmap) {\n    transferables.push(obj);\n    return { __type: 'ImageBitmap', __data: obj };\n  }\n\n  // Handle Arrays\n  if (Array.isArray(obj)) {\n    return obj.map((item) => processTransferables(item, transferables));\n  }\n\n  // Handle Objects\n  const result: Record<string, unknown> = {};\n  for (const [key, value] of Object.entries(obj)) {\n    result[key] = processTransferables(value, transferables);\n  }\n\n  return result;\n}\n\n/**\n * Restores transferable objects after deserialization\n */\nexport function restoreTransferables(obj: unknown): unknown {\n  if (obj === null || typeof obj !== 'object') {\n    return obj;\n  }\n\n  const typedObj = obj as Record<string, unknown>;\n\n  // Handle special transferable markers\n  if (typedObj.__type) {\n    switch (typedObj.__type) {\n      case 'ArrayBuffer':\n        return typedObj.__data;\n\n      case 'MessagePort':\n        return typedObj.__data;\n\n      case 'OffscreenCanvas':\n        return typedObj.__data;\n\n      case 'ImageBitmap':\n        return typedObj.__data;\n\n      // Handle TypedArrays\n      case 'Int8Array':\n      case 'Uint8Array':\n      case 'Uint8ClampedArray':\n      case 'Int16Array':\n      case 'Uint16Array':\n      case 'Int32Array':\n      case 'Uint32Array':\n      case 'Float32Array':\n      case 'Float64Array':\n      case 'BigInt64Array':\n      case 'BigUint64Array': {\n        const TypedArrayConstructor = (globalThis as Record<string, unknown>)[\n          typedObj.__type as string\n        ] as new (buffer: ArrayBuffer) => TypedArray;\n        return new TypedArrayConstructor(typedObj.__data as ArrayBuffer);\n      }\n    }\n  }\n\n  // Handle Arrays\n  if (Array.isArray(obj)) {\n    return obj.map(restoreTransferables);\n  }\n\n  // Handle Objects\n  const result: Record<string, unknown> = {};\n  for (const [key, value] of Object.entries(obj)) {\n    result[key] = restoreTransferables(value);\n  }\n\n  return result;\n}\n\n/**\n * Checks if an object contains transferable objects\n */\nexport function hasTransferables(obj: unknown): boolean {\n  if (obj === null || typeof obj !== 'object') {\n    return false;\n  }\n\n  // Check for transferable types\n  if (\n    obj instanceof ArrayBuffer ||\n    ArrayBuffer.isView(obj) ||\n    (typeof MessagePort !== 'undefined' && obj instanceof MessagePort) ||\n    (typeof OffscreenCanvas !== 'undefined' &&\n      obj instanceof OffscreenCanvas) ||\n    (typeof ImageBitmap !== 'undefined' && obj instanceof ImageBitmap)\n  ) {\n    return true;\n  }\n\n  // Recursively check arrays and objects\n  if (Array.isArray(obj)) {\n    return obj.some(hasTransferables);\n  }\n\n  return Object.values(obj).some(hasTransferables);\n}\n\n/**\n * Creates a worker script string with the function and data\n */\nexport function createWorkerScript(\n  fn: SerializableFunction,\n  data: unknown,\n  options: { timeout?: number } = {}\n): string {\n  const fnString = serializeFunction(fn);\n  const { serialized: dataString } = serializeData(data as SerializableData);\n\n  return `\n    // ThreadTS Universal Worker Script\n    const { deserializeData, restoreTransferables, serializeData } = {\n      deserializeData: ${deserializeData.toString()},\n      restoreTransferables: ${restoreTransferables.toString()},\n      serializeData: ${serializeData.toString()}\n    };\n\n    const fn = ${fnString};\n    const data = restoreTransferables(deserializeData('${dataString}'));\n\n    ${\n      options.timeout\n        ? `\n    const timeoutId = setTimeout(() => {\n      postMessage({ error: 'Operation timed out after ${options.timeout}ms' });\n    }, ${options.timeout});\n    `\n        : ''\n    }\n\n    try {\n      const startTime = performance.now();\n      const result = fn(data);\n      const executionTime = performance.now() - startTime;\n\n      ${options.timeout ? 'clearTimeout(timeoutId);' : ''}\n\n      if (result instanceof Promise) {\n        result\n          .then(asyncResult => {\n            const { serialized } = serializeData(asyncResult);\n            postMessage({\n              result: asyncResult,\n              executionTime: performance.now() - startTime,\n              serialized\n            });\n          })\n          .catch(error => {\n            postMessage({\n              error: error.message || 'Unknown error in async function',\n              executionTime: performance.now() - startTime\n            });\n          });\n      } else {\n        const { serialized } = serializeData(result);\n        postMessage({\n          result,\n          executionTime,\n          serialized\n        });\n      }\n    } catch (error) {\n      ${options.timeout ? 'clearTimeout(timeoutId);' : ''}\n      postMessage({\n        error: error.message || 'Unknown error',\n        executionTime: performance.now() - startTime\n      });\n    }\n  `;\n}\n\n// Serialization utilities class for easier access\nexport class SerializationUtils {\n  static serializeFunction = serializeFunction;\n  static deserializeFunction = deserializeFunction;\n  static serializeData = serializeData;\n  static deserializeData = deserializeData;\n  static restoreTransferables = restoreTransferables;\n  static hasTransferables = hasTransferables;\n  static createWorkerScript = createWorkerScript;\n}\n","/**\n * ThreadTS Universal - Abstract Base Worker Adapter\n *\n * Provides common functionality for all platform-specific worker adapters.\n * This base class implements the Template Method design pattern,\n * allowing subclasses to customize specific behaviors while sharing\n * common logic for worker management, error handling, and lifecycle.\n *\n * @module adapters/base\n * @author ThreadTS Universal Team\n */\n\nimport {\n  Platform,\n  SerializableFunction,\n  ThreadOptions,\n  ThreadResult,\n  WorkerAdapter,\n  WorkerError,\n  WorkerInstance,\n} from '../types';\nimport { getHighResTimestamp, getOptimalThreadCount } from '../utils/platform';\nimport { createWorkerScript } from '../utils/serialization';\n\n/**\n * Configuration options for base worker instance.\n * These options control common behavior across all platforms.\n */\nexport interface BaseWorkerConfig {\n  /** Maximum time in ms to wait for worker initialization */\n  initTimeout?: number;\n  /** Whether to automatically cleanup on error */\n  autoCleanupOnError?: boolean;\n  /** Whether to track execution metrics */\n  trackMetrics?: boolean;\n}\n\n/**\n * Execution metrics collected during worker operation.\n * Useful for monitoring and debugging performance issues.\n */\nexport interface WorkerExecutionMetrics {\n  /** Start timestamp of the execution */\n  startTime: number;\n  /** End timestamp of the execution */\n  endTime: number;\n  /** Total execution duration in milliseconds */\n  duration: number;\n  /** Whether the execution was successful */\n  success: boolean;\n  /** Error message if execution failed */\n  errorMessage?: string;\n}\n\n/** Counter for unique worker ID generation with overflow protection */\nlet workerIdCounter = 0;\n\n/**\n * Generates a unique worker ID using a counter-based approach.\n * More reliable than pure random generation for high-concurrency scenarios.\n * Includes overflow protection for long-running applications.\n *\n * @param platform - The platform identifier\n * @returns A unique worker ID string\n */\nfunction generateWorkerId(platform: Platform): string {\n  // Increment with overflow protection using modulo to prevent reaching Number.MAX_SAFE_INTEGER\n  workerIdCounter = (workerIdCounter + 1) % Number.MAX_SAFE_INTEGER;\n  const counter = workerIdCounter;\n  const timestamp = Date.now().toString(36);\n  const random = Math.random().toString(36).substring(2, 6);\n  return `${platform}-worker-${counter}-${timestamp}-${random}`;\n}\n\n/**\n * Abstract base class for worker instances across all platforms.\n *\n * Implements common functionality like:\n * - Execution state tracking\n * - Timeout handling\n * - Abort signal management\n * - Metrics collection\n *\n * Subclasses must implement platform-specific worker creation and cleanup.\n *\n * @abstract\n * @implements {WorkerInstance}\n *\n * @example\n * ```typescript\n * class MyWorkerInstance extends AbstractWorkerInstance {\n *   protected async createPlatformWorker(script: string): Promise<void> {\n *     // Platform-specific worker creation\n *   }\n *\n *   protected async cleanupPlatformWorker(): Promise<void> {\n *     // Platform-specific cleanup\n *   }\n *\n *   protected async postMessageToWorker(data: unknown): Promise<ThreadResult<unknown>> {\n *     // Platform-specific message passing\n *   }\n * }\n * ```\n */\nexport abstract class AbstractWorkerInstance implements WorkerInstance {\n  /** Unique identifier for this worker instance */\n  readonly id: string;\n\n  /** Whether the worker has been terminated */\n  protected isTerminated = false;\n\n  /** Whether the worker is currently executing a task */\n  protected isExecuting = false;\n\n  /** Collection of execution metrics for monitoring */\n  protected executionHistory: WorkerExecutionMetrics[] = [];\n\n  /** Configuration for this worker instance */\n  protected config: Required<BaseWorkerConfig>;\n\n  /**\n   * Creates a new abstract worker instance.\n   *\n   * @param platform - The platform identifier (browser, node, deno, bun)\n   * @param config - Optional configuration overrides\n   */\n  constructor(\n    protected readonly platform: Platform,\n    config: BaseWorkerConfig = {}\n  ) {\n    // Generate unique worker ID using counter-based approach for reliability\n    this.id = generateWorkerId(platform);\n\n    // Apply default configuration with user overrides\n    this.config = {\n      initTimeout: config.initTimeout ?? 30000,\n      autoCleanupOnError: config.autoCleanupOnError ?? true,\n      trackMetrics: config.trackMetrics ?? true,\n    };\n  }\n\n  /**\n   * Executes a function in the worker thread.\n   *\n   * This method handles common concerns like:\n   * - State validation (terminated, already executing)\n   * - Timeout management\n   * - Abort signal handling\n   * - Metrics collection\n   *\n   * @template T - The expected return type\n   * @param fn - The function to execute in the worker\n   * @param data - The data to pass to the function\n   * @param options - Execution options (timeout, signal, etc.)\n   * @returns Promise resolving to the execution result\n   * @throws {WorkerError} If worker is terminated or already executing\n   */\n  async execute<T = unknown>(\n    fn: SerializableFunction,\n    data: unknown,\n    options: ThreadOptions = {}\n  ): Promise<ThreadResult<T>> {\n    // Validate worker state before execution\n    this.validateState();\n\n    this.isExecuting = true;\n    const startTime = getHighResTimestamp();\n\n    try {\n      // Create the worker script from function and data\n      const workerScript = createWorkerScript(fn, data, {\n        timeout: options.timeout,\n      });\n\n      // Execute with timeout and abort handling\n      const result = await this.executeWithControls<T>(\n        workerScript,\n        data,\n        options,\n        startTime\n      );\n\n      // Record successful execution metrics\n      this.recordMetrics(startTime, true);\n\n      return result;\n    } catch (error) {\n      // Record failed execution metrics\n      this.recordMetrics(\n        startTime,\n        false,\n        error instanceof Error ? error.message : String(error)\n      );\n\n      // Auto-cleanup on error if configured\n      if (this.config.autoCleanupOnError) {\n        await this.cleanupOnError();\n      }\n\n      throw error;\n    } finally {\n      this.isExecuting = false;\n    }\n  }\n\n  /**\n   * Terminates the worker and releases resources.\n   *\n   * After termination, the worker instance cannot be reused.\n   * This method is idempotent - calling it multiple times is safe.\n   */\n  async terminate(): Promise<void> {\n    if (this.isTerminated) {\n      return; // Already terminated, nothing to do\n    }\n\n    // Perform platform-specific cleanup\n    await this.cleanupPlatformWorker();\n\n    this.isTerminated = true;\n    this.executionHistory = []; // Clear metrics to free memory\n  }\n\n  /**\n   * Checks if the worker is currently idle (not executing and not terminated).\n   *\n   * @returns true if the worker can accept new tasks\n   */\n  isIdle(): boolean {\n    return !this.isExecuting && !this.isTerminated;\n  }\n\n  /**\n   * Gets the execution history for this worker.\n   * Useful for monitoring and debugging.\n   *\n   * @param limit - Maximum number of records to return (default: 10)\n   * @returns Array of execution metrics in chronological order (oldest first)\n   */\n  getExecutionHistory(limit = 10): WorkerExecutionMetrics[] {\n    return this.executionHistory.slice(-limit);\n  }\n\n  /**\n   * Gets the average execution time for this worker.\n   *\n   * @returns Average execution time in milliseconds, or 0 if no history\n   */\n  getAverageExecutionTime(): number {\n    if (this.executionHistory.length === 0) {\n      return 0;\n    }\n\n    const totalDuration = this.executionHistory.reduce(\n      (sum, metric) => sum + metric.duration,\n      0\n    );\n\n    return totalDuration / this.executionHistory.length;\n  }\n\n  /**\n   * Gets the success rate for this worker.\n   *\n   * @returns Success rate as a decimal (0.0 to 1.0), or 1.0 if no history\n   */\n  getSuccessRate(): number {\n    if (this.executionHistory.length === 0) {\n      return 1.0;\n    }\n\n    const successCount = this.executionHistory.filter((m) => m.success).length;\n    return successCount / this.executionHistory.length;\n  }\n\n  // ═══════════════════════════════════════════════════════════════════════════\n  // Protected Helper Methods\n  // ═══════════════════════════════════════════════════════════════════════════\n\n  /**\n   * Validates that the worker is in a valid state for execution.\n   *\n   * @throws {WorkerError} If worker is terminated or already executing\n   */\n  protected validateState(): void {\n    if (this.isTerminated) {\n      throw new WorkerError('Worker has been terminated');\n    }\n\n    if (this.isExecuting) {\n      throw new WorkerError('Worker is already executing a task');\n    }\n  }\n\n  /**\n   * Executes with timeout and abort signal handling.\n   * Wraps the platform-specific execution with common controls.\n   *\n   * @template T - The expected return type\n   * @param workerScript - The serialized worker script\n   * @param data - The data to pass to the worker\n   * @param options - Execution options\n   * @param startTime - The execution start timestamp\n   * @returns Promise resolving to the execution result\n   */\n  protected async executeWithControls<T>(\n    workerScript: string,\n    data: unknown,\n    options: ThreadOptions,\n    startTime: number\n  ): Promise<ThreadResult<T>> {\n    // Create a promise that handles the actual execution\n    const executionPromise = this.performPlatformExecution<T>(\n      workerScript,\n      data,\n      options,\n      startTime\n    );\n\n    // Wrap with abort signal if provided\n    const abortPromise = options.signal\n      ? this.createAbortPromise<T>(options.signal)\n      : null;\n\n    // Wrap with timeout if provided\n    const timeoutPromise = options.timeout\n      ? this.createTimeoutPromise<T>(options.timeout)\n      : null;\n\n    // Race all promises\n    const promises: Promise<ThreadResult<T>>[] = [executionPromise];\n    if (abortPromise) promises.push(abortPromise);\n    if (timeoutPromise) promises.push(timeoutPromise);\n\n    return Promise.race(promises);\n  }\n\n  /**\n   * Creates a promise that rejects when the abort signal is triggered.\n   *\n   * @template T - The expected return type\n   * @param signal - The abort signal to monitor\n   * @returns Promise that rejects on abort\n   */\n  protected createAbortPromise<T>(\n    signal: AbortSignal\n  ): Promise<ThreadResult<T>> {\n    return new Promise<ThreadResult<T>>((_, reject) => {\n      if (signal.aborted) {\n        reject(new WorkerError('Operation was aborted'));\n        return;\n      }\n\n      const onAbort = () => {\n        signal.removeEventListener('abort', onAbort);\n        reject(new WorkerError('Operation was aborted'));\n      };\n\n      signal.addEventListener('abort', onAbort, { once: true });\n    });\n  }\n\n  /**\n   * Creates a promise that rejects after the specified timeout.\n   *\n   * @template T - The expected return type\n   * @param timeout - Timeout in milliseconds\n   * @returns Promise that rejects on timeout\n   */\n  protected createTimeoutPromise<T>(timeout: number): Promise<ThreadResult<T>> {\n    return new Promise<ThreadResult<T>>((_, reject) => {\n      setTimeout(() => {\n        reject(new WorkerError(`Operation timed out after ${timeout}ms`));\n      }, timeout);\n    });\n  }\n\n  /**\n   * Records execution metrics for monitoring.\n   *\n   * @param startTime - The execution start timestamp\n   * @param success - Whether the execution was successful\n   * @param errorMessage - Error message if execution failed\n   */\n  protected recordMetrics(\n    startTime: number,\n    success: boolean,\n    errorMessage?: string\n  ): void {\n    if (!this.config.trackMetrics) {\n      return;\n    }\n\n    const endTime = getHighResTimestamp();\n    const metrics: WorkerExecutionMetrics = {\n      startTime,\n      endTime,\n      duration: endTime - startTime,\n      success,\n      errorMessage,\n    };\n\n    this.executionHistory.push(metrics);\n\n    // Keep only last 100 metrics to prevent memory growth\n    if (this.executionHistory.length > 100) {\n      this.executionHistory = this.executionHistory.slice(-100);\n    }\n  }\n\n  /**\n   * Handles cleanup after an error occurs.\n   * Called when autoCleanupOnError is enabled.\n   */\n  protected async cleanupOnError(): Promise<void> {\n    // Default implementation: just clean up the platform worker\n    // Subclasses can override for more specific cleanup\n    try {\n      await this.cleanupPlatformWorker();\n    } catch {\n      // Ignore cleanup errors\n    }\n  }\n\n  // ═══════════════════════════════════════════════════════════════════════════\n  // Abstract Methods - Must be implemented by subclasses\n  // ═══════════════════════════════════════════════════════════════════════════\n\n  /**\n   * Performs the platform-specific worker execution.\n   *\n   * @template T - The expected return type\n   * @param workerScript - The serialized worker script\n   * @param data - The data to pass to the worker\n   * @param options - Execution options\n   * @param startTime - The execution start timestamp\n   * @returns Promise resolving to the execution result\n   *\n   * @abstract\n   */\n  protected abstract performPlatformExecution<T>(\n    workerScript: string,\n    data: unknown,\n    options: ThreadOptions,\n    startTime: number\n  ): Promise<ThreadResult<T>>;\n\n  /**\n   * Cleans up platform-specific worker resources.\n   *\n   * @abstract\n   */\n  protected abstract cleanupPlatformWorker(): Promise<void>;\n}\n\n/**\n * Abstract base class for worker adapters.\n *\n * Provides common factory pattern implementation for creating workers.\n * Subclasses implement platform-specific worker creation.\n *\n * @abstract\n * @implements {WorkerAdapter}\n */\nexport abstract class AbstractWorkerAdapter implements WorkerAdapter {\n  /** The platform this adapter supports */\n  abstract readonly platform: Platform;\n\n  /**\n   * Creates a new worker instance for this platform.\n   *\n   * @param script - Initial script (may be empty, actual script provided during execution)\n   * @returns Promise resolving to the new worker instance\n   */\n  abstract createWorker(script: string): Promise<WorkerInstance>;\n\n  /**\n   * Terminates a worker instance and releases resources.\n   *\n   * @param worker - The worker instance to terminate\n   */\n  async terminateWorker(worker: WorkerInstance): Promise<void> {\n    await worker.terminate();\n  }\n\n  /**\n   * Checks if this adapter is supported in the current environment.\n   *\n   * @returns true if workers can be created in this environment\n   */\n  abstract isSupported(): boolean;\n\n  /**\n   * Gets the recommended number of workers for this platform.\n   * Uses the optimal thread count from platform utilities for\n   * cross-platform consistency.\n   *\n   * @returns Recommended worker count based on hardware and platform\n   */\n  getRecommendedWorkerCount(): number {\n    // Use platform utilities for consistent cross-platform behavior\n    return getOptimalThreadCount();\n  }\n}\n\n/**\n * Creates a standardized error message for worker operations.\n * Ensures consistent error formatting across all adapters.\n *\n * @param operation - The operation that failed\n * @param platform - The platform where the error occurred\n * @param originalError - The original error if available\n * @returns Formatted error message\n */\nexport function createWorkerErrorMessage(\n  operation: string,\n  platform: Platform,\n  originalError?: Error\n): string {\n  let message = `[${platform}] Worker ${operation} failed`;\n\n  if (originalError) {\n    message += `: ${originalError.message}`;\n  }\n\n  return message;\n}\n\n/**\n * Type guard to check if an object is a WorkerInstance.\n *\n * @param obj - The object to check\n * @returns true if the object implements WorkerInstance\n */\nexport function isWorkerInstance(obj: unknown): obj is WorkerInstance {\n  if (typeof obj !== 'object' || obj === null) {\n    return false;\n  }\n\n  const worker = obj as Partial<WorkerInstance>;\n  return (\n    typeof worker.id === 'string' &&\n    typeof worker.execute === 'function' &&\n    typeof worker.terminate === 'function' &&\n    typeof worker.isIdle === 'function'\n  );\n}\n\n// ═══════════════════════════════════════════════════════════════════════════\n// Web Worker Base Implementation\n// ═══════════════════════════════════════════════════════════════════════════\n\n/**\n * Configuration for Web-API-based workers (Browser, Deno, Bun).\n *\n * This configuration extends the base configuration with\n * web-worker-specific options.\n */\nexport interface WebWorkerConfig extends BaseWorkerConfig {\n  /** Worker name for debugging (optional) */\n  workerName?: string;\n  /** Worker type: 'classic' or 'module' */\n  workerType?: 'classic' | 'module';\n}\n\n/**\n * Abstract base class for Web-API-based workers.\n *\n * This class implements the shared logic for Browser, Deno,\n * and Bun workers, all of which use the Web Worker API. It abstracts:\n *\n * - Blob URL creation and cleanup\n * - Event handler setup (message, error, messageerror)\n * - Timeout and abort-signal handling\n * - Transferable objects support\n *\n * Subclasses only need to implement worker creation with platform-specific\n * options.\n *\n * @abstract\n * @extends AbstractWorkerInstance\n *\n * @example\n * ```typescript\n * class MyPlatformWorkerInstance extends AbstractWebWorkerInstance {\n *   protected createPlatformWorkerOptions(): WorkerOptions {\n *     return { type: 'module', name: this.id };\n *   }\n * }\n * ```\n */\nexport abstract class AbstractWebWorkerInstance extends AbstractWorkerInstance {\n  /** The active web worker */\n  protected worker: Worker | null = null;\n\n  /** The blob URL of the worker script */\n  protected workerUrl: string | null = null;\n\n  /** Web-worker-specific configuration */\n  protected readonly webConfig: Required<WebWorkerConfig>;\n\n  /**\n   * Creates a new web worker instance.\n   *\n   * @param platform - The platform id\n   * @param config - Optional configuration\n   */\n  constructor(platform: Platform, config: WebWorkerConfig = {}) {\n    super(platform, config);\n    this.webConfig = {\n      ...this.config,\n      workerName: config.workerName ?? this.id,\n      workerType: config.workerType ?? 'classic',\n    };\n  }\n\n  /**\n   * Performs the platform-specific worker execution.\n   *\n   * Implements the Template Method pattern: shared logic\n   * (blob creation, event handling) is implemented here, while\n   * subclasses only adjust the worker options.\n   *\n   * @template T - The expected return type\n   * @param workerScript - The serialized worker script\n   * @param data - The data to pass\n   * @param options - Execution options\n   * @param startTime - Execution start timestamp\n   * @returns Promise with the execution result\n   */\n  protected async performPlatformExecution<T>(\n    workerScript: string,\n    data: unknown,\n    options: ThreadOptions,\n    startTime: number\n  ): Promise<ThreadResult<T>> {\n    // Create a blob URL for the worker\n    const blob = new Blob([workerScript], { type: 'application/javascript' });\n    this.workerUrl = URL.createObjectURL(blob);\n\n    return new Promise<ThreadResult<T>>((resolve, reject) => {\n      let timeoutId: ReturnType<typeof setTimeout> | undefined;\n      let isResolved = false;\n\n      /**\n       * Helper for resolving the promise.\n       * Prevents multiple resolution and cleans up resources.\n       */\n      const safeResolve = (result: ThreadResult<T>) => {\n        if (isResolved) return;\n        isResolved = true;\n        this.cleanupWebWorker(timeoutId);\n        resolve(result);\n      };\n\n      /**\n       * Helper for rejecting the promise.\n       * Prevents multiple resolution and cleans up resources.\n       */\n      const safeReject = (error: Error) => {\n        if (isResolved) return;\n        isResolved = true;\n        this.cleanupWebWorker(timeoutId);\n        reject(error);\n      };\n\n      // Create worker with platform-specific options\n      try {\n        const workerOptions = this.createPlatformWorkerOptions();\n        this.worker = new Worker(this.workerUrl!, workerOptions);\n      } catch (error) {\n        safeReject(\n          new WorkerError(\n            `Failed to create worker: ${error instanceof Error ? error.message : String(error)}`\n          )\n        );\n        return;\n      }\n\n      // Abort-Signal-Handler\n      if (options.signal) {\n        const onAbort = () => {\n          safeReject(new WorkerError('Operation was aborted'));\n        };\n        options.signal.addEventListener('abort', onAbort, { once: true });\n      }\n\n      // Timeout-Handler\n      if (options.timeout) {\n        timeoutId = setTimeout(() => {\n          safeReject(\n            new WorkerError(`Operation timed out after ${options.timeout}ms`)\n          );\n        }, options.timeout);\n      }\n\n      // Message-Handler\n      this.worker.onmessage = (event: MessageEvent) => {\n        const { result, error, executionTime } = event.data as {\n          result: T;\n          error?: string;\n          executionTime?: number;\n        };\n\n        if (error) {\n          safeReject(new WorkerError(error));\n        } else {\n          safeResolve({\n            result,\n            executionTime: executionTime ?? getHighResTimestamp() - startTime,\n            workerId: this.id,\n          });\n        }\n      };\n\n      // Error-Handler\n      this.worker.onerror = (event: ErrorEvent) => {\n        safeReject(new WorkerError(`Worker error: ${event.message}`));\n      };\n\n      // MessageError handler (for serialization errors)\n      if ('onmessageerror' in this.worker) {\n        this.worker.onmessageerror = (event: MessageEvent) => {\n          safeReject(\n            new WorkerError(`Message serialization error: ${event.type}`)\n          );\n        };\n      }\n\n      // Send data to the worker\n      this.postMessageToWorker(data, options.transferable);\n    });\n  }\n\n  /**\n   * Creates platform-specific worker options.\n   *\n   * Subclasses override this method to add platform-specific\n   * options such as Deno permissions or Bun credentials.\n   *\n   * @returns Worker options for new Worker()\n   * @abstract\n   */\n  protected abstract createPlatformWorkerOptions(): WorkerOptions;\n\n  /**\n   * Sends a message to the worker.\n   *\n   * Can be overridden by subclasses for platform-specific\n   * behavior (e.g. optimized transferables).\n   *\n   * @param data - The data to send\n   * @param transferable - Optional transferable objects\n   */\n  protected postMessageToWorker(\n    data: unknown,\n    transferable?: Transferable[]\n  ): void {\n    if (!this.worker) {\n      throw new WorkerError('Worker not initialized');\n    }\n\n    if (transferable && transferable.length > 0) {\n      this.worker.postMessage(data, transferable);\n    } else {\n      this.worker.postMessage(data);\n    }\n  }\n\n  /**\n   * Cleans up web worker resources.\n   *\n   * @param timeoutId - Optional timeout id to clear\n   */\n  protected cleanupWebWorker(timeoutId?: ReturnType<typeof setTimeout>): void {\n    // Terminate worker\n    if (this.worker) {\n      this.worker.terminate();\n      this.worker = null;\n    }\n\n    // Clear timeout\n    if (timeoutId) {\n      clearTimeout(timeoutId);\n    }\n\n    // Release blob URL\n    if (this.workerUrl) {\n      URL.revokeObjectURL(this.workerUrl);\n      this.workerUrl = null;\n    }\n  }\n\n  /**\n   * Cleans up platform-specific worker resources.\n   *\n   * Implementation of the abstract method from AbstractWorkerInstance.\n   */\n  protected async cleanupPlatformWorker(): Promise<void> {\n    this.cleanupWebWorker();\n  }\n}\n","/**\n * ThreadTS Universal - Browser Worker Adapter\n *\n * Implements worker support for browser environments.\n * Uses the Web Worker API with blob URLs for dynamic script execution.\n *\n * @module adapters/browser\n * @author ThreadTS Universal Team\n */\n\nimport { WorkerInstance } from '../types';\nimport { AbstractWebWorkerInstance, AbstractWorkerAdapter } from './base';\n\n/**\n * Worker adapter for browser environments.\n *\n * Supports:\n * - Web Workers with blob URLs\n * - Transferable Objects (ArrayBuffer, MessagePort, etc.)\n * - AbortSignal support for cancellation\n *\n * @extends AbstractWorkerAdapter\n *\n * @example\n * ```typescript\n * const adapter = new BrowserWorkerAdapter();\n * if (adapter.isSupported()) {\n *   const worker = await adapter.createWorker('');\n *   const result = await worker.execute(fn, data);\n * }\n * ```\n */\nexport class BrowserWorkerAdapter extends AbstractWorkerAdapter {\n  readonly platform = 'browser' as const;\n\n  async createWorker(script: string): Promise<WorkerInstance> {\n    return new BrowserWorkerInstance(script);\n  }\n\n  isSupported(): boolean {\n    try {\n      // Extended detection with error handling\n      if (\n        typeof Worker === 'undefined' ||\n        typeof Blob === 'undefined' ||\n        typeof URL === 'undefined'\n      ) {\n        return false;\n      }\n\n      // Test whether we can actually create a worker\n      // (in some environments Worker is defined but not functional)\n      try {\n        const testBlob = new Blob([''], { type: 'application/javascript' });\n        const testUrl = URL.createObjectURL(testBlob);\n        URL.revokeObjectURL(testUrl);\n        return true;\n      } catch (error) {\n        console.warn('Worker creation test failed:', error);\n        return false;\n      }\n    } catch (error) {\n      console.warn('Worker support detection failed:', error);\n      return false;\n    }\n  }\n}\n\n/**\n * Browser worker instance.\n *\n * Uses the shared AbstractWebWorkerInstance base class\n * for consistent behavior and reduced code duplication.\n *\n * @extends AbstractWebWorkerInstance\n */\nclass BrowserWorkerInstance extends AbstractWebWorkerInstance {\n  /**\n   * Creates a new browser worker instance.\n   *\n   * @param _script - Initial script (overridden by execute())\n   */\n  constructor(_script: string) {\n    super('browser', {\n      workerName: undefined, // Auto-generated\n      workerType: 'classic', // Browser default\n    });\n  }\n\n  /**\n   * Creates browser-specific worker options.\n   *\n   * Browser workers use 'classic' by default.\n   * Module workers are not yet supported by all browsers.\n   *\n   * @returns WorkerOptions for new Worker()\n   */\n  protected createPlatformWorkerOptions(): WorkerOptions {\n    return {\n      type: this.webConfig.workerType,\n      name: this.webConfig.workerName,\n    };\n  }\n}\n","/**\n * ThreadTS Universal - Bun Worker Adapter\n *\n * Implements worker support for Bun environments.\n * Uses Bun-specific optimizations like high-precision timing\n * and native garbage collection.\n *\n * @module adapters/bun\n * @author ThreadTS Universal Team\n */\n\nimport { WorkerInstance } from '../types';\nimport { AbstractWebWorkerInstance, AbstractWorkerAdapter } from './base';\n\n/**\n * Bun worker options.\n */\ninterface BunWorkerOptions extends WorkerOptions {\n  /** Credential handling for cross-origin requests */\n  credentials?: 'omit' | 'same-origin' | 'include';\n}\n\n/**\n * Bun runtime namespace for type checking.\n *\n * Bun provides additional APIs for performance and system interaction.\n */\ninterface BunGlobal {\n  Bun: {\n    /** Bun version number */\n    version: string;\n    /** Bun git revision */\n    revision: string;\n    /** Environment variables */\n    env: Record<string, string | undefined>;\n    /** Path to the main module */\n    main: string;\n    /** Command-line arguments */\n    argv: string[];\n    /**\n     * Finds a binary on the PATH.\n     * @param binary - Binary name\n     * @returns Full path or null\n     */\n    which(binary: string): string | null;\n    /**\n     * Executes a subprocess synchronously.\n     */\n    spawnSync(\n      cmd: string[],\n      options?: {\n        cwd?: string;\n        env?: Record<string, string>;\n        stdin?: 'pipe' | 'inherit' | 'ignore';\n        stdout?: 'pipe' | 'inherit' | 'ignore';\n        stderr?: 'pipe' | 'inherit' | 'ignore';\n      }\n    ): {\n      success: boolean;\n      exitCode: number | null;\n      signalCode: string | null;\n      stdout: Buffer;\n      stderr: Buffer;\n    };\n    /**\n     * Triggers garbage collection.\n     * @param force - Forces immediate collection\n     */\n    gc(force?: boolean): void;\n    /**\n     * Returns the current time in nanoseconds.\n     * Higher precision than performance.now().\n     */\n    nanoseconds(): number;\n    /**\n     * Allocates unsafe memory without initialization.\n     * @param size - Size in bytes\n     */\n    allocUnsafe(size: number): Uint8Array;\n    /**\n     * Writes data to a file descriptor.\n     */\n    write(fd: number, data: string | Uint8Array): number;\n    /**\n     * File system router for Next.js-style routing.\n     */\n    FileSystemRouter: new (options: { dir: string; style?: 'nextjs' }) => {\n      match(pathname: string): { filePath: string; kind: string } | null;\n    };\n  };\n}\n\n/**\n * Worker adapter for Bun environments.\n *\n * Supports:\n * - High-performance workers with Bun optimizations\n * - Nanosecond-precision timing\n * - Native garbage collection\n * - Module workers with ES module syntax\n *\n * @extends AbstractWorkerAdapter\n *\n * @example\n * ```typescript\n * const adapter = new BunWorkerAdapter();\n * console.log(adapter.getBunVersion()); // \"1.0.0\"\n * console.log(adapter.nanoseconds()); // 1234567890123456\n * ```\n */\nexport class BunWorkerAdapter extends AbstractWorkerAdapter {\n  readonly platform = 'bun' as const;\n\n  async createWorker(script: string): Promise<WorkerInstance> {\n    return new BunWorkerInstance(script);\n  }\n\n  isSupported(): boolean {\n    return (\n      typeof (globalThis as unknown as BunGlobal).Bun !== 'undefined' &&\n      typeof Worker !== 'undefined'\n    );\n  }\n\n  /**\n   * Returns the Bun version number.\n   *\n   * @returns Bun version or null if not available\n   *\n   * @example\n   * ```typescript\n   * const version = adapter.getBunVersion();\n   * console.log(version); // \"1.0.0\"\n   * ```\n   */\n  getBunVersion(): string | null {\n    const bun = (globalThis as unknown as BunGlobal).Bun;\n    return bun?.version || null;\n  }\n\n  /**\n   * Returns the Bun git revision.\n   *\n   * @returns Bun revision or null if not available\n   */\n  getBunRevision(): string | null {\n    const bun = (globalThis as unknown as BunGlobal).Bun;\n    return bun?.revision || null;\n  }\n\n  /**\n   * Triggers garbage collection (Bun-specific feature).\n   *\n   * Useful for memory profiling or after memory-intensive operations.\n   *\n   * @param force - Forces immediate collection (default: false)\n   *\n   * @example\n   * ```typescript\n   * // After a large operation:\n   * adapter.gc(true);\n   * ```\n   */\n  gc(force = false): void {\n    const bun = (globalThis as unknown as BunGlobal).Bun;\n    if (bun?.gc) {\n      bun.gc(force);\n    }\n  }\n\n  /**\n   * Returns the current time in nanoseconds.\n   *\n   * Higher precision than performance.now() for performance measurements.\n   *\n   * @returns Time in nanoseconds\n   *\n   * @example\n   * ```typescript\n   * const start = adapter.nanoseconds();\n   * // ... Operation ...\n   * const duration = adapter.nanoseconds() - start;\n   * console.log(`${duration / 1000000}ms`);\n   * ```\n   */\n  nanoseconds(): number {\n    const bun = (globalThis as unknown as BunGlobal).Bun;\n    return bun?.nanoseconds() || Date.now() * 1000000;\n  }\n}\n\n/**\n * Bun worker instance.\n *\n * Extends AbstractWebWorkerInstance with Bun-specific features:\n * - Nanosecond timing for precise performance measurements\n * - Native garbage collection support\n * - Optimized transferable-object handling\n *\n * @extends AbstractWebWorkerInstance\n */\nclass BunWorkerInstance extends AbstractWebWorkerInstance {\n  /**\n   * Creates a new Bun worker instance.\n   *\n   * @param _script - Initial script (overridden by execute())\n   */\n  constructor(_script: string) {\n    super('bun', {\n      workerName: undefined, // Auto-generated\n      workerType: 'module', // Bun prefers module workers\n    });\n  }\n\n  /**\n   * Creates Bun-specific worker options.\n   *\n   * Configures:\n   * - Module workers (ES module syntax)\n   * - credentials: 'omit' for security\n   *\n   * @returns BunWorkerOptions\n   */\n  protected createPlatformWorkerOptions(): BunWorkerOptions {\n    return {\n      type: 'module',\n      name: this.id,\n      credentials: 'omit', // Security: do not include credentials\n    };\n  }\n\n  /**\n   * Returns Bun-specific worker information.\n   *\n   * @returns Object with worker ID, Bun version, and capabilities\n   *\n   * @example\n   * ```typescript\n   * const info = worker.getWorkerInfo();\n   * console.log(info.capabilities); // ['transferable-objects', ...]\n   * ```\n   */\n  getWorkerInfo(): {\n    id: string;\n    bunVersion: string | null;\n    bunRevision: string | null;\n    capabilities: string[];\n  } {\n    const bun = (globalThis as unknown as BunGlobal).Bun;\n    return {\n      id: this.id,\n      bunVersion: bun?.version || null,\n      bunRevision: bun?.revision || null,\n      capabilities: [\n        'transferable-objects',\n        'blob-urls',\n        'module-workers',\n        'high-precision-timing',\n        'garbage-collection',\n      ],\n    };\n  }\n\n  /**\n   * Forces garbage collection for this worker.\n   *\n   * Uses Bun's native GC API for immediate memory reclamation.\n   */\n  forceGC(): void {\n    const bun = (globalThis as unknown as BunGlobal).Bun;\n    if (bun?.gc) {\n      bun.gc(true);\n    }\n  }\n\n  /**\n   * Returns high-precision time in nanoseconds.\n   *\n   * Uses Bun's nanoseconds() for maximum precision.\n   *\n   * @returns Time in nanoseconds\n   */\n  getHighPrecisionTime(): number {\n    const bun = (globalThis as unknown as BunGlobal).Bun;\n    return bun?.nanoseconds() || performance.now() * 1000000;\n  }\n}\n","/**\n * ThreadTS Universal - Deno Worker Adapter\n *\n * Implements worker support for Deno environments.\n * Uses Deno-specific features like permission control and module workers.\n *\n * @module adapters/deno\n * @author ThreadTS Universal Team\n */\n\nimport { WorkerInstance } from '../types';\nimport { AbstractWebWorkerInstance, AbstractWorkerAdapter } from './base';\n\n/**\n * Deno worker options with permission control.\n *\n * Enables fine-grained access control for workers.\n */\ninterface DenoWorkerOptions extends WorkerOptions {\n  /** Deno-specific settings */\n  deno?: {\n    /** Permission configuration for the worker */\n    permissions?: DenoWorkerPermissions;\n    /** Whether the Deno namespace should be available inside the worker */\n    namespace?: boolean;\n  };\n}\n\n/**\n * Deno permission configuration.\n *\n * Each permission can be:\n * - `true`: full access\n * - `false`: no access\n * - `string[]`: access to specific resources\n */\ninterface DenoWorkerPermissions {\n  /** Network access */\n  net?: boolean | string[];\n  /** File system read access */\n  read?: boolean | string[];\n  /** File system write access */\n  write?: boolean | string[];\n  /** Environment variables */\n  env?: boolean | string[];\n  /** Subprocess execution */\n  run?: boolean | string[];\n  /** Foreign Function Interface */\n  ffi?: boolean | string[];\n  /** High-Resolution Timer */\n  hrtime?: boolean;\n  /** System information */\n  sys?: boolean | string[];\n}\n\n/**\n * Deno namespace interface for type checking.\n */\ninterface DenoNamespace {\n  permissions: {\n    query(descriptor: PermissionDescriptor): Promise<PermissionStatus>;\n    request(descriptor: PermissionDescriptor): Promise<PermissionStatus>;\n    revoke(descriptor: PermissionDescriptor): Promise<PermissionStatus>;\n  };\n  version: {\n    deno: string;\n    v8: string;\n    typescript: string;\n  };\n  build: {\n    target: string;\n    arch: string;\n    os: string;\n    vendor: string;\n    env?: string;\n  };\n  env: {\n    get(key: string): string | undefined;\n    set(key: string, value: string): void;\n    delete(key: string): void;\n    has(key: string): boolean;\n    toObject(): Record<string, string>;\n  };\n}\n\n/**\n * Worker adapter for Deno environments.\n *\n * Supports:\n * - Module workers (ES module syntax)\n * - Fine-grained permission control\n * - Sandbox isolation\n *\n * @extends AbstractWorkerAdapter\n *\n * @example\n * ```typescript\n * const adapter = new DenoWorkerAdapter();\n * console.log(adapter.getDenoVersion()); // \"1.40.0\"\n * const worker = await adapter.createWorker('');\n * ```\n */\nexport class DenoWorkerAdapter extends AbstractWorkerAdapter {\n  readonly platform = 'deno' as const;\n\n  async createWorker(script: string): Promise<WorkerInstance> {\n    return new DenoWorkerInstance(script);\n  }\n\n  isSupported(): boolean {\n    return (\n      typeof (globalThis as unknown as { Deno?: DenoNamespace }).Deno !==\n        'undefined' && typeof Worker !== 'undefined'\n    );\n  }\n\n  /**\n   * Returns Deno version information.\n   *\n   * @returns Deno version or null if not available\n   *\n   * @example\n   * ```typescript\n   * const version = adapter.getDenoVersion();\n   * console.log(version); // \"1.40.0\"\n   * ```\n   */\n  getDenoVersion(): string | null {\n    const deno = (globalThis as unknown as { Deno?: DenoNamespace }).Deno;\n    return deno?.version.deno || null;\n  }\n\n  /**\n   * Checks whether a specific permission has been granted.\n   *\n   * @param name - Permission name (e.g. 'read', 'write', 'net')\n   * @param descriptor - Optional permission descriptor for specific resources\n   * @returns true if permission is granted\n   *\n   * @example\n   * ```typescript\n   * if (await adapter.checkPermission('read')) {\n   *   // File system read is allowed\n   * }\n   * ```\n   */\n  async checkPermission(\n    name: string,\n    descriptor?: PermissionDescriptor\n  ): Promise<boolean> {\n    const deno = (globalThis as unknown as { Deno?: DenoNamespace }).Deno;\n    if (!deno) return false;\n\n    try {\n      const status = await deno.permissions.query(\n        descriptor || ({ name } as PermissionDescriptor)\n      );\n      return status.state === 'granted';\n    } catch {\n      return false;\n    }\n  }\n}\n\n/**\n * Deno worker instance.\n *\n * Extends AbstractWebWorkerInstance with Deno-specific features:\n * - Permission isolation (minimal by default)\n * - Module worker support\n * - No Deno namespace inside the worker (sandbox)\n *\n * @extends AbstractWebWorkerInstance\n */\nclass DenoWorkerInstance extends AbstractWebWorkerInstance {\n  /**\n   * Creates a new Deno worker instance.\n   *\n   * @param _script - Initial script (overridden by execute())\n   */\n  constructor(_script: string) {\n    super('deno', {\n      workerName: undefined, // Auto-generated\n      workerType: 'module', // Deno prefers module workers\n    });\n  }\n\n  /**\n   * Creates Deno-specific worker options.\n   *\n   * Configures minimal permissions for maximum security:\n   * - Only hrtime is allowed for performance measurement\n   * - No network, file system, or subprocess access\n   * - Deno namespace is not exposed (sandbox)\n   *\n   * @returns DenoWorkerOptions with permission configuration\n   */\n  protected createPlatformWorkerOptions(): DenoWorkerOptions {\n    return {\n      type: 'module',\n      name: this.id,\n      deno: {\n        permissions: {\n          // Minimal permissions for security\n          net: false,\n          read: false,\n          write: false,\n          env: false,\n          run: false,\n          ffi: false,\n          hrtime: true, // For performance monitoring\n          sys: false,\n        },\n        namespace: false, // Do not expose the Deno namespace in the worker\n      },\n    };\n  }\n\n  /**\n   * Returns Deno-specific worker information.\n   *\n   * @returns Object with worker ID, Deno version, and active permissions\n   *\n   * @example\n   * ```typescript\n   * const info = worker.getWorkerInfo();\n   * console.log(info.denoVersion); // \"1.40.0\"\n   * console.log(info.permissions); // [\"hrtime\"]\n   * ```\n   */\n  getWorkerInfo(): {\n    id: string;\n    denoVersion: string | null;\n    permissions: string[];\n  } {\n    const deno = (globalThis as unknown as { Deno?: DenoNamespace }).Deno;\n    return {\n      id: this.id,\n      denoVersion: deno?.version.deno || null,\n      permissions: ['hrtime'], // Currently granted permissions\n    };\n  }\n\n  /**\n   * Checks whether the Deno API is available in the worker context.\n   *\n   * @returns true if the Deno namespace is available\n   */\n  hasDenoAPI(): boolean {\n    return (\n      typeof (globalThis as unknown as { Deno?: DenoNamespace }).Deno !==\n      'undefined'\n    );\n  }\n}\n","module.exports = {}","/**\n * ThreadTS Universal - Worker Pool Manager\n * Manages a pool of workers for optimal performance\n */\n\nimport {\n  PoolConfig,\n  PoolManager,\n  PoolStats,\n  SerializableData,\n  SerializableFunction,\n  ThreadOptions,\n  ThreadResult,\n  WorkerAdapter,\n  WorkerError,\n  WorkerInstance,\n} from '../types';\nimport { getOptimalThreadCount } from '../utils/platform';\n\ninterface PoolTask {\n  id: string;\n  fn: SerializableFunction;\n  data: SerializableData;\n  options: ThreadOptions;\n  resolve: (result: ThreadResult<unknown>) => void;\n  reject: (error: Error) => void;\n  priority: number;\n  createdAt: number;\n}\n\nexport class ThreadPoolManager implements PoolManager {\n  private workers: WorkerInstance[] = [];\n  private idleWorkers: WorkerInstance[] = [];\n  private busyWorkers: Set<WorkerInstance> = new Set();\n  private taskQueue: PoolTask[] = [];\n  private completedTasks = 0;\n  private totalExecutionTime = 0;\n  private isTerminating = false;\n\n  private readonly config: Required<PoolConfig>;\n\n  constructor(\n    private adapter: WorkerAdapter,\n    config: PoolConfig = {}\n  ) {\n    const optimalWorkerCount = getOptimalThreadCount();\n\n    this.config = {\n      minWorkers: config.minWorkers ?? 1,\n      maxWorkers: config.maxWorkers ?? optimalWorkerCount,\n      idleTimeout: config.idleTimeout ?? 30000, // 30 seconds\n      queueSize: config.queueSize ?? 1000,\n      strategy: config.strategy ?? 'least-busy',\n    };\n\n    // Initialize minimum workers\n    this.initializeWorkers().catch(console.error);\n  }\n\n  async execute<T = unknown>(\n    fn: SerializableFunction,\n    data: SerializableData,\n    options: ThreadOptions = {}\n  ): Promise<ThreadResult<T>> {\n    if (this.isTerminating) {\n      // Return a cancelled result instead of throwing\n      return {\n        result: undefined as T,\n        executionTime: 0,\n        error: new WorkerError('Pool is terminating'),\n      };\n    }\n\n    return new Promise<ThreadResult<T>>((resolve, reject) => {\n      const priority = this.getPriority(options.priority);\n      const task: PoolTask = {\n        id: `task-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`,\n        fn,\n        data,\n        options,\n        resolve: resolve as (result: ThreadResult<unknown>) => void,\n        reject,\n        priority,\n        createdAt: Date.now(),\n      };\n\n      // Check queue size limit\n      if (this.taskQueue.length >= this.config.queueSize) {\n        reject(new WorkerError('Task queue is full'));\n        return;\n      }\n\n      // Add to queue with priority sorting\n      this.taskQueue.push(task);\n      this.taskQueue.sort((a, b) => b.priority - a.priority);\n\n      // Process queue\n      this.processQueue().catch(reject);\n    });\n  }\n\n  async resize(size: number): Promise<void> {\n    if (size < this.config.minWorkers) {\n      size = this.config.minWorkers;\n    }\n\n    if (size > this.config.maxWorkers) {\n      size = this.config.maxWorkers;\n    }\n\n    const currentSize = this.workers.length;\n\n    if (size > currentSize) {\n      // Add workers\n      const workersToAdd = size - currentSize;\n      const newWorkers = await Promise.all(\n        Array(workersToAdd)\n          .fill(null)\n          .map(() => this.adapter.createWorker(''))\n      );\n\n      this.workers.push(...newWorkers);\n      this.idleWorkers.push(...newWorkers);\n    } else if (size < currentSize) {\n      // Remove workers\n      const workersToRemove = currentSize - size;\n      const workersToTerminate = this.idleWorkers.splice(0, workersToRemove);\n\n      for (const worker of workersToTerminate) {\n        await this.adapter.terminateWorker(worker);\n        const index = this.workers.indexOf(worker);\n        if (index !== -1) {\n          this.workers.splice(index, 1);\n        }\n      }\n    }\n  }\n\n  async terminate(): Promise<void> {\n    this.isTerminating = true;\n\n    // Gracefully handle queued tasks\n    for (const task of this.taskQueue) {\n      task.resolve({\n        result: undefined as unknown,\n        executionTime: 0,\n        error: new WorkerError('Pool is terminating'),\n      });\n    }\n    this.taskQueue = [];\n\n    // Wait for busy workers to complete or timeout\n    const busyWorkerPromises = Array.from(this.busyWorkers).map(\n      (worker) =>\n        new Promise<void>((resolve) => {\n          // Give workers 5 seconds to complete\n          const timeout = setTimeout(() => resolve(), 5000);\n\n          // Check if worker becomes idle\n          const checkIdle = setInterval(() => {\n            if (worker.isIdle()) {\n              clearTimeout(timeout);\n              clearInterval(checkIdle);\n              resolve();\n            }\n          }, 100);\n        })\n    );\n\n    await Promise.all(busyWorkerPromises);\n\n    // Terminate all workers\n    await Promise.all(\n      this.workers.map((worker) => this.adapter.terminateWorker(worker))\n    );\n\n    this.workers = [];\n    this.idleWorkers = [];\n    this.busyWorkers.clear();\n  }\n\n  getStats(): PoolStats {\n    return {\n      activeWorkers: this.busyWorkers.size,\n      idleWorkers: this.idleWorkers.length,\n      queuedTasks: this.taskQueue.length,\n      completedTasks: this.completedTasks,\n      averageExecutionTime:\n        this.completedTasks > 0\n          ? this.totalExecutionTime / this.completedTasks\n          : 0,\n    };\n  }\n\n  private async initializeWorkers(): Promise<void> {\n    const workers = await Promise.all(\n      Array(this.config.minWorkers)\n        .fill(null)\n        .map(() => this.adapter.createWorker(''))\n    );\n\n    this.workers.push(...workers);\n    this.idleWorkers.push(...workers);\n  }\n\n  private async processQueue(): Promise<void> {\n    while (this.taskQueue.length > 0 && !this.isTerminating) {\n      const worker = await this.getAvailableWorker();\n      if (!worker) break;\n\n      const task = this.taskQueue.shift();\n      if (!task) break;\n\n      // Execute task\n      this.executeTask(worker, task).catch((error) => {\n        task.reject(error);\n        this.releaseWorker(worker);\n      });\n    }\n  }\n\n  private async getAvailableWorker(): Promise<WorkerInstance | null> {\n    // Check for idle workers first\n    if (this.idleWorkers.length > 0) {\n      const worker = this.idleWorkers.shift()!;\n      this.busyWorkers.add(worker);\n      return worker;\n    }\n\n    // Create new worker if under max limit\n    if (this.workers.length < this.config.maxWorkers) {\n      try {\n        const worker = await this.adapter.createWorker('');\n        this.workers.push(worker);\n        this.busyWorkers.add(worker);\n        return worker;\n      } catch (error) {\n        console.error('Failed to create new worker:', error);\n      }\n    }\n\n    // All workers are busy\n    return null;\n  }\n\n  private async executeTask(\n    worker: WorkerInstance,\n    task: PoolTask\n  ): Promise<void> {\n    try {\n      const result = await worker.execute(task.fn, task.data, task.options);\n\n      // Update statistics\n      this.completedTasks++;\n      this.totalExecutionTime += result.executionTime;\n\n      task.resolve(result);\n    } catch (error) {\n      task.reject(error as Error);\n    } finally {\n      this.releaseWorker(worker);\n\n      // Process next task if queue not empty\n      if (this.taskQueue.length > 0) {\n        this.processQueue().catch(console.error);\n      }\n    }\n  }\n\n  private releaseWorker(worker: WorkerInstance): void {\n    this.busyWorkers.delete(worker);\n\n    if (!this.isTerminating && worker.isIdle()) {\n      this.idleWorkers.push(worker);\n\n      // Set up idle timeout for cleanup\n      setTimeout(() => {\n        this.cleanupIdleWorker(worker);\n      }, this.config.idleTimeout);\n    } else if (!this.isTerminating) {\n      // Worker might not be immediately idle, add back after a short delay\n      setTimeout(() => {\n        if (worker.isIdle() && !this.busyWorkers.has(worker)) {\n          this.idleWorkers.push(worker);\n        }\n      }, 10); // 10ms delay\n    }\n  }\n\n  private async cleanupIdleWorker(worker: WorkerInstance): Promise<void> {\n    // Only cleanup if worker is still idle and we have more than minimum workers\n    if (\n      worker.isIdle() &&\n      this.idleWorkers.includes(worker) &&\n      this.workers.length > this.config.minWorkers\n    ) {\n      const idleIndex = this.idleWorkers.indexOf(worker);\n      if (idleIndex !== -1) {\n        this.idleWorkers.splice(idleIndex, 1);\n      }\n\n      const workerIndex = this.workers.indexOf(worker);\n      if (workerIndex !== -1) {\n        this.workers.splice(workerIndex, 1);\n      }\n\n      await this.adapter.terminateWorker(worker);\n    }\n  }\n\n  private getPriority(priority?: 'low' | 'normal' | 'high'): number {\n    switch (priority) {\n      case 'high':\n        return 3;\n      case 'normal':\n        return 2;\n      case 'low':\n        return 1;\n      default:\n        return 2;\n    }\n  }\n}\n\n// Export as PoolManager for compatibility\nexport { ThreadPoolManager as PoolManager };\n","/**\n * ThreadTS Universal - Advanced Error Handling and Recovery System\n * Comprehensive error detection, classification, and recovery mechanisms\n */\n\nimport { SerializationError, TimeoutError, WorkerError } from '../types';\n\nexport interface ErrorContext {\n  operation: string;\n  timestamp: number;\n  platform: string;\n  workerCount: number;\n  memoryUsage?: number;\n  stackTrace?: string;\n  additionalData?: Record<string, unknown>;\n}\n\nexport interface ErrorMetrics {\n  errorCount: number;\n  errorRate: number;\n  lastErrorTime: number;\n  commonErrors: Map<string, number>;\n  criticalErrors: number;\n  recoverySuccessRate: number;\n}\n\nexport interface RecoveryStrategy {\n  name: string;\n  condition: (error: Error, context: ErrorContext) => boolean;\n  action: (error: Error, context: ErrorContext) => Promise<boolean>;\n  priority: number; // Higher number = higher priority\n}\n\nexport class ErrorHandler {\n  private errors: Array<{ error: Error; context: ErrorContext }> = [];\n  private recoveryStrategies: RecoveryStrategy[] = [];\n  private circuitBreakerStates = new Map<\n    string,\n    { isOpen: boolean; failures: number; lastFailure: number }\n  >();\n  private retryPolicies = new Map<\n    string,\n    { maxRetries: number; backoffMs: number; multiplier: number }\n  >();\n\n  constructor() {\n    this.initializeDefaultStrategies();\n    this.initializeDefaultRetryPolicies();\n  }\n\n  /**\n   * Initializes default recovery strategies\n   */\n  private initializeDefaultStrategies(): void {\n    // Memory cleanup strategy\n    this.addRecoveryStrategy({\n      name: 'memory-cleanup',\n      priority: 10,\n      condition: (error) =>\n        error.message.includes('out of memory') ||\n        error.message.includes('heap') ||\n        error.name === 'RangeError',\n      action: async (error, context) => {\n        console.log('🧹 Executing memory cleanup strategy...');\n\n        // Force garbage collection if available\n        if (typeof global !== 'undefined' && global.gc) {\n          global.gc();\n        }\n\n        // Clear internal caches\n        this.clearInternalCaches();\n\n        // Reduce worker pool size temporarily\n        await this.reduceWorkerPoolSize(context);\n\n        return true;\n      },\n    });\n\n    // Worker restart strategy\n    this.addRecoveryStrategy({\n      name: 'worker-restart',\n      priority: 8,\n      condition: (error) =>\n        error instanceof WorkerError ||\n        error.message.includes('worker') ||\n        error.message.includes('terminated'),\n      action: async (\n        // eslint-disable-next-line @typescript-eslint/no-unused-vars\n        error,\n        // eslint-disable-next-line @typescript-eslint/no-unused-vars\n        context\n      ) => {\n        console.log('🔄 Executing worker restart strategy...');\n\n        // This would be implemented by the calling code\n        // Return success for now\n        return true;\n      },\n    });\n\n    // Serialization fallback strategy\n    this.addRecoveryStrategy({\n      name: 'serialization-fallback',\n      priority: 6,\n      condition: (error) =>\n        error instanceof SerializationError ||\n        error.message.includes('serialize') ||\n        error.message.includes('JSON'),\n      action: async (\n        // eslint-disable-next-line @typescript-eslint/no-unused-vars\n        error,\n        // eslint-disable-next-line @typescript-eslint/no-unused-vars\n        context\n      ) => {\n        console.log('📦 Executing serialization fallback strategy...');\n\n        // Switch to simpler serialization method\n        // This would be implemented by the calling code\n        return true;\n      },\n    });\n\n    // Timeout recovery strategy\n    this.addRecoveryStrategy({\n      name: 'timeout-recovery',\n      priority: 4,\n      condition: (error) =>\n        error instanceof TimeoutError ||\n        error.message.includes('timeout') ||\n        error.message.includes('timed out'),\n      action: async (error, context) => {\n        console.log('⏱️ Executing timeout recovery strategy...');\n\n        // Increase timeout for subsequent operations\n        this.adjustTimeouts(context.operation, 1.5);\n\n        return true;\n      },\n    });\n\n    // Generic retry strategy (lowest priority)\n    this.addRecoveryStrategy({\n      name: 'generic-retry',\n      priority: 1,\n      condition: () => true, // Always applicable as last resort\n      action: async (error, context) => {\n        console.log('🔁 Executing generic retry strategy...');\n\n        // Implement exponential backoff\n        const retryDelay = Math.min(\n          1000 *\n            Math.pow(2, (context.additionalData?.retryCount as number) || 0),\n          30000\n        );\n        await new Promise((resolve) => setTimeout(resolve, retryDelay));\n\n        return true;\n      },\n    });\n  }\n\n  /**\n   * Initializes default retry policies for different operations\n   */\n  private initializeDefaultRetryPolicies(): void {\n    this.retryPolicies.set('worker-execution', {\n      maxRetries: 3,\n      backoffMs: 1000,\n      multiplier: 2,\n    });\n\n    this.retryPolicies.set('serialization', {\n      maxRetries: 2,\n      backoffMs: 500,\n      multiplier: 1.5,\n    });\n\n    this.retryPolicies.set('pool-operation', {\n      maxRetries: 5,\n      backoffMs: 2000,\n      multiplier: 1.8,\n    });\n  }\n\n  /**\n   * Handles an error with automatic recovery attempts\n   */\n  async handleError(error: Error, context: ErrorContext): Promise<boolean> {\n    // Record the error\n    this.recordError(error, context);\n\n    // Check circuit breaker\n    if (this.isCircuitBreakerOpen(context.operation)) {\n      console.warn(\n        `🚫 Circuit breaker open for ${context.operation}, skipping recovery`\n      );\n      return false;\n    }\n\n    // Try recovery strategies in priority order\n    const strategies = this.recoveryStrategies\n      .filter((strategy) => strategy.condition(error, context))\n      .sort((a, b) => b.priority - a.priority);\n\n    for (const strategy of strategies) {\n      try {\n        console.log(`🔧 Attempting recovery strategy: ${strategy.name}`);\n        const success = await strategy.action(error, context);\n\n        if (success) {\n          console.log(`✅ Recovery successful with strategy: ${strategy.name}`);\n          this.recordRecoverySuccess(context.operation);\n          return true;\n        }\n      } catch (recoveryError) {\n        console.warn(\n          `❌ Recovery strategy ${strategy.name} failed:`,\n          recoveryError\n        );\n        this.recordRecoveryFailure(context.operation);\n      }\n    }\n\n    // Update circuit breaker state\n    this.updateCircuitBreaker(context.operation, false);\n\n    console.error(\n      `💥 All recovery strategies failed for error: ${error.message}`\n    );\n    return false;\n  }\n\n  /**\n   * Records an error for metrics and analysis\n   */\n  private recordError(error: Error, context: ErrorContext): void {\n    this.errors.push({ error, context });\n\n    // Keep only last 1000 errors to prevent memory leaks\n    if (this.errors.length > 1000) {\n      this.errors = this.errors.slice(-1000);\n    }\n\n    // Log error with context\n    console.error(`🚨 Error recorded: ${error.name}: ${error.message}`, {\n      operation: context.operation,\n      platform: context.platform,\n      timestamp: new Date(context.timestamp).toISOString(),\n    });\n  }\n\n  /**\n   * Checks if circuit breaker is open for an operation\n   */\n  private isCircuitBreakerOpen(operation: string): boolean {\n    const state = this.circuitBreakerStates.get(operation);\n    if (!state) return false;\n\n    // Auto-reset after 60 seconds\n    if (state.isOpen && Date.now() - state.lastFailure > 60000) {\n      state.isOpen = false;\n      state.failures = 0;\n      console.log(`🟢 Circuit breaker reset for ${operation}`);\n    }\n\n    return state.isOpen;\n  }\n\n  /**\n   * Updates circuit breaker state\n   */\n  private updateCircuitBreaker(operation: string, success: boolean): void {\n    let state = this.circuitBreakerStates.get(operation);\n    if (!state) {\n      state = { isOpen: false, failures: 0, lastFailure: 0 };\n      this.circuitBreakerStates.set(operation, state);\n    }\n\n    if (success) {\n      state.failures = 0;\n      if (state.isOpen) {\n        state.isOpen = false;\n        console.log(`🟢 Circuit breaker closed for ${operation}`);\n      }\n    } else {\n      state.failures++;\n      state.lastFailure = Date.now();\n\n      // Open circuit breaker after 5 consecutive failures\n      if (state.failures >= 5 && !state.isOpen) {\n        state.isOpen = true;\n        console.warn(\n          `🔴 Circuit breaker opened for ${operation} after ${state.failures} failures`\n        );\n      }\n    }\n  }\n\n  /**\n   * Records a successful recovery\n   */\n  private recordRecoverySuccess(operation: string): void {\n    this.updateCircuitBreaker(operation, true);\n  }\n\n  /**\n   * Records a failed recovery\n   */\n  private recordRecoveryFailure(operation: string): void {\n    this.updateCircuitBreaker(operation, false);\n  }\n\n  /**\n   * Adds a custom recovery strategy\n   */\n  addRecoveryStrategy(strategy: RecoveryStrategy): void {\n    this.recoveryStrategies.push(strategy);\n    this.recoveryStrategies.sort((a, b) => b.priority - a.priority);\n    console.log(\n      `➕ Added recovery strategy: ${strategy.name} (priority: ${strategy.priority})`\n    );\n  }\n\n  /**\n   * Sets retry policy for an operation\n   */\n  setRetryPolicy(\n    operation: string,\n    policy: { maxRetries: number; backoffMs: number; multiplier: number }\n  ): void {\n    this.retryPolicies.set(operation, policy);\n    console.log(`⚙️ Set retry policy for ${operation}:`, policy);\n  }\n\n  /**\n   * Executes an operation with automatic retry and error handling\n   */\n  async executeWithRetry<T>(\n    operation: string,\n    fn: () => Promise<T>,\n    context: Partial<ErrorContext> = {}\n  ): Promise<T> {\n    const policy =\n      this.retryPolicies.get(operation) ||\n      this.retryPolicies.get('worker-execution')!;\n    let lastError: Error | null = null;\n\n    for (let attempt = 0; attempt <= policy.maxRetries; attempt++) {\n      try {\n        const result = await fn();\n\n        // Success - update circuit breaker\n        this.updateCircuitBreaker(operation, true);\n\n        return result;\n      } catch (error) {\n        lastError = error as Error;\n\n        const errorContext: ErrorContext = {\n          operation,\n          timestamp: Date.now(),\n          platform: context.platform || 'unknown',\n          workerCount: context.workerCount || 0,\n          memoryUsage: context.memoryUsage,\n          stackTrace: lastError.stack,\n          additionalData: {\n            ...context.additionalData,\n            retryCount: attempt,\n            maxRetries: policy.maxRetries,\n          },\n        };\n\n        // Last attempt - don't retry, just handle error\n        if (attempt === policy.maxRetries) {\n          await this.handleError(lastError, errorContext);\n          break;\n        }\n\n        // Try recovery\n        const recovered = await this.handleError(lastError, errorContext);\n\n        if (!recovered && attempt < policy.maxRetries) {\n          // Wait before retry with exponential backoff\n          const delay = policy.backoffMs * Math.pow(policy.multiplier, attempt);\n          console.log(\n            `⏳ Retrying in ${delay}ms (attempt ${attempt + 1}/${policy.maxRetries})`\n          );\n          await new Promise((resolve) => setTimeout(resolve, delay));\n        }\n      }\n    }\n\n    throw (\n      lastError ||\n      new Error(\n        `Operation ${operation} failed after ${policy.maxRetries} retries`\n      )\n    );\n  }\n\n  /**\n   * Gets error metrics for analysis\n   */\n  getErrorMetrics(): ErrorMetrics {\n    if (this.errors.length === 0) {\n      return {\n        errorCount: 0,\n        errorRate: 0,\n        lastErrorTime: 0,\n        commonErrors: new Map(),\n        criticalErrors: 0,\n        recoverySuccessRate: 0,\n      };\n    }\n\n    const now = Date.now();\n    const last24Hours = this.errors.filter(\n      (e) => now - e.context.timestamp < 24 * 60 * 60 * 1000\n    );\n\n    const commonErrors = new Map<string, number>();\n    let criticalErrors = 0;\n\n    last24Hours.forEach(({ error }) => {\n      const errorKey = `${error.name}: ${error.message}`;\n      commonErrors.set(errorKey, (commonErrors.get(errorKey) || 0) + 1);\n\n      if (error instanceof TimeoutError || error instanceof WorkerError) {\n        criticalErrors++;\n      }\n    });\n\n    return {\n      errorCount: this.errors.length,\n      errorRate: last24Hours.length / Math.max(1, 24), // errors per hour\n      lastErrorTime: this.errors[this.errors.length - 1].context.timestamp,\n      commonErrors,\n      criticalErrors,\n      recoverySuccessRate: this.calculateRecoverySuccessRate(),\n    };\n  }\n\n  /**\n   * Calculates recovery success rate\n   */\n  private calculateRecoverySuccessRate(): number {\n    // This would be calculated based on actual recovery attempts\n    // For now, return a placeholder\n    return 0.85; // 85% success rate\n  }\n\n  /**\n   * Helper methods for recovery strategies\n   */\n  private clearInternalCaches(): void {\n    // Clear any internal caches here\n    console.log('🧹 Clearing internal caches...');\n  }\n\n  private async reduceWorkerPoolSize(context: ErrorContext): Promise<void> {\n    // Reduce worker pool size temporarily\n    console.log(\n      `📉 Reducing worker pool size from ${context.workerCount} to ${Math.max(1, Math.floor(context.workerCount / 2))}`\n    );\n  }\n\n  private adjustTimeouts(operation: string, multiplier: number): void {\n    console.log(`⏱️ Increasing timeout for ${operation} by ${multiplier}x`);\n    // This would adjust timeouts in the actual operation handlers\n  }\n\n  /**\n   * Generates a comprehensive error report\n   */\n  generateErrorReport(): string {\n    const metrics = this.getErrorMetrics();\n\n    let report = `🚨 Error Analysis Report\\n`;\n    report += `═══════════════════════════════════════\\n`;\n    report += `📊 Total Errors: ${metrics.errorCount}\\n`;\n    report += `⚡ Error Rate: ${metrics.errorRate.toFixed(2)} errors/hour\\n`;\n    report += `🔥 Critical Errors: ${metrics.criticalErrors}\\n`;\n    report += `✅ Recovery Success Rate: ${(metrics.recoverySuccessRate * 100).toFixed(1)}%\\n`;\n\n    if (metrics.lastErrorTime > 0) {\n      const timeSinceLastError =\n        (Date.now() - metrics.lastErrorTime) / 1000 / 60;\n      report += `⏰ Last Error: ${timeSinceLastError.toFixed(1)} minutes ago\\n`;\n    }\n\n    if (metrics.commonErrors.size > 0) {\n      report += `\\n🔍 Most Common Errors:\\n`;\n      const sortedErrors = Array.from(metrics.commonErrors.entries())\n        .sort((a, b) => b[1] - a[1])\n        .slice(0, 5);\n\n      sortedErrors.forEach(([error, count], index) => {\n        report += `${index + 1}. ${error} (${count} times)\\n`;\n      });\n    }\n\n    // Circuit breaker status\n    report += `\\n🔴 Circuit Breaker Status:\\n`;\n    for (const [operation, state] of this.circuitBreakerStates) {\n      const status = state.isOpen ? '🔴 OPEN' : '🟢 CLOSED';\n      report += `- ${operation}: ${status} (failures: ${state.failures})\\n`;\n    }\n\n    return report;\n  }\n\n  /**\n   * Resets all error data and states\n   */\n  reset(): void {\n    this.errors = [];\n    this.circuitBreakerStates.clear();\n    console.log('🔄 Error handler reset');\n  }\n\n  /**\n   * Gets recent errors for debugging\n   */\n  getRecentErrors(\n    count: number = 10\n  ): Array<{ error: Error; context: ErrorContext }> {\n    return this.errors.slice(-count);\n  }\n}\n\n// Global error handler instance\nexport const errorHandler = new ErrorHandler();\n","/**\n * ThreadTS Universal - Performance Monitoring System\n * Advanced performance tracking and diagnostics\n */\n\nexport interface PerformanceMetrics {\n  timestamp: number;\n  cpuUsage?: number;\n  memoryUsage: {\n    used: number;\n    total: number;\n    heap?: {\n      used: number;\n      total: number;\n      limit: number;\n    };\n  };\n  executionTime: number;\n  throughput: number; // operations per second\n  errorRate: number;\n  workerPoolStats?: {\n    activeWorkers: number;\n    idleWorkers: number;\n    queuedTasks: number;\n    averageTaskTime: number;\n  };\n}\n\nexport interface PerformanceAlert {\n  type: 'memory' | 'cpu' | 'latency' | 'error_rate' | 'throughput';\n  severity: 'low' | 'medium' | 'high' | 'critical';\n  message: string;\n  threshold: number;\n  actualValue: number;\n  timestamp: number;\n  recommendations: string[];\n}\n\nexport class PerformanceMonitor {\n  private metrics: PerformanceMetrics[] = [];\n  private alerts: PerformanceAlert[] = [];\n  private isMonitoring = false;\n  private monitoringInterval?: NodeJS.Timeout;\n\n  private readonly thresholds = {\n    memoryUsage: 100 * 1024 * 1024, // 100MB\n    cpuUsage: 80, // 80%\n    maxLatency: 1000, // 1000ms\n    errorRate: 0.05, // 5%\n    minThroughput: 100, // 100 ops/sec\n  };\n\n  /**\n   * Starts continuous performance monitoring\n   */\n  startMonitoring(intervalMs: number = 5000): void {\n    if (this.isMonitoring) {\n      console.warn('Performance monitoring is already active');\n      return;\n    }\n\n    this.isMonitoring = true;\n    this.monitoringInterval = setInterval(() => {\n      this.collectMetrics();\n    }, intervalMs);\n\n    console.log(\n      `🔍 Performance monitoring started (interval: ${intervalMs}ms)`\n    );\n  }\n\n  /**\n   * Stops performance monitoring\n   */\n  stopMonitoring(): void {\n    if (this.monitoringInterval) {\n      clearInterval(this.monitoringInterval);\n      this.monitoringInterval = undefined;\n    }\n    this.isMonitoring = false;\n    console.log('📊 Performance monitoring stopped');\n  }\n\n  /**\n   * Collects current performance metrics\n   */\n  collectMetrics(): PerformanceMetrics {\n    const metrics: PerformanceMetrics = {\n      timestamp: Date.now(),\n      memoryUsage: this.getMemoryUsage(),\n      executionTime: this.getAverageExecutionTime(),\n      throughput: this.calculateThroughput(),\n      errorRate: this.calculateErrorRate(),\n    };\n\n    // Add CPU usage if available\n    const cpuUsage = this.getCPUUsage();\n    if (cpuUsage !== null) {\n      metrics.cpuUsage = cpuUsage;\n    }\n\n    this.metrics.push(metrics);\n    this.checkThresholds(metrics);\n\n    // Keep only last 1000 metrics to prevent memory leaks\n    if (this.metrics.length > 1000) {\n      this.metrics = this.metrics.slice(-1000);\n    }\n\n    return metrics;\n  }\n\n  /**\n   * Gets current memory usage information\n   */\n  private getMemoryUsage(): PerformanceMetrics['memoryUsage'] {\n    if (typeof process !== 'undefined' && process.memoryUsage) {\n      // Node.js environment\n      const nodeMemory = process.memoryUsage();\n      return {\n        used: nodeMemory.rss,\n        total: nodeMemory.rss + nodeMemory.heapTotal,\n        heap: {\n          used: nodeMemory.heapUsed,\n          total: nodeMemory.heapTotal,\n          limit: nodeMemory.rss + nodeMemory.heapTotal,\n        },\n      };\n    }\n\n    if (typeof performance !== 'undefined' && 'memory' in performance) {\n      // Browser environment with memory API\n      const browserMemory = (\n        performance as {\n          memory: {\n            usedJSHeapSize: number;\n            totalJSHeapSize: number;\n            jsHeapSizeLimit: number;\n          };\n        }\n      ).memory;\n      return {\n        used: browserMemory.usedJSHeapSize,\n        total: browserMemory.totalJSHeapSize,\n        heap: {\n          used: browserMemory.usedJSHeapSize,\n          total: browserMemory.totalJSHeapSize,\n          limit: browserMemory.jsHeapSizeLimit,\n        },\n      };\n    }\n\n    // Fallback for environments without memory APIs\n    return {\n      used: 0,\n      total: 0,\n    };\n  }\n\n  /**\n   * Gets CPU usage (Node.js only)\n   */\n  private getCPUUsage(): number | null {\n    if (typeof process !== 'undefined' && process.cpuUsage) {\n      const usage = process.cpuUsage();\n      return (usage.user + usage.system) / 1000000; // Convert to percentage\n    }\n    return null;\n  }\n\n  /**\n   * Calculates average execution time from recent operations\n   */\n  private getAverageExecutionTime(): number {\n    if (this.metrics.length === 0) return 0;\n\n    const recentMetrics = this.metrics.slice(-10);\n    const totalTime = recentMetrics.reduce(\n      (sum, metric) => sum + metric.executionTime,\n      0\n    );\n    return totalTime / recentMetrics.length;\n  }\n\n  /**\n   * Calculates current throughput (operations per second)\n   */\n  private calculateThroughput(): number {\n    if (this.metrics.length < 2) return 0;\n\n    const recentMetrics = this.metrics.slice(-5);\n    const timeWindow =\n      recentMetrics[recentMetrics.length - 1].timestamp -\n      recentMetrics[0].timestamp;\n\n    if (timeWindow === 0) return 0;\n\n    return (recentMetrics.length * 1000) / timeWindow; // ops per second\n  }\n\n  /**\n   * Calculates current error rate\n   */\n  private calculateErrorRate(): number {\n    // This would need to be implemented based on actual error tracking\n    // For now, return 0 as a placeholder\n    return 0;\n  }\n\n  /**\n   * Checks if metrics exceed thresholds and creates alerts\n   */\n  private checkThresholds(metrics: PerformanceMetrics): void {\n    // Memory usage check\n    if (metrics.memoryUsage.used > this.thresholds.memoryUsage) {\n      this.createAlert({\n        type: 'memory',\n        severity: 'high',\n        message: `High memory usage detected: ${Math.round(metrics.memoryUsage.used / 1024 / 1024)}MB`,\n        threshold: this.thresholds.memoryUsage,\n        actualValue: metrics.memoryUsage.used,\n        timestamp: metrics.timestamp,\n        recommendations: [\n          'Check for memory leaks in worker threads',\n          'Reduce batch size for large operations',\n          'Implement memory cleanup in long-running processes',\n        ],\n      });\n    }\n\n    // CPU usage check\n    if (metrics.cpuUsage && metrics.cpuUsage > this.thresholds.cpuUsage) {\n      this.createAlert({\n        type: 'cpu',\n        severity: 'medium',\n        message: `High CPU usage detected: ${metrics.cpuUsage.toFixed(1)}%`,\n        threshold: this.thresholds.cpuUsage,\n        actualValue: metrics.cpuUsage,\n        timestamp: metrics.timestamp,\n        recommendations: [\n          'Consider reducing worker pool size',\n          'Optimize CPU-intensive operations',\n          'Implement operation throttling',\n        ],\n      });\n    }\n\n    // Latency check\n    if (metrics.executionTime > this.thresholds.maxLatency) {\n      this.createAlert({\n        type: 'latency',\n        severity: 'medium',\n        message: `High latency detected: ${metrics.executionTime.toFixed(2)}ms`,\n        threshold: this.thresholds.maxLatency,\n        actualValue: metrics.executionTime,\n        timestamp: metrics.timestamp,\n        recommendations: [\n          'Profile slow operations',\n          'Optimize data serialization',\n          'Consider operation caching',\n        ],\n      });\n    }\n\n    // Throughput check\n    if (metrics.throughput < this.thresholds.minThroughput) {\n      this.createAlert({\n        type: 'throughput',\n        severity: 'low',\n        message: `Low throughput detected: ${metrics.throughput.toFixed(1)} ops/sec`,\n        threshold: this.thresholds.minThroughput,\n        actualValue: metrics.throughput,\n        timestamp: metrics.timestamp,\n        recommendations: [\n          'Increase worker pool size',\n          'Optimize task distribution',\n          'Review system resource constraints',\n        ],\n      });\n    }\n  }\n\n  /**\n   * Creates a performance alert\n   */\n  private createAlert(alert: PerformanceAlert): void {\n    this.alerts.push(alert);\n\n    // Keep only last 100 alerts\n    if (this.alerts.length > 100) {\n      this.alerts = this.alerts.slice(-100);\n    }\n\n    // Log the alert\n    const severityIcon = {\n      low: '💡',\n      medium: '⚠️',\n      high: '🚨',\n      critical: '🔥',\n    };\n\n    console.warn(\n      `${severityIcon[alert.severity]} Performance Alert: ${alert.message}`\n    );\n\n    if (alert.severity === 'critical' || alert.severity === 'high') {\n      console.warn(`Recommendations: ${alert.recommendations.join(', ')}`);\n    }\n  }\n\n  /**\n   * Gets recent performance metrics\n   */\n  getMetrics(count: number = 10): PerformanceMetrics[] {\n    return this.metrics.slice(-count);\n  }\n\n  /**\n   * Gets recent alerts\n   */\n  getAlerts(count: number = 10): PerformanceAlert[] {\n    return this.alerts.slice(-count);\n  }\n\n  /**\n   * Generates a performance summary report\n   */\n  generateReport(): string {\n    const recentMetrics = this.getMetrics(20);\n    const recentAlerts = this.getAlerts(5);\n\n    if (recentMetrics.length === 0) {\n      return '📊 No performance data available';\n    }\n\n    const avgMemory =\n      recentMetrics.reduce((sum, m) => sum + m.memoryUsage.used, 0) /\n      recentMetrics.length;\n    const avgThroughput =\n      recentMetrics.reduce((sum, m) => sum + m.throughput, 0) /\n      recentMetrics.length;\n    const avgLatency =\n      recentMetrics.reduce((sum, m) => sum + m.executionTime, 0) /\n      recentMetrics.length;\n\n    let report = `📊 Performance Report\\n`;\n    report += `═══════════════════════════════════════\\n`;\n    report += `📅 Period: Last ${recentMetrics.length} measurements\\n`;\n    report += `💾 Avg Memory: ${Math.round(avgMemory / 1024 / 1024)}MB\\n`;\n    report += `⚡ Avg Throughput: ${avgThroughput.toFixed(1)} ops/sec\\n`;\n    report += `⏱️ Avg Latency: ${avgLatency.toFixed(2)}ms\\n`;\n\n    if (recentAlerts.length > 0) {\n      report += `\\n🚨 Recent Alerts (${recentAlerts.length}):\\n`;\n      recentAlerts.forEach((alert, index) => {\n        report += `${index + 1}. [${alert.severity.toUpperCase()}] ${alert.message}\\n`;\n      });\n    } else {\n      report += `\\n✅ No recent alerts\\n`;\n    }\n\n    return report;\n  }\n\n  /**\n   * Resets all collected metrics and alerts\n   */\n  reset(): void {\n    this.metrics = [];\n    this.alerts = [];\n    console.log('📊 Performance monitor data reset');\n  }\n\n  /**\n   * Gets the monitoring status\n   */\n  isActive(): boolean {\n    return this.isMonitoring;\n  }\n}\n\n// Global performance monitor instance\nexport const performanceMonitor = new PerformanceMonitor();\n","/**\n * ThreadTS Universal - Health Check System\n * Comprehensive system health monitoring and diagnostics\n */\n\nimport { detectPlatform, supportsWorkerThreads } from '../utils/platform';\nimport { errorHandler } from './error-handler';\nimport { performanceMonitor } from './performance';\n\nexport interface HealthStatus {\n  overall: 'healthy' | 'warning' | 'critical' | 'unknown';\n  timestamp: number;\n  uptime: number;\n  checks: HealthCheck[];\n  summary: string;\n  recommendations: string[];\n}\n\nexport interface HealthCheck {\n  name: string;\n  status: 'pass' | 'warn' | 'fail';\n  message: string;\n  details?: Record<string, unknown>;\n  duration: number;\n}\n\nexport class HealthMonitor {\n  private startTime: number = Date.now();\n  private lastHealthCheck?: HealthStatus;\n  private healthCheckInterval?: NodeJS.Timeout;\n  private isMonitoring = false;\n\n  /**\n   * Starts continuous health monitoring\n   */\n  startHealthMonitoring(intervalMs: number = 30000): void {\n    if (this.isMonitoring) {\n      console.warn('Health monitoring is already active');\n      return;\n    }\n\n    this.isMonitoring = true;\n    this.healthCheckInterval = setInterval(async () => {\n      await this.performHealthCheck();\n    }, intervalMs);\n\n    console.log(`🏥 Health monitoring started (interval: ${intervalMs}ms)`);\n  }\n\n  /**\n   * Stops health monitoring\n   */\n  stopHealthMonitoring(): void {\n    if (this.healthCheckInterval) {\n      clearInterval(this.healthCheckInterval);\n      this.healthCheckInterval = undefined;\n    }\n    this.isMonitoring = false;\n    console.log('🏥 Health monitoring stopped');\n  }\n\n  /**\n   * Performs a comprehensive health check\n   */\n  async performHealthCheck(): Promise<HealthStatus> {\n    const checks: HealthCheck[] = [];\n\n    // Platform compatibility check\n    checks.push(await this.checkPlatformCompatibility());\n\n    // Worker support check\n    checks.push(await this.checkWorkerSupport());\n\n    // Memory health check\n    checks.push(await this.checkMemoryHealth());\n\n    // Performance metrics check\n    checks.push(await this.checkPerformanceMetrics());\n\n    // Error rate check\n    checks.push(await this.checkErrorRate());\n\n    // System resources check\n    checks.push(await this.checkSystemResources());\n\n    // Dependency health check\n    checks.push(await this.checkDependencyHealth());\n\n    // Calculate overall status\n    const overall = this.calculateOverallStatus(checks);\n    const uptime = Date.now() - this.startTime;\n\n    const healthStatus: HealthStatus = {\n      overall,\n      timestamp: Date.now(),\n      uptime,\n      checks,\n      summary: this.generateSummary(overall, checks),\n      recommendations: this.generateRecommendations(checks),\n    };\n\n    this.lastHealthCheck = healthStatus;\n\n    // Log health status if not healthy\n    if (overall !== 'healthy') {\n      console.warn(`🏥 Health status: ${overall.toUpperCase()}`);\n      if (overall === 'critical') {\n        console.error(\n          '🚨 Critical health issues detected:',\n          healthStatus.summary\n        );\n      }\n    }\n\n    return healthStatus;\n  }\n\n  /**\n   * Checks platform compatibility\n   */\n  private async checkPlatformCompatibility(): Promise<HealthCheck> {\n    const start = Date.now();\n    const platform = detectPlatform();\n\n    const supportedPlatforms = ['browser', 'node', 'deno', 'bun'];\n    const isSupported = supportedPlatforms.includes(platform);\n\n    return {\n      name: 'Platform Compatibility',\n      status: isSupported ? 'pass' : 'fail',\n      message: isSupported\n        ? `Running on supported platform: ${platform}`\n        : `Unsupported platform detected: ${platform}`,\n      details: { platform, supported: isSupported },\n      duration: Date.now() - start,\n    };\n  }\n\n  /**\n   * Checks worker thread support\n   */\n  private async checkWorkerSupport(): Promise<HealthCheck> {\n    const start = Date.now();\n    const hasWorkerSupport = supportsWorkerThreads();\n    const platform = detectPlatform();\n\n    let status: 'pass' | 'warn' | 'fail' = 'pass';\n    let message = 'Worker threads are supported and available';\n\n    if (!hasWorkerSupport) {\n      status = platform === 'browser' ? 'warn' : 'fail';\n      message = `Worker threads not supported on ${platform}. Falling back to synchronous execution.`;\n    }\n\n    return {\n      name: 'Worker Support',\n      status,\n      message,\n      details: {\n        hasSupport: hasWorkerSupport,\n        platform,\n        fallbackAvailable: true,\n      },\n      duration: Date.now() - start,\n    };\n  }\n\n  /**\n   * Checks memory health\n   */\n  private async checkMemoryHealth(): Promise<HealthCheck> {\n    const start = Date.now();\n    let memoryUsage = 0;\n    let totalMemory = 0;\n    let heapUsed = 0;\n\n    try {\n      if (typeof process !== 'undefined' && process.memoryUsage) {\n        const nodeMemory = process.memoryUsage();\n        memoryUsage = nodeMemory.rss;\n        totalMemory = nodeMemory.rss + nodeMemory.heapTotal;\n        heapUsed = nodeMemory.heapUsed;\n      } else if (\n        typeof performance !== 'undefined' &&\n        'memory' in performance\n      ) {\n        const browserMemory = (\n          performance as {\n            memory: {\n              usedJSHeapSize: number;\n              totalJSHeapSize: number;\n              jsHeapSizeLimit: number;\n            };\n          }\n        ).memory;\n        memoryUsage = browserMemory.usedJSHeapSize;\n        totalMemory = browserMemory.totalJSHeapSize;\n        heapUsed = browserMemory.usedJSHeapSize;\n      }\n\n      const memoryUsageMB = memoryUsage / 1024 / 1024;\n      let status: 'pass' | 'warn' | 'fail' = 'pass';\n      let message = `Memory usage is healthy: ${memoryUsageMB.toFixed(1)}MB`;\n\n      if (memoryUsageMB > 500) {\n        status = 'fail';\n        message = `High memory usage detected: ${memoryUsageMB.toFixed(1)}MB`;\n      } else if (memoryUsageMB > 200) {\n        status = 'warn';\n        message = `Elevated memory usage: ${memoryUsageMB.toFixed(1)}MB`;\n      }\n\n      return {\n        name: 'Memory Health',\n        status,\n        message,\n        details: {\n          memoryUsageMB: memoryUsageMB,\n          totalMemoryMB: totalMemory / 1024 / 1024,\n          heapUsedMB: heapUsed / 1024 / 1024,\n        },\n        duration: Date.now() - start,\n      };\n    } catch (error) {\n      return {\n        name: 'Memory Health',\n        status: 'warn',\n        message: 'Unable to retrieve memory information',\n        details: { error: (error as Error).message },\n        duration: Date.now() - start,\n      };\n    }\n  }\n\n  /**\n   * Checks performance metrics\n   */\n  private async checkPerformanceMetrics(): Promise<HealthCheck> {\n    const start = Date.now();\n\n    if (!performanceMonitor.isActive()) {\n      return {\n        name: 'Performance Metrics',\n        status: 'warn',\n        message: 'Performance monitoring is not active',\n        details: { monitoringActive: false },\n        duration: Date.now() - start,\n      };\n    }\n\n    const metrics = performanceMonitor.getMetrics(5);\n\n    if (metrics.length === 0) {\n      return {\n        name: 'Performance Metrics',\n        status: 'warn',\n        message: 'No performance data available',\n        details: { metricsCount: 0 },\n        duration: Date.now() - start,\n      };\n    }\n\n    const avgThroughput =\n      metrics.reduce((sum, m) => sum + m.throughput, 0) / metrics.length;\n    const avgLatency =\n      metrics.reduce((sum, m) => sum + m.executionTime, 0) / metrics.length;\n\n    let status: 'pass' | 'warn' | 'fail' = 'pass';\n    let message = `Performance is good: ${avgThroughput.toFixed(1)} ops/sec, ${avgLatency.toFixed(2)}ms latency`;\n\n    if (avgLatency > 5000) {\n      status = 'fail';\n      message = `Poor performance: High latency ${avgLatency.toFixed(2)}ms`;\n    } else if (avgLatency > 2000 || avgThroughput < 10) {\n      status = 'warn';\n      message = `Performance degradation: ${avgThroughput.toFixed(1)} ops/sec, ${avgLatency.toFixed(2)}ms latency`;\n    }\n\n    return {\n      name: 'Performance Metrics',\n      status,\n      message,\n      details: {\n        avgThroughput,\n        avgLatency,\n        metricsCount: metrics.length,\n      },\n      duration: Date.now() - start,\n    };\n  }\n\n  /**\n   * Checks error rate\n   */\n  private async checkErrorRate(): Promise<HealthCheck> {\n    const start = Date.now();\n    const errorMetrics = errorHandler.getErrorMetrics();\n\n    let status: 'pass' | 'warn' | 'fail' = 'pass';\n    let message = `Error rate is acceptable: ${(errorMetrics.errorRate * 100).toFixed(2)}% errors`;\n\n    if (errorMetrics.errorRate > 0.1) {\n      // > 10%\n      status = 'fail';\n      message = `High error rate: ${(errorMetrics.errorRate * 100).toFixed(2)}%`;\n    } else if (errorMetrics.errorRate > 0.05) {\n      // > 5%\n      status = 'warn';\n      message = `Elevated error rate: ${(errorMetrics.errorRate * 100).toFixed(2)}%`;\n    }\n\n    return {\n      name: 'Error Rate',\n      status,\n      message,\n      details: {\n        errorRate: errorMetrics.errorRate,\n        totalErrors: errorMetrics.errorCount,\n        criticalErrors: errorMetrics.criticalErrors,\n        recoveryRate: errorMetrics.recoverySuccessRate,\n      },\n      duration: Date.now() - start,\n    };\n  }\n\n  /**\n   * Checks system resources\n   */\n  private async checkSystemResources(): Promise<HealthCheck> {\n    const start = Date.now();\n\n    try {\n      // Check if we can create a simple worker (basic functionality test)\n      const testStart = Date.now();\n      const testDuration = Date.now() - testStart;\n\n      let status: 'pass' | 'warn' | 'fail' = 'pass';\n      let message = `System resources are available (test completed in ${testDuration}ms)`;\n\n      if (testDuration > 5000) {\n        status = 'warn';\n        message = `Slow system response: ${testDuration}ms`;\n      }\n\n      return {\n        name: 'System Resources',\n        status,\n        message,\n        details: {\n          testDuration,\n          resourcesAvailable: true,\n        },\n        duration: Date.now() - start,\n      };\n    } catch (error) {\n      return {\n        name: 'System Resources',\n        status: 'fail',\n        message: `System resource check failed: ${(error as Error).message}`,\n        details: { error: (error as Error).message },\n        duration: Date.now() - start,\n      };\n    }\n  }\n\n  /**\n   * Checks dependency health\n   */\n  private async checkDependencyHealth(): Promise<HealthCheck> {\n    const start = Date.now();\n\n    const dependencies = [\n      { name: 'global', check: () => typeof globalThis !== 'undefined' },\n      { name: 'Promise', check: () => typeof Promise !== 'undefined' },\n      { name: 'setTimeout', check: () => typeof setTimeout !== 'undefined' },\n      { name: 'console', check: () => typeof console !== 'undefined' },\n    ];\n\n    const failed = dependencies.filter((dep) => !dep.check());\n\n    if (failed.length === 0) {\n      return {\n        name: 'Dependency Health',\n        status: 'pass',\n        message: 'All required dependencies are available',\n        details: { dependencies: dependencies.map((d) => d.name) },\n        duration: Date.now() - start,\n      };\n    } else {\n      return {\n        name: 'Dependency Health',\n        status: 'fail',\n        message: `Missing dependencies: ${failed.map((d) => d.name).join(', ')}`,\n        details: { failed: failed.map((d) => d.name) },\n        duration: Date.now() - start,\n      };\n    }\n  }\n\n  /**\n   * Calculates overall health status based on individual checks\n   */\n  private calculateOverallStatus(\n    checks: HealthCheck[]\n  ): 'healthy' | 'warning' | 'critical' | 'unknown' {\n    if (checks.length === 0) return 'unknown';\n\n    const hasCritical = checks.some((check) => check.status === 'fail');\n    const hasWarnings = checks.some((check) => check.status === 'warn');\n\n    if (hasCritical) return 'critical';\n    if (hasWarnings) return 'warning';\n    return 'healthy';\n  }\n\n  /**\n   * Generates a health summary\n   */\n  private generateSummary(overall: string, checks: HealthCheck[]): string {\n    const passCount = checks.filter((c) => c.status === 'pass').length;\n    const warnCount = checks.filter((c) => c.status === 'warn').length;\n    const failCount = checks.filter((c) => c.status === 'fail').length;\n\n    return `Health: ${overall.toUpperCase()} | Checks: ${passCount} pass, ${warnCount} warn, ${failCount} fail`;\n  }\n\n  /**\n   * Generates health recommendations\n   */\n  private generateRecommendations(checks: HealthCheck[]): string[] {\n    const recommendations: string[] = [];\n\n    checks.forEach((check) => {\n      if (check.status === 'fail') {\n        switch (check.name) {\n          case 'Memory Health':\n            recommendations.push(\n              'Consider reducing batch sizes and implementing memory cleanup'\n            );\n            break;\n          case 'Performance Metrics':\n            recommendations.push(\n              'Profile application for performance bottlenecks'\n            );\n            break;\n          case 'Error Rate':\n            recommendations.push('Investigate and fix recurring errors');\n            break;\n          case 'Worker Support':\n            recommendations.push('Consider platform-specific optimizations');\n            break;\n          case 'System Resources':\n            recommendations.push('Check system load and available resources');\n            break;\n        }\n      } else if (check.status === 'warn') {\n        switch (check.name) {\n          case 'Memory Health':\n            recommendations.push('Monitor memory usage trends');\n            break;\n          case 'Performance Metrics':\n            recommendations.push('Consider performance optimizations');\n            break;\n          case 'Error Rate':\n            recommendations.push(\n              'Review error patterns and implement preventive measures'\n            );\n            break;\n        }\n      }\n    });\n\n    if (recommendations.length === 0) {\n      recommendations.push('System is healthy - continue monitoring');\n    }\n\n    return recommendations;\n  }\n\n  /**\n   * Gets the last health check result\n   */\n  getLastHealthCheck(): HealthStatus | undefined {\n    return this.lastHealthCheck;\n  }\n\n  /**\n   * Gets system uptime in milliseconds\n   */\n  getUptime(): number {\n    return Date.now() - this.startTime;\n  }\n\n  /**\n   * Generates a comprehensive health report\n   */\n  generateHealthReport(): string {\n    const health = this.lastHealthCheck;\n\n    if (!health) {\n      return '🏥 No health data available. Run performHealthCheck() first.';\n    }\n\n    let report = `🏥 ThreadTS Universal - Health Report\\n`;\n    report += `═══════════════════════════════════════════════════\\n`;\n    report += `🎯 Overall Status: ${health.overall.toUpperCase()}\\n`;\n    report += `⏰ Timestamp: ${new Date(health.timestamp).toISOString()}\\n`;\n    report += `🕐 Uptime: ${Math.round(health.uptime / 1000 / 60)} minutes\\n`;\n    report += `📋 Summary: ${health.summary}\\n`;\n\n    report += `\\n🔍 Health Checks:\\n`;\n    health.checks.forEach((check, index) => {\n      const statusIcon =\n        check.status === 'pass' ? '✅' : check.status === 'warn' ? '⚠️' : '❌';\n      report += `${index + 1}. ${statusIcon} ${check.name}: ${check.message}\\n`;\n\n      if (check.details && Object.keys(check.details).length > 0) {\n        report += `   Details: ${JSON.stringify(check.details, null, 2).replace(/\\n/g, '\\n   ')}\\n`;\n      }\n    });\n\n    if (health.recommendations.length > 0) {\n      report += `\\n💡 Recommendations:\\n`;\n      health.recommendations.forEach((rec, index) => {\n        report += `${index + 1}. ${rec}\\n`;\n      });\n    }\n\n    return report;\n  }\n\n  /**\n   * Performs a quick health check (essential checks only)\n   */\n  async quickHealthCheck(): Promise<{\n    status: 'healthy' | 'warning' | 'critical';\n    message: string;\n  }> {\n    const checks = [\n      await this.checkPlatformCompatibility(),\n      await this.checkWorkerSupport(),\n      await this.checkMemoryHealth(),\n    ];\n\n    const overall = this.calculateOverallStatus(checks);\n    const failedChecks = checks.filter((c) => c.status === 'fail');\n    const warningChecks = checks.filter((c) => c.status === 'warn');\n\n    let message = 'System is healthy';\n    if (failedChecks.length > 0) {\n      message = `Critical issues: ${failedChecks.map((c) => c.name).join(', ')}`;\n    } else if (warningChecks.length > 0) {\n      message = `Warnings: ${warningChecks.map((c) => c.name).join(', ')}`;\n    }\n\n    // Map unknown to warning for the quick check\n    const status = overall === 'unknown' ? 'warning' : overall;\n\n    return { status, message };\n  }\n\n  /**\n   * Resets the health monitor\n   */\n  reset(): void {\n    this.startTime = Date.now();\n    this.lastHealthCheck = undefined;\n    console.log('🏥 Health monitor reset');\n  }\n}\n\n// Global health monitor instance\nexport const healthMonitor = new HealthMonitor();\n","/**\n * ThreadTS Universal - Main Entry Point\n * Universal TypeScript library for effortless parallel computing\n *\n * @packageDocumentation\n * @module threadts-universal\n *\n * @example\n * ```typescript\n * import threadts from 'threadts-universal';\n *\n * // Simple parallel execution\n * const result = await threadts.run((x) => x * 2, 21);\n *\n * // Array operations\n * const squares = await threadts.map([1, 2, 3], x => x * x);\n * const found = await threadts.find([1, 2, 3, 4], x => x > 2);\n *\n * // Using options (e.g., batchSize) with find\n * const foundWithOptions = await threadts.find(\n *   [1, 2, 3, 4],\n *   x => x > 2,\n *   { batchSize: 2 }\n * );\n * ```\n */\n\n// Core exports\nexport {\n  Pipeline,\n  TerminalPipeline,\n  ThreadTS,\n  default as threadts,\n} from './core/threadts';\n\n// Array operations exports\nexport {\n  createArrayOperations,\n  type ArrayOperationExecutor,\n  type ArrayOperations,\n} from './core/array-operations';\n\n// Type exports\nexport type {\n  MapOptions,\n  ParallelMethodOptions,\n  Platform,\n  PoolConfig,\n  PoolManager,\n  PoolStats,\n  ProgressEvent,\n  ProgressTracker,\n  ThreadOptions,\n  ThreadResult,\n  ThreadTask,\n  WorkerAdapter,\n  WorkerInstance,\n} from './types';\n\n// Error exports\nexport {\n  SerializationError,\n  ThreadError,\n  TimeoutError,\n  WorkerError,\n} from './types';\n\n// Decorator exports\nexport {\n  cache,\n  circuitBreaker,\n  concurrent,\n  createClassDecorator,\n  createMethodDecorator,\n  createMethodDecoratorWithClass,\n  debounce,\n  lazy,\n  logged,\n  measure,\n  memoize,\n  parallel,\n  parallelBatch,\n  parallelClass,\n  parallelMap,\n  parallelMethod,\n  rateLimit,\n  retry,\n  throttle,\n  timeout,\n  validate,\n} from './decorators';\n\n// Utility exports\nexport {\n  detectPlatform,\n  getHighResTimestamp,\n  getMemoryInfo,\n  getOptimalThreadCount,\n  supportsOffscreenCanvas,\n  supportsTransferableObjects,\n  supportsWebLocks,\n  supportsWorkerThreads,\n} from './utils/platform';\n\nexport type { MemoryInfo } from './utils/platform';\n\nexport {\n  createWorkerScript,\n  deserializeData,\n  deserializeFunction,\n  hasTransferables,\n  restoreTransferables,\n  serializeData,\n  serializeFunction,\n} from './utils/serialization';\n\n// Validation utilities\nexport {\n  ValidationUtils,\n  toNonNegativeInt,\n  toPositiveInt,\n  validateArray,\n  validateEnum,\n  validateFunction,\n  validateNonEmptyArray,\n  validateNonNegativeNumber,\n  validatePositiveNumber,\n  validateRange,\n  validateSerializable,\n  validateTask,\n  validateTasks,\n  validateThreadOptions,\n} from './utils/validation';\n\nexport type { ValidationResult } from './utils/validation';\n\n// Adapter exports (for advanced usage)\nexport { BrowserWorkerAdapter } from './adapters/browser';\nexport { BunWorkerAdapter } from './adapters/bun';\nexport { DenoWorkerAdapter } from './adapters/deno';\nexport { NodeWorkerAdapter } from './adapters/node';\n\n// Base adapter export (for extending)\nexport {\n  AbstractWorkerAdapter,\n  AbstractWorkerInstance,\n  createWorkerErrorMessage,\n  isWorkerInstance,\n} from './adapters/base';\n\nexport type { BaseWorkerConfig, WorkerExecutionMetrics } from './adapters/base';\n\n// Pool manager export\nexport { ThreadPoolManager } from './pool/manager';\n\n// Monitoring and diagnostics\nexport { ErrorHandler, errorHandler } from './monitoring/error-handler';\nexport type {\n  ErrorContext,\n  ErrorMetrics,\n  RecoveryStrategy,\n} from './monitoring/error-handler';\nexport { HealthMonitor, healthMonitor } from './monitoring/health';\nexport type { HealthCheck, HealthStatus } from './monitoring/health';\nexport {\n  PerformanceMonitor,\n  performanceMonitor,\n} from './monitoring/performance';\nexport type {\n  PerformanceAlert,\n  PerformanceMetrics,\n} from './monitoring/performance';\n\n// Default export for simple usage\nimport threadts from './core/threadts';\nexport default threadts;\n"],"mappings":";;;;AAwJA,IAAa,cAAb,cAAiC,MAAM;CACrC,YACE,SACA,MACA,OACA;EACA,MAAM,OAAO;EAHG,KAAA,OAAA;EACA,KAAA,QAAA;EAGhB,KAAK,OAAO;CACd;AACF;AAEA,IAAa,eAAb,cAAkC,YAAY;CAC5C,YAAY,SAAiB;EAC3B,MAAM,6BAA6B,QAAQ,KAAK,SAAS;CAC3D;AACF;AAEA,IAAa,cAAb,cAAiC,YAAY;CAC3C,YAAY,SAAiB,OAAe;EAC1C,MAAM,SAAS,gBAAgB,KAAK;CACtC;AACF;AAEA,IAAa,qBAAb,cAAwC,YAAY;CAClD,YAAY,SAAiB,OAAe;EAC1C,MAAM,SAAS,uBAAuB,KAAK;CAC7C;AACF;;;;;;;ACrHA,SAAgB,iBAA2B;CAEzC,IAAI,OAAO,WAAW,eAAe,OAAO,OAAO,aAAa,aAC9D,OAAO;CAGT,MAAM,MAAM;CAGZ,IACE,OAAO,IAAI,YAAY,eACvB,IAAI,QAAQ,YACZ,IAAI,QAAQ,SAAS,MAErB,OAAO;CAIT,IAAI,OAAO,IAAI,SAAS,aACtB,OAAO;CAIT,IAAI,OAAO,IAAI,QAAQ,aACrB,OAAO;CAGT,OAAO;AACT;;;;AAKA,SAAgB,wBAAiC;CAG/C,QAFiB,eAET,GAAR;EACE,KAAK,WACH,OAAO,OAAO,WAAW;EAC3B,KAAK,QACH,IAAI;GAGF,MAAM,cAAc,WAAI;GACxB,IAAI,aAAa;IACf,YAAY,gBAAgB;IAC5B,OAAO;GACT;GACA,OAAO;EACT,QAAQ;GACN,OAAO;EACT;EACF,KAAK,QACH,OAAO,OAAO,WAAW;EAC3B,KAAK,OACH,OAAO,OAAO,WAAW;EAC3B,SACE,OAAO;CACX;AACF;;;;AAKA,SAAgB,8BAAuC;CAGrD,QAFiB,eAET,GAAR;EACE,KAAK,WACH,OACE,OAAO,gBAAgB,eACvB,OAAO,mBAAmB;EAE9B,KAAK,QACH,OAAO;EACT,KAAK,QACH,OAAO,OAAO,gBAAgB;EAChC,KAAK,OACH,OAAO,OAAO,gBAAgB;EAChC,SACE,OAAO;CACX;AACF;;;;AAKA,SAAgB,wBAAgC;CAG9C,QAFiB,eAET,GAAR;EACE,KAAK,WAEH,OAAO,WAAI,WAAW,uBAAuB;EAE/C,KAAK,QACH,IAAI;GAEF,MAAM,cAAc,WAAI;GACxB,IAAI,aAEF,OADW,YAAY,IAChB,CAAA,CAAG,KAAK,CAAC,CAAC;GAEnB,OAAO;EACT,QAAQ;GACN,OAAO;EACT;EAEF,KAAK,QAEH,OAAO,WAAQ,WAAW,uBAAuB;EAEnD,KAAK,OAEH,OAAO,WAAO,WAAW,uBAAuB;EAElD,SACE,OAAO;CACX;AACF;;;;AAKA,SAAgB,0BAAmC;CACjD,OAAO,OAAO,oBAAoB;AACpC;;;;AAKA,SAAgB,mBAA4B;CAC1C,OAAO,OAAO,cAAc,eAAe,WAAW;AACxD;;;;AAKA,SAAgB,sBAA8B;CAG5C,QAFiB,eAET,GAAR;EACE,KAAK,WACH,OAAO,YAAY,IAAI;EACzB,KAAK,QACH,IAAI;GAEF,MAAM,cAAc,WAAI;GACxB,IAAI,aAAa;IACf,MAAM,EAAE,aAAa,aAAa,YAAY,YAAY;IAC1D,OAAO,SAAS,IAAI;GACtB;GACA,OAAO,KAAK,IAAI;EAClB,QAAQ;GACN,OAAO,KAAK,IAAI;EAClB;EACF,KAAK,QACH,OAAO,YAAY,IAAI;EACzB,KAAK,OACH,OAAO,YAAY,IAAI;EACzB,SACE,OAAO,KAAK,IAAI;CACpB;AACF;;;;AAcA,SAAgB,gBAAmC;CAGjD,QAFiB,eAET,GAAR;EACE,KAAK;GACH,IAAI,OAAO,gBAAgB,eAAe,YAAY,aAAa;IAEjE,MAAM,MAAM,WAAI,aAAa;IAC7B,IAAI,KACF,OAAO;KACL,MAAM,IAAI;KACV,OAAO,IAAI;KACX,WAAW,IAAI,kBAAkB,IAAI;IACvC;GAEJ;GACA,OAAO;EACT,KAAK,QACH,IAAI;GAEF,MAAM,cAAc,WAAI;GACxB,IAAI,aAAa,aAAa;IAC5B,MAAM,MAAM,YAAY,YAAY;IACpC,OAAO;KACL,MAAM,IAAI;KACV,OAAO,IAAI;KACX,WAAW,IAAI,YAAY,IAAI;IACjC;GACF;GACA,OAAO;EACT,QAAQ;GACN,OAAO;EACT;EACF,KAAK;GACH,IAAI,OAAO,gBAAgB,eAAe,YAAY,aAAa;IAEjE,MAAM,MAAM,WAAI,aAAa;IAC7B,IAAI,KACF,OAAO;KACL,MAAM,IAAI;KACV,OAAO,IAAI;KACX,WAAW,IAAI,kBAAkB,IAAI;IACvC;GAEJ;GACA,OAAO;EACT,SACE,OAAO;CACX;AACF;AAGA,IAAa,gBAAb,MAA2B,CAS3B;;AAR0B,eAAA,iBAAA;AACO,eAAA,wBAAA;AACM,eAAA,8BAAA;AACN,eAAA,wBAAA;AACE,eAAA,0BAAA;AACP,eAAA,mBAAA;AACG,eAAA,sBAAA;AACN,eAAA,gBAAA;;;;;;;;;;;;;;;;;;;;;;;;;;ACvQzB,SAAgB,iBAAiB,IAAa,YAAY,MAAY;CACpE,IAAI,OAAO,OAAO,YAEhB,MAAM,IAAI,YACR,GAAG,UAAU,gCAFM,OAAO,OAAO,SAAS,OAAO,MAGjD,kBACF;AAEJ;;;;;;;;;;;;;;AAeA,SAAgB,cAAc,KAAc,YAAY,SAAe;CACrE,IAAI,CAAC,MAAM,QAAQ,GAAG,GAEpB,MAAM,IAAI,YACR,GAAG,UAAU,8BAFM,QAAQ,OAAO,SAAS,OAAO,OAGlD,kBACF;AAEJ;;;;;;;;;;;;;AAcA,SAAgB,sBACd,KACA,YAAY,SACN;CACN,IAAI,IAAI,WAAW,GACjB,MAAM,IAAI,YAAY,GAAG,UAAU,mBAAmB,kBAAkB;AAE5E;;;;;;;;;;;;;;AAeA,SAAgB,uBACd,OACA,YAAY,SACN;CACN,IAAI,OAAO,UAAU,YAAY,MAAM,KAAK,GAC1C,MAAM,IAAI,YACR,GAAG,UAAU,8BAA8B,OAAO,SAClD,kBACF;CAGF,IAAI,SAAS,GACX,MAAM,IAAI,YACR,GAAG,UAAU,8BAA8B,SAC3C,kBACF;AAEJ;;;;;;;;;;;;;;AAeA,SAAgB,0BACd,OACA,YAAY,SACN;CACN,IAAI,OAAO,UAAU,YAAY,MAAM,KAAK,GAC1C,MAAM,IAAI,YACR,GAAG,UAAU,8BAA8B,OAAO,SAClD,kBACF;CAGF,IAAI,QAAQ,GACV,MAAM,IAAI,YACR,GAAG,UAAU,kCAAkC,SAC/C,kBACF;AAEJ;;;;;;;;;;;;;;;;AAiBA,SAAgB,cACd,OACA,KACA,KACA,YAAY,SACN;CACN,IAAI,QAAQ,OAAO,QAAQ,KACzB,MAAM,IAAI,YACR,GAAG,UAAU,mBAAmB,IAAI,OAAO,IAAI,aAAa,SAC5D,kBACF;AAEJ;;;;;;;;;;;;;;;AAgBA,SAAgB,aACd,OACA,eACA,YAAY,SACN;CACN,IAAI,CAAC,cAAc,SAAS,KAAK,GAE/B,MAAM,IAAI,YACR,GAAG,UAAU,mBAFC,cAAc,KAAK,MAAM,IAAI,OAAO,CAAC,EAAE,EAAE,CAAC,CAAC,KAAK,IAE9B,EAAQ,eAAe,OAAO,KAAK,EAAE,IACrE,kBACF;AAEJ;;;;;AAMA,SAAS,yBAAyB,OAAgB,MAA6B;CAE7E,IAAI,UAAU,QAAQ,UAAU,KAAA,GAC9B;CAGF,MAAM,YAAY,OAAO;CAGzB,IAAI,cAAc,YAChB,MAAM,IAAI,mBACR,uFACF;CAGF,IAAI,cAAc,UAChB,MAAM,IAAI,mBACR,oDACF;CAGF,IAAI,cAAc,UAChB,MAAM,IAAI,mBACR,uEACF;CAIF,IAAI,cAAc,UAChB;CAIF,IAAI,KAAK,IAAI,KAAe,GAC1B,MAAM,IAAI,mBACR,2FACF;CAGF,KAAK,IAAI,KAAe;CAGxB,IAAI,MAAM,QAAQ,KAAK,GAAG;EACxB,KAAK,IAAI,IAAI,GAAG,IAAI,MAAM,QAAQ,KAChC,IAAI;GACF,yBAAyB,MAAM,IAAI,IAAI;EACzC,SAAS,OAAO;GACd,IAAI,iBAAiB,oBACnB,MAAM,IAAI,mBAAmB,kBAAkB,EAAE,IAAI,MAAM,SAAS;GAEtE,MAAM;EACR;EAEF;CACF;CAGA,IACE,iBAAiB,eACjB,YAAY,OAAO,KAAK,KACxB,iBAAiB,QACjB,iBAAiB,UACjB,iBAAiB,OACjB,iBAAiB,KAEjB;CAIF,KAAK,MAAM,CAAC,KAAK,QAAQ,OAAO,QAAQ,KAAgC,GACtE,IAAI;EACF,yBAAyB,KAAK,IAAI;CACpC,SAAS,OAAO;EACd,IAAI,iBAAiB,oBACnB,MAAM,IAAI,mBAAmB,gBAAgB,IAAI,KAAK,MAAM,SAAS;EAEvE,MAAM;CACR;AAEJ;;;;;;;;;;;;;;;;;;;;;;;;AAyBA,SAAgB,qBAAqB,OAAsB;CACzD,yBAAyB,uBAAO,IAAI,QAAgB,CAAC;AACvD;;;;;;;;;;;;;AAcA,SAAgB,sBAAsB,SAAwC;CAC5E,IAAI,QAAQ,YAAY,KAAA,GAAW;EACjC,IAAI,OAAO,QAAQ,YAAY,UAC7B,MAAM,IAAI,YACR,sCAAsC,OAAO,QAAQ,WACrD,gBACF;EAEF,IAAI,MAAM,QAAQ,OAAO,GACvB,MAAM,IAAI,YACR,gDACA,gBACF;EAEF,IAAI,QAAQ,WAAW,GACrB,MAAM,IAAI,YACR,sCAAsC,QAAQ,WAC9C,gBACF;CAEJ;CAEA,IAAI,QAAQ,eAAe,KAAA,GAAW;EACpC,IAAI,OAAO,QAAQ,eAAe,UAChC,MAAM,IAAI,YACR,yCAAyC,OAAO,QAAQ,cACxD,gBACF;EAEF,IAAI,MAAM,QAAQ,UAAU,GAC1B,MAAM,IAAI,YACR,mDACA,gBACF;EAEF,IAAI,QAAQ,aAAa,GACvB,MAAM,IAAI,YACR,6CAA6C,QAAQ,cACrD,gBACF;CAEJ;CAEA,IAAI,QAAQ,aAAa,KAAA,GACvB,aACE,QAAQ,UACR;EAAC;EAAO;EAAU;CAAM,GACxB,UACF;CAGF,IAAI,QAAQ,cAAc,KAAA,GAAW;EACnC,IAAI,OAAO,QAAQ,cAAc,UAC/B,MAAM,IAAI,YACR,wCAAwC,OAAO,QAAQ,aACvD,gBACF;EAEF,IAAI,MAAM,QAAQ,SAAS,GACzB,MAAM,IAAI,YACR,kDACA,gBACF;EAEF,IAAI,QAAQ,YAAY,GACtB,MAAM,IAAI,YACR,0CAA0C,QAAQ,aAClD,gBACF;CAEJ;CAEA,IACE,QAAQ,WAAW,KAAA,KACnB,EAAE,QAAQ,kBAAkB,cAE5B,MAAM,IAAI,YACR,0CACA,gBACF;AAEJ;;;;;;;;;;;;;;;;;;AAmBA,SAAgB,aACd,MACA,OAIA;CACA,MAAM,SAAS,UAAU,KAAA,IAAY,iBAAiB,MAAM,MAAM;CAGlE,IAAI,OAAO,SAAS,YAAY,SAAS,MACvC,MAAM,IAAI,YACR,GAAG,OAAO,0CACV,cACF;CAIF,MAAM,UAAU;CAKhB,IAAI,QAFO,QAAQ,MAAM,QAAQ,UAEf,YAChB,MAAM,IAAI,YACR,GAAG,OAAO,kDACV,cACF;AAEJ;;;;;;;;;;;;;;;AAgBA,SAAgB,cAAc,OAAwB;CACpD,cAAc,OAAO,OAAO;CAE5B,KAAK,IAAI,IAAI,GAAG,IAAI,MAAM,QAAQ,KAChC,aAAa,MAAM,IAAI,CAAC;AAE5B;;;;;;;;;;;;;;;AAgBA,SAAgB,cACd,OACA,cACA,WAAW,GACH;CACR,IAAI,OAAO,UAAU,YAAY,MAAM,KAAK,GAC1C,OAAO;CAIT,OAAO,KAAK,IAAI,UADC,KAAK,MAAM,KACF,CAAQ;AACpC;;;;;;;;;;;;;;AAeA,SAAgB,iBAAiB,OAAgB,cAA8B;CAC7E,IAAI,OAAO,UAAU,YAAY,MAAM,KAAK,GAC1C,OAAO;CAIT,OAAO,KAAK,IAAI,GADC,KAAK,MAAM,KACT,CAAQ;AAC7B;;;;;;;;;;;AAYA,IAAa,kBAAb,MAA6B;CAC3B,OAAO,iBAAiB,IAAa,YAAY,MAAY;EAC3D,iBAAiB,IAAI,SAAS;CAChC;CAEA,OAAO,cAAc,KAAc,YAAY,SAAe;EAC5D,cAAc,KAAK,SAAS;CAC9B;CAEA,OAAO,sBAAsB,KAAgB,YAAY,SAAe;EACtE,sBAAsB,KAAK,SAAS;CACtC;CAEA,OAAO,uBAAuB,OAAgB,YAAY,SAAe;EACvE,uBAAuB,OAAO,SAAS;CACzC;CAEA,OAAO,0BAA0B,OAAgB,YAAY,SAAe;EAC1E,0BAA0B,OAAO,SAAS;CAC5C;CAEA,OAAO,cACL,OACA,KACA,KACA,YAAY,SACN;EACN,cAAc,OAAO,KAAK,KAAK,SAAS;CAC1C;CAEA,OAAO,aACL,OACA,eACA,YAAY,SACN;EACN,aAAa,OAAO,eAAe,SAAS;CAC9C;CAEA,OAAO,qBAAqB,OAAsB;EAChD,qBAAqB,KAAK;CAC5B;CAEA,OAAO,sBAAsB,SAAwC;EACnE,sBAAsB,OAAO;CAC/B;CAEA,OAAO,aACL,MACA,OAIA;EACA,aAAa,MAAM,KAAK;CAC1B;CAEA,OAAO,cAAc,OAAwB;EAC3C,cAAc,KAAK;CACrB;CAEA,OAAO,cACL,OACA,cACA,WAAW,GACH;EACR,OAAO,cAAc,OAAO,cAAc,QAAQ;CACpD;CAEA,OAAO,iBAAiB,OAAgB,cAA8B;EACpE,OAAO,iBAAiB,OAAO,YAAY;CAC7C;AACF;;;;;;;;;;ACtkBA,SAAgB,sBAAsB,WAAmC;;;;;;;;;;;;;;;;;CAiBvE,eAAe,QACb,OACA,eACA,YAAY,GACK;EACjB,IAAI,CAAC,MAAM,QACT,OAAO;EAGT,MAAM,aACJ,YAAY,IAAI,KAAK,IAAI,GAAG,MAAM,SAAS,SAAS,IAAI;EAE1D,IAAI,cAAc,MAAM,QACtB,OAAO;EAKT,OADe,MAAM,QAAQ,eAAe,UACrC;CACT;;;;;;;;;;;;;;;;;CAkBA,eAAe,YACb,OACA,eACA,WACiB;EACjB,IAAI,CAAC,MAAM,QACT,OAAO;EAGT,MAAM,aAAa,cAAc,KAAA,IAAY,MAAM,SAAS,IAAI;EAEhE,OADe,MAAM,YAAY,eAAe,UACzC;CACT;;;;;;;;;;;;;;;;CAiBA,eAAe,GAAM,OAAY,OAAuC;EACtE,IAAI,CAAC,MAAM,QACT;EAGF,MAAM,kBAAkB,QAAQ,IAAI,MAAM,SAAS,QAAQ;EAE3D,IAAI,kBAAkB,KAAK,mBAAmB,MAAM,QAClD;EAGF,OAAO,MAAM;CACf;;;;;;;;;;;;;;;;;CAkBA,eAAe,MACb,OACA,OACA,KACc;EACd,OAAO,MAAM,MAAM,OAAO,GAAG;CAC/B;;;;;;;;;;;;;;;;CAiBA,eAAe,OAAU,OAAY,GAAG,OAAkC;EACxE,OAAO,MAAM,OAAO,GAAG,KAAK;CAC9B;;;;;;;;;;;;;;;;;;CAmBA,eAAe,KACb,OACA,OACA,QAAQ,GACR,KACc;EACd,MAAM,SAAS,CAAC,GAAG,KAAK;EACxB,MAAM,YAAY,OAAO,MAAM;EAC/B,MAAM,kBACJ,QAAQ,IAAI,KAAK,IAAI,GAAG,MAAM,SAAS,KAAK,IAAI;EAClD,MAAM,gBACJ,YAAY,IAAI,KAAK,IAAI,GAAG,MAAM,SAAS,SAAS,IAAI;EAE1D,KAAK,IAAI,IAAI,iBAAiB,IAAI,iBAAiB,IAAI,OAAO,QAAQ,KACpE,OAAO,KAAK;EAGd,OAAO;CACT;;;;;;;;;;;;;;;;;CAkBA,eAAe,SACb,OACA,eACA,YAAY,GACM;EAClB,OAAO,MAAM,SAAS,eAAe,SAAS;CAChD;;;;;;;;;;;;;;;;CAiBA,eAAe,KAAQ,OAAY,YAAY,KAAsB;EACnE,OAAO,MAAM,KAAK,SAAS;CAC7B;;;;;;;;;;;;;;;CAgBA,eAAe,QAAW,OAA0B;EAClD,OAAO,CAAC,GAAG,KAAK,CAAC,CAAC,QAAQ;CAC5B;;;;;;;;;;;;;;;;CAiBA,eAAe,KACb,OACA,WACc;EACd,OAAO,CAAC,GAAG,KAAK,CAAC,CAAC,KAAK,SAAS;CAClC;;;;;;;;;;;;;;;;CAiBA,eAAe,MACb,OACA,KACA,OAAO,GACY;EACnB,MAAM,SAAmB,CAAC;EAC1B,IAAI,OAAO,GACT,KAAK,IAAI,IAAI,OAAO,IAAI,KAAK,KAAK,MAChC,OAAO,KAAK,CAAC;OAEV,IAAI,OAAO,GAChB,KAAK,IAAI,IAAI,OAAO,IAAI,KAAK,KAAK,MAChC,OAAO,KAAK,CAAC;EAGjB,OAAO;CACT;;;;;;;;;;;;;;;CAgBA,eAAe,OAAU,OAAU,OAA6B;EAC9D,OAAO,MAAM,KAAK,EAAE,QAAQ,KAAK,IAAI,GAAG,KAAK,EAAE,SAAS,KAAK;CAC/D;;;;;;;;;;;;;CAcA,eAAe,IACb,GAAG,QACkE;EACrE,IAAI,OAAO,WAAW,GACpB,OAAO,CAAC;EAGV,MAAM,YAAY,KAAK,IAAI,GAAG,OAAO,KAAK,QAAQ,IAAI,MAAM,CAAC;EAC7D,MAAM,SAAsB,CAAC;EAE7B,KAAK,IAAI,IAAI,GAAG,IAAI,WAAW,KAC7B,OAAO,KAAK,OAAO,KAAK,QAAQ,IAAI,EAAE,CAAC;EAGzC,OAAO;CACT;;;;;;;;;;;;;;;CAgBA,eAAe,MACb,OACqC;EACrC,IAAI,MAAM,WAAW,GACnB,OAAO,CAAC;EAGV,MAAM,cAAc,MAAM,EAAE,CAAC;EAC7B,MAAM,SAAsB,MAAM,KAAK,EAAE,QAAQ,YAAY,SAAS,CAAC,CAAC;EAExE,KAAK,MAAM,SAAS,OAClB,KAAK,IAAI,IAAI,GAAG,IAAI,aAAa,KAC/B,OAAO,EAAE,CAAC,KAAK,MAAM,EAAE;EAI3B,OAAO;CACT;;;;;;;;;;;;;;;CAgBA,eAAe,OAAU,OAA0B;EACjD,OAAO,CAAC,GAAG,IAAI,IAAI,KAAK,CAAC;CAC3B;;;;;;;;;;;;;;;;;CAkBA,eAAe,SACb,OACA,OACc;EACd,MAAM,uBAAO,IAAI,IAAO;EACxB,MAAM,SAAc,CAAC;EAErB,KAAK,MAAM,QAAQ,OAAO;GACxB,MAAM,MAAM,MAAM,IAAI;GACtB,IAAI,CAAC,KAAK,IAAI,GAAG,GAAG;IAClB,KAAK,IAAI,GAAG;IACZ,OAAO,KAAK,IAAI;GAClB;EACF;EAEA,OAAO;CACT;;;;;;;;;;;;;;;CAgBA,eAAe,KAAQ,OAAY,QAAQ,GAAuB;EAChE,OAAO,MAAM,KAAK,KAAK;CACzB;;;;;;;;;;;;;;;CAgBA,eAAe,MAAS,OAAY,MAA8B;EAChE,IAAI,QAAQ,GACV,OAAO,CAAC;EAGV,MAAM,SAAgB,CAAC;EACvB,KAAK,IAAI,IAAI,GAAG,IAAI,MAAM,QAAQ,KAAK,MACrC,OAAO,KAAK,MAAM,MAAM,GAAG,IAAI,IAAI,CAAC;EAEtC,OAAO;CACT;;;;;;;;;;;;;;;;CAmBA,eAAe,SACb,OACA,WACwB;EACxB,KAAK,IAAI,IAAI,MAAM,SAAS,GAAG,KAAK,GAAG,KACrC,IAAI,UAAU,MAAM,IAAI,GAAG,KAAK,GAC9B,OAAO,MAAM;CAInB;;;;;;;;;;;;;;;;CAiBA,eAAe,cACb,OACA,WACiB;EACjB,KAAK,IAAI,IAAI,MAAM,SAAS,GAAG,KAAK,GAAG,KACrC,IAAI,UAAU,MAAM,IAAI,GAAG,KAAK,GAC9B,OAAO;EAGX,OAAO;CACT;;;;;;;;;;;;;;;;CAiBA,eAAe,SACb,OACA,WACc;EACd,OAAO,CAAC,GAAG,KAAK,CAAC,CAAC,KAAK,SAAS;CAClC;;;;;;;;;;;;;;;CAgBA,eAAe,WAAc,OAA0B;EACrD,OAAO,CAAC,GAAG,KAAK,CAAC,CAAC,QAAQ;CAC5B;;;;;;;;;;;;;;;;;CAkBA,eAAe,YACb,OACA,OACA,OACc;EACd,MAAM,kBAAkB,QAAQ,IAAI,MAAM,SAAS,QAAQ;EAE3D,IAAI,kBAAkB,KAAK,mBAAmB,MAAM,QAClD,MAAM,IAAI,WAAW,kBAAkB,OAAO;EAGhD,MAAM,SAAS,CAAC,GAAG,KAAK;EACxB,OAAO,mBAAmB;EAC1B,OAAO;CACT;;;;;;;;;;;;;;;;;;CAmBA,eAAe,UACb,OACA,OACA,aACA,GAAG,OACW;EACd,MAAM,SAAS,CAAC,GAAG,KAAK;EACxB,IAAI,gBAAgB,KAAA,GAClB,OAAO,OAAO,KAAK;OAEnB,OAAO,OAAO,OAAO,aAAa,GAAG,KAAK;EAE5C,OAAO;CACT;;;;;;;;;;;;;;;;;;;;CAqBA,eAAe,cACb,OACA,OACkC;EAClC,MAAM,SAAkC,CAAC;EAEzC,KAAK,IAAI,IAAI,GAAG,IAAI,MAAM,QAAQ,KAAK;GACrC,MAAM,MAAM,MAAM,MAAM,IAAI,CAAC;GAC7B,IAAI,CAAC,OAAO,MACV,OAAO,OAAO,CAAC;GAEjB,OAAO,IAAI,CAAE,KAAK,MAAM,EAAE;EAC5B;EAEA,OAAO;CACT;CAEA,OAAO;EACL;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EAEA;EACA;EACA;EACA;EACA;EACA;EACA;CACF;AACF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AC9rBA,SAAgB,mBAAsB,OAAiB;CACrD,KAAK,IAAI,IAAI,MAAM,SAAS,GAAG,IAAI,GAAG,KAAK;EACzC,MAAM,IAAI,KAAK,MAAM,KAAK,OAAO,KAAK,IAAI,EAAE;EAC5C,CAAC,MAAM,IAAI,MAAM,MAAM,CAAC,MAAM,IAAI,MAAM,EAAE;CAC5C;CACA,OAAO;AACT;;;;;;;;;;;;;;;;;;;AAoBA,SAAgB,YAAe,OAAiB;CAC9C,OAAO,mBAAmB,CAAC,GAAG,KAAK,CAAC;AACtC;;;;;;;;;;;;;;;;;;;AAoBA,SAAgB,aAAgB,OAAY,OAAoB;CAC9D,MAAM,aAAa,KAAK,IAAI,KAAK,IAAI,GAAG,KAAK,GAAG,MAAM,MAAM;CAC5D,IAAI,eAAe,GACjB,OAAO,CAAC;CAEV,OAAO,YAAY,KAAK,CAAC,CAAC,MAAM,GAAG,UAAU;AAC/C;;;;;;;;;;;;;;;;AAiBA,SAAgB,WAAc,OAAY,MAAqB;CAC7D,IAAI,QAAQ,GACV,OAAO,CAAC;CAEV,MAAM,SAAgB,CAAC;CACvB,KAAK,IAAI,IAAI,GAAG,IAAI,MAAM,QAAQ,KAAK,MACrC,OAAO,KAAK,MAAM,MAAM,GAAG,IAAI,IAAI,CAAC;CAEtC,OAAO;AACT;;;;;;;;;;;;;;;;;;;;AAqBA,SAAgB,cAAiB,OAAY,MAAc,OAAO,GAAU;CAC1E,IAAI,QAAQ,KAAK,QAAQ,KAAK,MAAM,SAAS,MAC3C,OAAO,QAAQ,KAAK,QAAQ,IAAI,CAAC,IAAI,CAAC;CAExC,MAAM,SAAgB,CAAC;CACvB,KAAK,IAAI,IAAI,GAAG,KAAK,MAAM,SAAS,MAAM,KAAK,MAC7C,OAAO,KAAK,MAAM,MAAM,GAAG,IAAI,IAAI,CAAC;CAEtC,OAAO;AACT;;;;;;;;;;;;;;;;AAiBA,SAAgB,iBAAoB,QAAa,QAAkB;CACjE,MAAM,SAAc,CAAC;CACrB,MAAM,SAAS,KAAK,IAAI,OAAO,QAAQ,OAAO,MAAM;CACpD,KAAK,IAAI,IAAI,GAAG,IAAI,QAAQ,KAAK;EAC/B,IAAI,IAAI,OAAO,QAAQ,OAAO,KAAK,OAAO,EAAE;EAC5C,IAAI,IAAI,OAAO,QAAQ,OAAO,KAAK,OAAO,EAAE;CAC9C;CACA,OAAO;AACT;;;;;;;;;;;;;;;;;;;AAoBA,SAAgB,YAAe,OAAY,WAAwB;CACjE,IAAI,MAAM,WAAW,KAAK,cAAc,GACtC,OAAO,CAAC,GAAG,KAAK;CAElB,MAAM,KAAM,YAAY,MAAM,SAAU,MAAM,UAAU,MAAM;CAC9D,OAAO,CAAC,GAAG,MAAM,MAAM,CAAC,CAAC,GAAG,GAAG,MAAM,MAAM,GAAG,CAAC,CAAC,CAAC;AACnD;;;;;;;;;;;;;;;;;;;;;AAsBA,SAAgB,SAAe,OAAY,OAA4B;CACrE,MAAM,uBAAO,IAAI,IAAO;CACxB,MAAM,SAAc,CAAC;CACrB,KAAK,MAAM,QAAQ,OAAO;EACxB,MAAM,MAAM,MAAM,IAAI;EACtB,IAAI,CAAC,KAAK,IAAI,GAAG,GAAG;GAClB,KAAK,IAAI,GAAG;GACZ,OAAO,KAAK,IAAI;EAClB;CACF;CACA,OAAO;AACT;;;;;;;;;AAUA,SAAgB,aAAgB,OAAY,OAAmC;CAC7E,MAAM,uBAAO,IAAI,IAAY;CAC7B,MAAM,SAAc,CAAC;CACrB,KAAK,MAAM,QAAQ,OAAO;EACxB,MAAM,MAAM,KAAK,UAAU,QAAQ,MAAM,IAAI,IAAI,IAAI;EACrD,IAAI,CAAC,KAAK,IAAI,GAAG,GAAG;GAClB,KAAK,IAAI,GAAG;GACZ,OAAO,KAAK,IAAI;EAClB;CACF;CACA,OAAO;AACT;;;;;;AC3MA,IAAa,sBAAsB;CACjC;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;AACF;;;;AAOA,SAAgB,oBAAoB,MAAuB;CACzD,OAAO,oBAAoB,SAAS,IAA6B;AACnE;;;;;;;;;;AAWA,eAAsB,6BACpB,MACA,IACA,UACoB;CACpB,QAAQ,GAAG,MAAX;EACE,KAAK,OACH,OAAO,SAAS,IAAI,MAAM,GAAG,IAAK,GAAG,OAAqB;EAE5D,KAAK,UACH,OAAO,SAAS,OAAO,MAAM,GAAG,IAAK,GAAG,OAAqB;EAE/D,KAAK,WACH,OAAO,SAAS,QAAQ,MAAM,GAAG,IAAK,GAAG,OAAqB;EAEhE,KAAK,QACH,OAAO,KAAK,MAAM,GAAG,GAAG,SAAS,CAAC;EAEpC,KAAK,QACH,OAAO,KAAK,MAAM,GAAG,SAAS,CAAC;EAEjC,KAAK,SAEH,OAAO,WAAW,MADA,GAAG,SAAS,CACG;EAGnC,KAAK;EACL,KAAK;GAGH,IAAI,GAAG,IACL,KAAK,MAAM,QAAQ,MACjB,GAAG,GAAG,IAAI;GAGd,OAAO;EAGT,KAAK,UAGH,OAAO,cAAc,MAFF,GAAG,SAAS,GAClB,GAAG,QAAQ,CACmB;EAG7C,KAAK,UAEH,OAAO,aACL,MACA,GAAG,EACL;EAGF,KAAK;GAGH,IAAI,GAAG,IACL,OAAO,SAAS,MAAM,GAAG,EAAgC;GAG3D,OAAO,CAAC,GAAG,IAAI,IAAI,IAAI,CAAC;EAG1B,KAAK,WACH,OAAO,CAAC,GAAG,IAAI,CAAC,CAAC,QAAQ;EAE3B,KAAK,QACH,OAAO,CAAC,GAAG,IAAI,CAAC,CAAC,KACf,GAAG,EACL;EAEF,KAAK,OAAO;GAEV,MAAM,QAAQ,GAAG;GACjB,IAAI,CAAC,MAAM,QAAQ,KAAK,GAAG,OAAO;GAClC,MAAM,SAAsB,CAAC;GAC7B,MAAM,SAAS,KAAK,IAAI,KAAK,QAAQ,MAAM,MAAM;GACjD,KAAK,IAAI,IAAI,GAAG,IAAI,QAAQ,KAC1B,OAAO,KAAK,CAAC,KAAK,IAAI,MAAM,EAAE,CAAC;GAEjC,OAAO;EACT;EAEA,KAAK,WAAW;GAEd,MAAM,QAAQ,GAAG;GACjB,IAAI,CAAC,MAAM,QAAQ,KAAK,KAAK,CAAC,GAAG,IAAI,OAAO;GAC5C,MAAM,aAAwB,CAAC;GAC/B,MAAM,SAAS,KAAK,IAAI,KAAK,QAAQ,MAAM,MAAM;GACjD,KAAK,IAAI,IAAI,GAAG,IAAI,QAAQ,KAC1B,WAAW,KAAK,GAAG,GAAG,KAAK,IAAI,MAAM,IAAI,CAAC,CAAC;GAE7C,OAAO;EACT;EAEA,KAAK,cAAc;GAEjB,MAAM,QAAQ,GAAG;GACjB,IAAI,CAAC,MAAM,QAAQ,KAAK,GAAG,OAAO;GAClC,OAAO,iBAAiB,MAAM,KAAK;EACrC;EAEA,KAAK,WAEH,OAAO,KAAK,QAAQ,SAAS;GAC3B,IAAI,GAAG,IACL,OAAO,GAAG,GAAG,IAAI;GAEnB,OAAO,QAAQ;EACjB,CAAC;EAGH,KAAK,WAAW;GAEd,MAAM,QAAQ,GAAG,SAAS;GAC1B,OAAO,KAAK,KAAK,KAAK;EACxB;EAEA,KAAK,WAEH,OAAO,YAAY,IAAI;EAGzB,KAAK,UAEH,OAAO,aAAa,MAAM,GAAG,SAAS,CAAC;EAGzC,KAAK,aAAa;GAEhB,IAAI,CAAC,GAAG,IAAI,OAAO;GACnB,IAAI,YAAY;GAChB,KAAK,IAAI,IAAI,GAAG,IAAI,KAAK,QAAQ,KAAK;IACpC,IAAI,CAAC,GAAG,GAAG,KAAK,IAAI,GAAG,IAAI,GAAG;KAC5B,YAAY;KACZ;IACF;IACA,IAAI,MAAM,KAAK,SAAS,GACtB,OAAO,CAAC;GAEZ;GACA,OAAO,KAAK,MAAM,SAAS;EAC7B;EAEA,KAAK,aAAa;GAEhB,IAAI,CAAC,GAAG,IAAI,OAAO;GACnB,MAAM,SAAoB,CAAC;GAC3B,KAAK,IAAI,IAAI,GAAG,IAAI,KAAK,QAAQ,KAC/B,IAAI,GAAG,GAAG,KAAK,IAAI,GAAG,IAAI,GACxB,OAAO,KAAK,KAAK,EAAE;QAEnB;GAGJ,OAAO;EACT;EAEA,KAAK,SAAS;GAEZ,MAAM,QAAQ,GAAG,SAAS;GAC1B,MAAM,MAAM,GAAG;GACf,OAAO,KAAK,MAAM,OAAO,GAAG;EAC9B;EAEA,KAAK,UAAU;GAEb,MAAM,QAAQ,GAAG;GACjB,IAAI,CAAC,MAAM,QAAQ,KAAK,GAAG,OAAO;GAClC,OAAO,CAAC,GAAG,MAAM,GAAG,KAAK;EAC3B;EAEA,KAAK,UAEH,OAAO,YAAY,MAAM,GAAG,SAAS,CAAC;EAGxC,KAAK,UAEH,OAAO,KAAK,OAAO,OAAO;EAG5B,KAAK,SAEH,OAAO,KAAK,QAAQ,SAAS,CAAC,IAAI;EAGpC,SACE,OAAO;CACX;AACF;;;;;;;;;;AAWA,eAAsB,yBACpB,MACA,IACA,UACY;CACZ,QAAQ,GAAG,MAAX;EACE,KAAK,UACH,OAAO,SAAS,OACd,MACA,GAAG,IACH,GAAG,cACH,GAAG,OACL;EAEF,KAAK;GACH,MAAM,SAAS,QAAQ,MAAM,GAAG,IAAK,GAAG,OAAqB;GAC7D;EAEF,KAAK,QACH,OAAO,SAAS,KACd,MACA,GAAG,IACH,GAAG,OACL;EAEF,KAAK,aACH,OAAO,SAAS,UACd,MACA,GAAG,IACH,GAAG,OACL;EAEF,KAAK;GAEH,IAAI,CAAC,GAAG,IAAI,OAAO,KAAA;GACnB,KAAK,IAAI,IAAI,KAAK,SAAS,GAAG,KAAK,GAAG,KACpC,IAAI,GAAG,GAAG,KAAK,IAAI,GAAG,IAAI,GACxB,OAAO,KAAK;GAGhB;EAGF,KAAK;GAEH,IAAI,CAAC,GAAG,IAAI,OAAO;GACnB,KAAK,IAAI,IAAI,KAAK,SAAS,GAAG,KAAK,GAAG,KACpC,IAAI,GAAG,GAAG,KAAK,IAAI,GAAG,IAAI,GACxB,OAAO;GAGX,OAAO;EAGT,KAAK,QACH,OAAO,SAAS,KACd,MACA,GAAG,IACH,GAAG,OACL;EAEF,KAAK,SACH,OAAO,SAAS,MACd,MACA,GAAG,IACH,GAAG,OACL;EAEF,KAAK,SACH,OAAO,SAAS,MACd,MACA,GAAG,IACH,GAAG,OACL;EAEF,KAAK,WACH,OAAO,SAAS,QACd,MACA,GAAG,IACH,GAAG,OACL;EAEF,KAAK,aACH,OAAO,SAAS,UACd,MACA,GAAG,IACH,GAAG,OACL;EAEF,KAAK,SACH,OAAQ,KAAK,SAAS,IAAI,KAAK,KAAK,KAAA;EAEtC,KAAK,QACH,OAAQ,KAAK,SAAS,IAAI,KAAK,KAAK,SAAS,KAAK,KAAA;EAEpD,KAAK,WACH,OAAQ,KAAK,WAAW;EAE1B,KAAK,OACH,OAAO,KAAK,QACT,KAAa,QAAQ,OAAO,OAAO,QAAQ,WAAW,MAAM,IAC7D,CACF;EAEF,KAAK;GACH,IAAI,KAAK,WAAW,GAAG,OAAO;GAK9B,OAJiB,KAAK,QACnB,KAAa,QAAQ,OAAO,OAAO,QAAQ,WAAW,MAAM,IAC7D,CAEM,IAAW,KAAK;EAG1B,KAAK,OAAO;GACV,IAAI,KAAK,WAAW,GAAG,OAAO,KAAA;GAC9B,MAAM,eAAe,GAAG;GAExB,OAAO,CAAC,GAAG,IAAI,CAAC,CAAC,KACf,kBACI,GAAG,MAAM;IACT,IAAI,MAAM,GAAG,OAAO;IACpB,OAAQ,IAAgB,IAAe,KAAK;GAC9C,EACJ,CAAC,CAAC;EACJ;EAEA,KAAK,OAAO;GACV,IAAI,KAAK,WAAW,GAAG,OAAO,KAAA;GAC9B,MAAM,eAAe,GAAG;GAExB,OAAO,CAAC,GAAG,IAAI,CAAC,CAAC,KACf,kBACI,GAAG,MAAM;IACT,IAAI,MAAM,GAAG,OAAO;IACpB,OAAQ,IAAgB,IAAe,KAAK;GAC9C,EACJ,CAAC,CAAC;EACJ;EAEA,KAAK,QAAQ;GACX,MAAM,YAAa,GAAG,gBAA2B;GACjD,OAAO,KAAK,KAAK,SAAS;EAC5B;EAEA,KAAK,YAAY;GACf,MAAM,cAAc,GAAG;GACvB,OAAO,KAAK,SAAS,WAAW;EAClC;EAEA,SACE,OAAO;CACX;AACF;;;;;;;;;;;;;;;;;;AC5YA,IAAa,WAAb,MAAyB;CAGvB,YACE,OACA,UACA;EAFU,KAAA,QAAA;EACA,KAAA,WAAA;EAJgC,KAAA,aAAA,CAAC;CAK1C;;;;CAKH,IAAO,IAA0B,SAAmC;EAClE,KAAK,WAAW,KAAK;GAAE,MAAM;GAAO;GAAI;EAAQ,CAAC;EACjD,OAAO;CACT;;;;CAKA,OAAO,IAA0B,SAAmC;EAClE,KAAK,WAAW,KAAK;GAAE,MAAM;GAAU;GAAI;EAAQ,CAAC;EACpD,OAAO;CACT;;;;CAKA,QAAW,IAA0B,SAAmC;EACtE,KAAK,WAAW,KAAK;GAAE,MAAM;GAAW;GAAI;EAAQ,CAAC;EACrD,OAAO;CACT;;;;;;;;;;;;;;;;CAiBA,KAAK,OAA4B;EAC/B,KAAK,WAAW,KAAK;GACnB,MAAM;GACN,OAAO,KAAK,IAAI,GAAG,KAAK,MAAM,KAAK,CAAC;EACtC,CAAC;EACD,OAAO;CACT;;;;;;;;;;;;;;;;CAiBA,KAAK,OAA4B;EAC/B,KAAK,WAAW,KAAK;GACnB,MAAM;GACN,OAAO,KAAK,IAAI,GAAG,KAAK,MAAM,KAAK,CAAC;EACtC,CAAC;EACD,OAAO;CACT;;;;;;;;;;;;;;;;CAiBA,MAAM,MAA6B;EACjC,KAAK,WAAW,KAAK;GACnB,MAAM;GACN,OAAO,KAAK,IAAI,GAAG,KAAK,MAAM,IAAI,CAAC;EACrC,CAAC;EACD,OAAO;CACT;;;;;;;;;;;;;;;;;;CAmBA,IAAI,IAAuC;EACzC,KAAK,WAAW,KAAK;GAAE,MAAM;GAAO;EAAG,CAAC;EACxC,OAAO;CACT;;;;;;;;;;;;;;;;;CAkBA,OAAO,MAAc,OAAe,GAAkB;EACpD,KAAK,WAAW,KAAK;GACnB,MAAM;GACN,OAAO,KAAK,IAAI,GAAG,KAAK,MAAM,IAAI,CAAC;GACnC,MAAM,KAAK,IAAI,GAAG,KAAK,MAAM,IAAI,CAAC;EACpC,CAAC;EACD,OAAO;CACT;;;;;;;;;;;;;;;;CAiBA,OAAO,OAA2C;EAChD,KAAK,WAAW,KAAK;GAAE,MAAM;GAAU,IAAI;EAAM,CAAC;EAClD,OAAO;CACT;;;;;;;;CASA,SAAS,OAA2C;EAClD,KAAK,WAAW,KAAK;GAAE,MAAM;GAAY,IAAI;EAAM,CAAC;EACpD,OAAO;CACT;;;;;;;;;;;;;;CAeA,UAAuB;EACrB,KAAK,WAAW,KAAK,EAAE,MAAM,UAAU,CAAC;EACxC,OAAO;CACT;;;;;;;;;;;;;;;CAgBA,KAAK,WAA+C;EAClD,KAAK,WAAW,KAAK;GAAE,MAAM;GAAQ,IAAI;EAAU,CAAC;EACpD,OAAO;CACT;;;;;;;;;;;;;;;CAgBA,IAAO,OAA8B;EACnC,KAAK,WAAW,KAAK;GAAE,MAAM;GAAO,cAAc;EAAM,CAAC;EACzD,OAAO;CACT;;;;;;;;;;;;;;;;CAiBA,QAAc,OAAY,IAAuC;EAC/D,KAAK,WAAW,KAAK;GAAE,MAAM;GAAW,cAAc;GAAO;EAAG,CAAC;EACjE,OAAO;CACT;;;;;;;;;;;;;;;CAgBA,WAAW,OAAyB;EAClC,KAAK,WAAW,KAAK;GAAE,MAAM;GAAc,cAAc;EAAM,CAAC;EAChE,OAAO;CACT;;;;;;;;;;;;;;;CAgBA,QAAQ,WAA4D;EAClE,KAAK,WAAW,KAAK;GAAE,MAAM;GAAW,IAAI;EAAU,CAAC;EACvD,OAAO;CACT;;;;;;;;;;;;;;;CAgBA,QAAQ,QAAgB,GAAsB;EAC5C,KAAK,WAAW,KAAK;GAAE,MAAM;GAAW,OAAO;EAAM,CAAC;EACtD,OAAO;CACT;;;;;;CAOA,UAAuB;EACrB,KAAK,WAAW,KAAK,EAAE,MAAM,UAAU,CAAC;EACxC,OAAO;CACT;;;;;;;CAQA,OAAO,OAA4B;EACjC,KAAK,WAAW,KAAK;GAAE,MAAM;GAAU,OAAO,KAAK,IAAI,GAAG,KAAK;EAAE,CAAC;EAClE,OAAO;CACT;;;;;;;;;;;;;;;CAgBA,UAAU,WAA8C;EACtD,KAAK,WAAW,KAAK;GAAE,MAAM;GAAa,IAAI;EAAU,CAAC;EACzD,OAAO;CACT;;;;;;;;;;;;;;;CAgBA,UAAU,WAA8C;EACtD,KAAK,WAAW,KAAK;GAAE,MAAM;GAAa,IAAI;EAAU,CAAC;EACzD,OAAO;CACT;;;;;;;;;;;;;;;;CAiBA,UAAU,OAAgB,KAA2B;EACnD,KAAK,WAAW,KAAK;GACnB,MAAM;GACN,OAAO;GACP,MAAM;EACR,CAAC;EACD,OAAO;CACT;;;;;;;;;;;;;;;CAgBA,WAAW,OAAyB;EAClC,KAAK,WAAW,KAAK;GACnB,MAAM;GACN,cAAc;EAChB,CAAC;EACD,OAAO;CACT;;;;;;;;;;;;;;;;CAiBA,OAAO,GAAwB;EAC7B,KAAK,WAAW,KAAK;GACnB,MAAM;GACN,OAAO;EACT,CAAC;EACD,OAAO;CACT;;;;;;;;;;;;;;;CAgBA,SAAsB;EACpB,KAAK,WAAW,KAAK,EAAE,MAAM,SAAS,CAAC;EACvC,OAAO;CACT;;;;;;;;;;;;;;CAeA,QAAqB;EACnB,KAAK,WAAW,KAAK,EAAE,MAAM,QAAQ,CAAC;EACtC,OAAO;CACT;;;;;;;;CASA,KAAK,IAAuC;EAC1C,KAAK,WAAW,KAAK;GAAE,MAAM;GAAQ;EAAG,CAAC;EACzC,OAAO;CACT;;;;CAKA,OACE,IACA,cACA,SACqB;EACrB,KAAK,WAAW,KAAK;GAAE,MAAM;GAAU;GAAI;GAAc;EAAQ,CAAC;EAClE,OAAO,IAAI,iBAAoB,KAAK,OAAO,KAAK,YAAY,KAAK,QAAQ;CAC3E;;;;CAKA,QACE,IACA,SACwB;EACxB,KAAK,WAAW,KAAK;GAAE,MAAM;GAAW;GAAI;EAAQ,CAAC;EACrD,OAAO,IAAI,iBACT,KAAK,OACL,KAAK,YACL,KAAK,QACP;CACF;;;;CAKA,KACE,IACA,SACiC;EACjC,KAAK,WAAW,KAAK;GAAE,MAAM;GAAQ;GAAI;EAAQ,CAAC;EAClD,OAAO,IAAI,iBACT,KAAK,OACL,KAAK,YACL,KAAK,QACP;CACF;;;;CAKA,UACE,IACA,SAC0B;EAC1B,KAAK,WAAW,KAAK;GAAE,MAAM;GAAa;GAAI;EAAQ,CAAC;EACvD,OAAO,IAAI,iBACT,KAAK,OACL,KAAK,YACL,KAAK,QACP;CACF;;;;;;;;;;;;;;;;;CAkBA,SACE,IACA,SACiC;EACjC,KAAK,WAAW,KAAK;GAAE,MAAM;GAAY;GAAI;EAAQ,CAAC;EACtD,OAAO,IAAI,iBACT,KAAK,OACL,KAAK,YACL,KAAK,QACP;CACF;;;;;;;;;;;;;;;;;CAkBA,cACE,IACA,SAC0B;EAC1B,KAAK,WAAW,KAAK;GAAE,MAAM;GAAiB;GAAI;EAAQ,CAAC;EAC3D,OAAO,IAAI,iBACT,KAAK,OACL,KAAK,YACL,KAAK,QACP;CACF;;;;CAKA,KACE,IACA,SAC2B;EAC3B,KAAK,WAAW,KAAK;GAAE,MAAM;GAAQ;GAAI;EAAQ,CAAC;EAClD,OAAO,IAAI,iBACT,KAAK,OACL,KAAK,YACL,KAAK,QACP;CACF;;;;CAKA,MACE,IACA,SAC2B;EAC3B,KAAK,WAAW,KAAK;GAAE,MAAM;GAAS;GAAI;EAAQ,CAAC;EACnD,OAAO,IAAI,iBACT,KAAK,OACL,KAAK,YACL,KAAK,QACP;CACF;;;;;CAMA,MACE,IACA,SAC0B;EAC1B,MAAM,UAAU,aAAa;EAC7B,KAAK,WAAW,KAAK;GAAE,MAAM;GAAS,IAAI;GAAS;EAAQ,CAAC;EAC5D,OAAO,IAAI,iBACT,KAAK,OACL,KAAK,YACL,KAAK,QACP;CACF;;;;;;;;;;;;;;;CAgBA,QACE,OACA,SAC+B;EAC/B,KAAK,WAAW,KAAK;GAAE,MAAM;GAAW,IAAI;GAAO;EAAQ,CAAC;EAC5D,OAAO,IAAI,iBACT,KAAK,OACL,KAAK,YACL,KAAK,QACP;CACF;;;;;;;;;;;;;;;CAgBA,UACE,WACA,SAC8B;EAC9B,KAAK,WAAW,KAAK;GAAE,MAAM;GAAa,IAAI;GAAW;EAAQ,CAAC;EAClE,OAAO,IAAI,iBACT,KAAK,OACL,KAAK,YACL,KAAK,QACP;CACF;;;;;;CAOA,QAAyC;EACvC,KAAK,WAAW,KAAK,EAAE,MAAM,QAAQ,CAAC;EACtC,OAAO,IAAI,iBACT,KAAK,OACL,KAAK,YACL,KAAK,QACP;CACF;;;;;;CAOA,OAAwC;EACtC,KAAK,WAAW,KAAK,EAAE,MAAM,OAAO,CAAC;EACrC,OAAO,IAAI,iBACT,KAAK,OACL,KAAK,YACL,KAAK,QACP;CACF;;;;;;CAOA,UAAqC;EACnC,KAAK,WAAW,KAAK,EAAE,MAAM,UAAU,CAAC;EACxC,OAAO,IAAI,iBACT,KAAK,OACL,KAAK,YACL,KAAK,QACP;CACF;;;;;;CAOA,MAAgC;EAC9B,KAAK,WAAW,KAAK,EAAE,MAAM,MAAM,CAAC;EACpC,OAAO,IAAI,iBACT,KAAK,OACL,KAAK,YACL,KAAK,QACP;CACF;;;;;;CAOA,UAAoC;EAClC,KAAK,WAAW,KAAK,EAAE,MAAM,UAAU,CAAC;EACxC,OAAO,IAAI,iBACT,KAAK,OACL,KAAK,YACL,KAAK,QACP;CACF;;;;;;;CAQA,IAAI,WAAmE;EACrE,KAAK,WAAW,KAAK;GAAE,MAAM;GAAO,IAAI;EAAU,CAAC;EACnD,OAAO,IAAI,iBACT,KAAK,OACL,KAAK,YACL,KAAK,QACP;CACF;;;;;;;CAQA,IAAI,WAAmE;EACrE,KAAK,WAAW,KAAK;GAAE,MAAM;GAAO,IAAI;EAAU,CAAC;EACnD,OAAO,IAAI,iBACT,KAAK,OACL,KAAK,YACL,KAAK,QACP;CACF;;;;;;;;;;;;;;CAeA,KAAK,YAAY,KAA+B;EAC9C,KAAK,WAAW,KAAK;GAAE,MAAM;GAAQ,cAAc;EAAU,CAAC;EAC9D,OAAO,IAAI,iBACT,KAAK,OACL,KAAK,YACL,KAAK,QACP;CACF;;;;;;;;;;;;;;CAeA,SAAS,eAA6C;EACpD,KAAK,WAAW,KAAK;GAAE,MAAM;GAAY,cAAc;EAAc,CAAC;EACtE,OAAO,IAAI,iBACT,KAAK,OACL,KAAK,YACL,KAAK,QACP;CACF;;;;CAKA,MAAM,UAAwB;EAC5B,IAAI,SAAoB,KAAK;EAE7B,KAAK,MAAM,MAAM,KAAK,YACpB,SAAS,MAAM,6BAA6B,QAAQ,IAAI,KAAK,QAAQ;EAGvE,OAAO;CACT;;;;;CAMA,MAAM,UAAwB;EAC5B,OAAO,KAAK,QAAQ;CACtB;;;;CAKA,MAAM,QAAyB;EAC7B,MAAM,SAAS,MAAM,KAAK,QAAQ;EAClC,OAAO,IAAI,IAAI,MAAM;CACvB;;;;;;;CAQA,MAAM,MAAS,OAA2C;EACxD,MAAM,SAAS,MAAM,KAAK,QAAQ;EAClC,MAAM,sBAAM,IAAI,IAAU;EAC1B,KAAK,MAAM,QAAQ,QACjB,IAAI,IAAI,MAAM,IAAI,GAAG,IAAI;EAE3B,OAAO;CACT;AACF;;;;AAKA,IAAa,mBAAb,MAAiC;CAC/B,YACE,OACA,YACA,UACA;EAHQ,KAAA,QAAA;EACA,KAAA,aAAA;EACA,KAAA,WAAA;CACP;;;;CAKH,MAAM,UAAsB;EAC1B,IAAI,SAAoB,KAAK;EAE7B,KAAK,IAAI,IAAI,GAAG,IAAI,KAAK,WAAW,QAAQ,KAAK;GAC/C,MAAM,KAAK,KAAK,WAAW;GAG3B,IAFe,MAAM,KAAK,WAAW,SAAS,KAEhC,oBAAoB,GAAG,IAAI,GACvC,OAAO,yBAA4B,QAAQ,IAAI,KAAK,QAAQ;GAG9D,SAAS,MAAM,6BAA6B,QAAQ,IAAI,KAAK,QAAQ;EACvE;EAEA,OAAO;CACT;AACF;;;;;;;;AC14BA,IAAM,4BAA4B;;;;;;;;AASlC,SAAS,0BAA0B,aAA6B;CAC9D,OAAO,KAAK,IAAI,aAAa,yBAAyB;AACxD;;AA6BA,IAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;AAiD1B,IAAa,WAAb,MAAa,iBAAiB,YAAY;CAgBxC,YAAY,SAAgC,CAAC,GAAG;EAC9C,MAAM;EAdmB,KAAA,UAAA;EACG,KAAA,cAAA;EACG,KAAA,iBAAA;EACH,KAAA,cAAA;EACO,KAAA,qBAAA;EAIjC,KAAA,iCAAA,IAAI,IAAI;EAG+B,KAAA,WAAA;EAKzC,IAAI,SAAS,aAAa,OAAO,KAAK,MAAM,CAAC,CAAC,WAAW,GACvD,OAAO,SAAS;EAGlB,KAAK,SAAS,KAAK,YAAY,MAAM;EAErC,IAAI,CAAC,SAAS,WACZ,SAAS,YAAY;EAGvB,KAAK,WAAW;CAClB;CAEA,YAAoB,YAAiD;EAenE,OAAO;GAbL,UAAU,cAAc,sBAAsB;GAC9C,SAAS;GACT,SAAS;GACT,YAAY;GACZ,OAAO;GACP,uBAAuB;GACvB,kBAAkB;GAClB,eAAe;GACf,cAAc;GACd,mBAAmB;GACnB,cAAc;GAGW,GAAG;EAAW;CAC3C;CAEA,OAAO,YAAY,QAA0C;EAC3D,IAAI,CAAC,SAAS,WACZ,SAAS,YAAY,IAAI,SAAS,MAAM;EAE1C,OAAO,SAAS;CAClB;CAEA,MAAc,aAA4B;EACxC,IAAI;GACF,KAAK,UAAU;GAEf,KAAK,WAAW,sBAAsB,IAAI;GAC1C,KAAK,UAAU,eAAe;IAC5B,SAAS;IACT,SAAS,KAAK,OAAO;GACvB,CAAC;EACH,SAAS,OAAO;GACd,QAAQ,MAAM,kCAAkC,KAAK;GACrD,MAAM;EACR;CACF;;;;;;;;;;;;;;CAeA,cAA+B;EAC7B,IAAI,CAAC,KAAK,UACR,KAAK,WAAW,sBAAsB,IAAI;EAE5C,OAAO,KAAK;CACd;;;;;CAQA,MAAM,QACJ,OACA,eACA,YAAY,GACK;EACjB,OAAO,KAAK,YAAY,CAAC,CAAC,QAAQ,OAAO,eAAe,SAAS;CACnE;;;;;CAMA,MAAM,YACJ,OACA,eACA,WACiB;EACjB,OAAO,KAAK,YAAY,CAAC,CAAC,YAAY,OAAO,eAAe,SAAS;CACvE;;;;;CAMA,MAAM,GAAM,OAAY,OAAuC;EAC7D,OAAO,KAAK,YAAY,CAAC,CAAC,GAAG,OAAO,KAAK;CAC3C;;;;;CAMA,MAAM,MAAS,OAAY,OAAgB,KAA4B;EACrE,OAAO,KAAK,YAAY,CAAC,CAAC,MAAM,OAAO,OAAO,GAAG;CACnD;;;;;CAMA,MAAM,OAAU,OAAY,GAAG,OAAkC;EAC/D,OAAO,KAAK,YAAY,CAAC,CAAC,OAAO,OAAO,GAAG,KAAK;CAClD;;;;;CAMA,MAAM,MAAM,OAAe,KAAa,OAAO,GAAsB;EACnE,OAAO,KAAK,YAAY,CAAC,CAAC,MAAM,OAAO,KAAK,IAAI;CAClD;;;;;CAMA,MAAM,OAAU,OAAU,OAA6B;EACrD,OAAO,KAAK,YAAY,CAAC,CAAC,OAAO,OAAO,KAAK;CAC/C;;;;;CAMA,MAAM,OAAU,OAA0B;EACxC,OAAO,KAAK,YAAY,CAAC,CAAC,OAAO,KAAK;CACxC;;;;;CAMA,MAAM,SAAe,OAAY,OAAqC;EACpE,OAAO,KAAK,YAAY,CAAC,CAAC,SAAS,OAAO,KAAK;CACjD;;;;;CAMA,MAAM,MAAS,OAAY,MAA8B;EACvD,OAAO,KAAK,YAAY,CAAC,CAAC,MAAM,OAAO,IAAI;CAC7C;;;;;CAMA,MAAM,IACJ,GAAG,QACkE;EACrE,OAAO,KAAK,YAAY,CAAC,CAAC,IAAI,GAAG,MAAM;CACzC;;;;;CAQA,MAAM,SACJ,OACA,WACwB;EACxB,OAAO,KAAK,YAAY,CAAC,CAAC,SAAS,OAAO,SAAS;CACrD;;;;;CAMA,MAAM,cACJ,OACA,WACiB;EACjB,OAAO,KAAK,YAAY,CAAC,CAAC,cAAc,OAAO,SAAS;CAC1D;;;;;CAMA,MAAM,SACJ,OACA,WACc;EACd,OAAO,KAAK,YAAY,CAAC,CAAC,SAAS,OAAO,SAAS;CACrD;;;;;CAMA,MAAM,WAAc,OAA0B;EAC5C,OAAO,KAAK,YAAY,CAAC,CAAC,WAAW,KAAK;CAC5C;;;;;CAMA,MAAM,YAAe,OAAY,OAAe,OAAwB;EACtE,OAAO,KAAK,YAAY,CAAC,CAAC,YAAY,OAAO,OAAO,KAAK;CAC3D;;;;;CAMA,MAAM,UACJ,OACA,OACA,aACA,GAAG,OACW;EACd,OAAO,KAAK,YAAY,CAAC,CAAC,UAAU,OAAO,OAAO,aAAa,GAAG,KAAK;CACzE;;;;;CAMA,MAAM,cACJ,OACA,OACkC;EAClC,OAAO,KAAK,YAAY,CAAC,CAAC,cAAc,OAAO,KAAK;CACtD;CAEA,UACE,MACA,QACM;EACN,MAAM,YAAY,KAAK,eAAe,IAAI,IAAI;EAC9C,IAAI,WACF,UAAU,SAAS,aAAa;GAC9B,IAAI;IACF,SAAqC,MAAM;GAC7C,SAAS,OAAO;IACd,IAAI,KAAK,OAAO,OACd,QAAQ,MAAM,+BAA+B,KAAK,IAAI,KAAK;GAE/D;EACF,CAAC;CAEL;CAEA,GACE,OACA,UACM;EACN,IAAI,CAAC,KAAK,eAAe,IAAI,KAAK,GAChC,KAAK,eAAe,IAAI,uBAAO,IAAI,IAAI,CAAC;EAE1C,KAAK,eACF,IAAI,KAAK,CAAC,CACV,IAAI,QAAqD;CAC9D;CAEA,IACE,OACA,UACM;EACN,MAAM,YAAY,KAAK,eAAe,IAAI,KAAK;EAC/C,IAAI,WACF,UAAU,OAAO,QAAqD;CAE1E;CAEA,cAAsB,OAA8C;EAClE,OACE,OAAO,UAAU,YACjB,UAAU,QACV,qBAAsB,SACtB,MAAM,QAAS,MAAkC,kBAAkB;CAEvE;CAEA,kBAA0B,GAAG,MAAsC;EACjE,OAAO,GACJ,oBAAoB,KACvB;CACF;CAEA,iBACE,MACW;EACX,IAAI,OAAO,SAAS,aAClB,OAAO,CAAC;EAGV,IAAI,KAAK,cAAc,IAAI,GACzB,OAAO,CAAC,GAAG,KAAK,kBAAkB;EAGpC,OAAO,CAAC,IAAI;CACd;CAEA,MAAc,oBACZ,MACA,MACA,SACY;EACZ,IAAI,QAAQ,QAAQ,SAClB,MAAM,IAAI,YAAY,wCAAwC;EAGhE,MAAM,YAAY,QAAQ,QAAQ,CAAC,CAAC,WAAW,KAAK,GAAG,IAAI,CAAC;EAC5D,MAAM,aAAa,KAAK,cAAc,WAAW,QAAQ,MAAM;EAE/D,IAAI,OAAO,QAAQ,YAAY,UAC7B,OAAO,KAAK,YAAY,YAAY,QAAQ,OAAO;EAGrD,OAAO;CACT;CAEA,cACE,SACA,QACY;EACZ,IAAI,CAAC,QACH,OAAO;EAGT,IAAI,OAAO,SACT,OAAO,QAAQ,OAAO,IAAI,YAAY,uBAAuB,CAAC;EAGhE,OAAO,IAAI,SAAY,SAAS,WAAW;GACzC,MAAM,gBAAgB;IACpB,OAAO,oBAAoB,SAAS,OAAO;IAC3C,OAAO,IAAI,YAAY,uBAAuB,CAAC;GACjD;GAEA,OAAO,iBAAiB,SAAS,SAAS,EAAE,MAAM,KAAK,CAAC;GAExD,QAAQ,MACL,UAAU;IACT,OAAO,oBAAoB,SAAS,OAAO;IAC3C,QAAQ,KAAK;GACf,IACC,UAAU;IACT,OAAO,oBAAoB,SAAS,OAAO;IAC3C,OAAO,KAAK;GACd,CACF;EACF,CAAC;CACH;CAEA,YAAuB,SAAqB,SAA6B;EACvE,IAAI,WAAW,GACb,OAAO;EAGT,IAAI;EAEJ,OAAO,IAAI,SAAY,SAAS,WAAW;GACzC,YAAY,iBAAiB;IAC3B,OAAO,IAAI,aAAa,OAAO,CAAC;GAClC,GAAG,OAAO;GAEV,QAAQ,MACL,UAAU;IACT,IAAI,WACF,aAAa,SAAS;IAExB,QAAQ,KAAK;GACf,IACC,UAAU;IACT,IAAI,WACF,aAAa,SAAS;IAExB,OAAO,KAAK;GACd,CACF;EACF,CAAC;CACH;CAEA,cAAsB,MAA+C;EACnE,MAAM,cACJ,OAAO,KAAK,OAAO,aACf,KAAK,KACL,OAAQ,KAAoB,SAAS,aAClC,KAAoB,OACrB,KAAA;EAER,IAAI,OAAO,gBAAgB,YACzB,MAAM,IAAI,YACR,6CACA,cACF;EAGF,OAAO;GACL,IAAI;GACJ,MAAM,KAAK;GACX,SAAS,KAAK;EAChB;CACF;CAEA,MAAM,IACJ,MACA,MACA,UAAyB,CAAC,GACd;EACZ,IAAI,CAAC,KAAK,SACR,MAAM,KAAK,WAAW;EAIxB,iBAAiB,MAAM,MAAM;EAE7B,MAAM,SAAS,KAAK,eAAe;EACnC,MAAM,YAAY,cAAc,oBAAoB;EACpD,MAAM,OAAO,KAAK,iBAAiB,IAAI;EAGvC,KAAK,MAAM,OAAO,MAChB,qBAAqB,GAAG;EAG1B,MAAM,aAAa,KAAK,IACtB,GACA,QAAQ,cAAc,KAAK,OAAO,WAAW,CAC/C;EACA,IAAI,UAAU;EAGd,OAAO,MACL,IAAI;GACF,MAAM,SAAS,MAAM,KAAK,oBAAuB,MAAM,MAAM,OAAO;GAEpE,MAAM,WAAW,cAAc,oBAAoB,IAAI;GACvD,KAAK,kBAAkB;GACvB,KAAK,sBAAsB;GAE3B,KAAK,UAAU,iBAAiB;IAC9B;IACQ;IACR;GACF,CAAC;GAED,OAAO;EACT,SAAS,OAAO;GACd,IAAI,WAAW,YAAY;IACzB,MAAM,WAAW,cAAc,oBAAoB,IAAI;IACvD,MAAM,eACJ,iBAAiB,QAAQ,MAAM,UAAU,OAAO,KAAK;IAEvD,KAAK,eAAe;IACpB,KAAK,UAAU,cAAc;KAC3B;KACA,OAAO;KACP;IACF,CAAC;IAED,MAAM;GACR;GAEA,WAAW;GAEX,IAAI,KAAK,OAAO,OACd,QAAQ,KACN,0BAA0B,OAAO,YAAY,QAAQ,MAAM,WAAW,IACtE,KACF;EAEJ;CAEJ;CAEA,MAAM,IACJ,OACA,MACA,UAAsB,CAAC,GACT;EACd,IAAI,CAAC,MAAM,QACT,OAAO,CAAC;EAGV,MAAM,EAAE,YAAY,MAAM,QAAQ,GAAG,eAAe;EACpD,MAAM,mBAAkC,EAAE,GAAG,WAAW;EACxD,MAAM,sBAAsB,KAAK,IAAI,GAAG,KAAK,MAAM,SAAS,CAAC;EAC7D,MAAM,UAAe,CAAC;EAEtB,KAAK,IAAI,QAAQ,GAAG,QAAQ,MAAM,QAAQ,SAAS,qBAAqB;GACtE,MAAM,QAAQ,MAAM,MAAM,OAAO,QAAQ,mBAAmB;GAC5D,MAAM,eAAe,MAAM,QAAQ,IACjC,MAAM,KAAK,MAAM,WACf,KAAK,IACH,MACA,KAAK,kBAAkB,MAAM,QAAQ,QAAQ,KAAK,GAClD,gBACF,CACF,CACF;GACA,QAAQ,KAAK,GAAG,YAAY;EAC9B;EAEA,OAAO;CACT;CAEA,MAAM,OACJ,OACA,WACA,UAAsB,CAAC,GACT;EACd,IAAI,CAAC,MAAM,QACT,OAAO,CAAC;EAGV,MAAM,UAAU,MAAM,KAAK,IAAgB,OAAO,WAAW,OAAO;EACpE,OAAO,MAAM,QAAQ,GAAG,UAAU,QAAQ,QAAQ,MAAM,CAAC;CAC3D;CAEA,MAAM,OACJ,OACA,SACA,cACA,UAAyB,CAAC,GACd;EACZ,IAAI,cAAc;EAElB,IAAI,CAAC,MAAM,QACT,OAAO;EAGT,KAAK,IAAI,QAAQ,GAAG,QAAQ,MAAM,QAAQ,SACxC,cAAc,MAAM,KAAK,IACvB,SACA,KAAK,kBAAkB,aAAa,MAAM,QAAQ,OAAO,KAAK,GAC9D,OACF;EAGF,OAAO;CACT;;;;;;;;;;;;;;;;;CAkBA,MAAM,QACJ,OACA,MACA,UAAsB,CAAC,GACR;EACf,MAAM,KAAK,IAAa,OAAO,MAAM,OAAO;CAC9C;;;;;;;;;;;;;;;;;;;;;;;CAwBA,MAAM,KACJ,OACA,WACA,UAAsB,CAAC,GACC;EACxB,IAAI,CAAC,MAAM,QACT;EAIF,MAAM,YAAY,cAChB,QAAQ,WACR,0BAA0B,MAAM,MAAM,CACxC;EACA,MAAM,mBAAkC,EAAE,GAAG,QAAQ;EAErD,KAAK,IAAI,IAAI,GAAG,IAAI,MAAM,QAAQ,KAAK,WAAW;GAChD,MAAM,QAAQ,MAAM,MAAM,GAAG,IAAI,SAAS;GAY1C,MAAM,cAAa,MAXG,QAAQ,IAC5B,MAAM,KAAK,MAAM,WACf,KAAK,IACH,WACA,KAAK,kBAAkB,MAAM,IAAI,QAAQ,KAAK,GAC9C,gBACF,CACF,CACF,EAAA,CAG2B,WAAW,WAAW,QAAQ,MAAM,CAAC;GAChE,IAAI,eAAe,IACjB,OAAO,MAAM;EAEjB;CAGF;;;;;;;;;;;;;;;;;;;;CAqBA,MAAM,UACJ,OACA,WACA,UAAsB,CAAC,GACN;EACjB,IAAI,CAAC,MAAM,QACT,OAAO;EAGT,MAAM,YAAY,cAChB,QAAQ,WACR,0BAA0B,MAAM,MAAM,CACxC;EACA,MAAM,mBAAkC,EAAE,GAAG,QAAQ;EAErD,KAAK,IAAI,IAAI,GAAG,IAAI,MAAM,QAAQ,KAAK,WAAW;GAChD,MAAM,QAAQ,MAAM,MAAM,GAAG,IAAI,SAAS;GAW1C,MAAM,cAAa,MAVG,QAAQ,IAC5B,MAAM,KAAK,MAAM,WACf,KAAK,IACH,WACA,KAAK,kBAAkB,MAAM,IAAI,QAAQ,KAAK,GAC9C,gBACF,CACF,CACF,EAAA,CAE2B,WAAW,WAAW,QAAQ,MAAM,CAAC;GAChE,IAAI,eAAe,IACjB,OAAO,IAAI;EAEf;EAEA,OAAO;CACT;;;;;;;;;;;;;;;;;;;;CAqBA,MAAM,KACJ,OACA,WACA,UAAsB,CAAC,GACL;EAClB,IAAI,CAAC,MAAM,QACT,OAAO;EAGT,MAAM,YAAY,cAChB,QAAQ,WACR,0BAA0B,MAAM,MAAM,CACxC;EACA,MAAM,mBAAkC,EAAE,GAAG,QAAQ;EAErD,KAAK,IAAI,IAAI,GAAG,IAAI,MAAM,QAAQ,KAAK,WAAW;GAChD,MAAM,QAAQ,MAAM,MAAM,GAAG,IAAI,SAAS;GAY1C,KAAI,MAXkB,QAAQ,IAC5B,MAAM,KAAK,MAAM,WACf,KAAK,IACH,WACA,KAAK,kBAAkB,MAAM,IAAI,QAAQ,KAAK,GAC9C,gBACF,CACF,CACF,EAAA,CAGY,MAAM,WAAW,QAAQ,MAAM,CAAC,GAC1C,OAAO;EAEX;EAEA,OAAO;CACT;;;;;;;;;;;;;;;;;;;;CAqBA,MAAM,MACJ,OACA,WACA,UAAsB,CAAC,GACL;EAClB,IAAI,CAAC,MAAM,QACT,OAAO;EAGT,MAAM,YAAY,cAChB,QAAQ,WACR,0BAA0B,MAAM,MAAM,CACxC;EACA,MAAM,mBAAkC,EAAE,GAAG,QAAQ;EAErD,KAAK,IAAI,IAAI,GAAG,IAAI,MAAM,QAAQ,KAAK,WAAW;GAChD,MAAM,QAAQ,MAAM,MAAM,GAAG,IAAI,SAAS;GAY1C,IAAI,EAAC,MAXiB,QAAQ,IAC5B,MAAM,KAAK,MAAM,WACf,KAAK,IACH,WACA,KAAK,kBAAkB,MAAM,IAAI,QAAQ,KAAK,GAC9C,gBACF,CACF,CACF,EAAA,CAGa,OAAO,WAAW,QAAQ,MAAM,CAAC,GAC5C,OAAO;EAEX;EAEA,OAAO;CACT;;;;;;;;;;;;;;;;;;;;;CAsBA,MAAM,QACJ,OACA,MACA,UAAsB,CAAC,GACT;EACd,IAAI,CAAC,MAAM,QACT,OAAO,CAAC;EAIV,QAAO,MADe,KAAK,IAAY,OAAO,MAAM,OAAO,EAAA,CAC5C,KAAK;CACtB;;;;;;;;;;;;;;;;;;;;;;;CAwBA,MAAM,YACJ,OACA,SACA,cACA,UAAyB,CAAC,GACd;EACZ,IAAI,cAAc;EAElB,IAAI,CAAC,MAAM,QACT,OAAO;EAIT,KAAK,IAAI,QAAQ,MAAM,SAAS,GAAG,SAAS,GAAG,SAC7C,cAAc,MAAM,KAAK,IACvB,SACA,KAAK,kBAAkB,aAAa,MAAM,QAAQ,OAAO,KAAK,GAC9D,OACF;EAGF,OAAO;CACT;;;;;;;;;;;;;;;;;;;;;CAsBA,MAAM,QACJ,OACA,OACA,UAAsB,CAAC,GACD;EACtB,IAAI,CAAC,MAAM,QACT,uBAAO,IAAI,IAAI;EAGjB,MAAM,OAAO,MAAM,KAAK,IAAU,OAAO,OAAO,OAAO;EACvD,MAAM,yBAAS,IAAI,IAAY;EAE/B,KAAK,IAAI,IAAI,GAAG,IAAI,MAAM,QAAQ,KAAK;GACrC,MAAM,MAAM,KAAK;GACjB,IAAI,CAAC,OAAO,IAAI,GAAG,GACjB,OAAO,IAAI,KAAK,CAAC,CAAC;GAEpB,OAAO,IAAI,GAAG,CAAC,CAAE,KAAK,MAAM,EAAE;EAChC;EAEA,OAAO;CACT;;;;;;;;;;;;;;;;;;;;;;CAuBA,MAAM,UACJ,OACA,WACA,UAAsB,CAAC,GACF;EACrB,IAAI,CAAC,MAAM,QACT,OAAO,CAAC,CAAC,GAAG,CAAC,CAAC;EAGhB,MAAM,UAAU,MAAM,KAAK,IAAgB,OAAO,WAAW,OAAO;EACpE,MAAM,SAAc,CAAC;EACrB,MAAM,QAAa,CAAC;EAEpB,KAAK,IAAI,IAAI,GAAG,IAAI,MAAM,QAAQ,KAChC,IAAI,QAAQ,IACV,OAAO,KAAK,MAAM,EAAE;OAEpB,MAAM,KAAK,MAAM,EAAE;EAIvB,OAAO,CAAC,QAAQ,KAAK;CACvB;;;;;;;;;;;;;;;;;;;;CAqBA,MAAM,MACJ,OACA,WACA,UAAsB,CAAC,GACN;EACjB,IAAI,CAAC,MAAM,QACT,OAAO;EAIT,QAAO,MADe,KAAK,IAAgB,OAAO,WAAW,OAAO,EAAA,CACrD,OAAO,OAAO,CAAC,CAAC;CACjC;;;;;;;;;;;;;;;;;;;CAoBA,KAAQ,OAAyB;EAC/B,OAAO,IAAI,SAAY,OAAO,IAAI;CACpC;;;;;;;;;;;;;;;;;CAkBA,MAAM,MACJ,OACA,YAAoB,MAAM,QACH;EACvB,IAAI,CAAC,MAAM,QACT,OAAO,CAAC;EAGV,MAAM,sBAAsB,KAAK,IAAI,GAAG,KAAK,MAAM,SAAS,CAAC;EAC7D,MAAM,UAAwB,CAAC;EAE/B,KAAK,IAAI,QAAQ,GAAG,QAAQ,MAAM,QAAQ,SAAS,qBAAqB;GACtE,MAAM,QAAQ,MAAM,MAAM,OAAO,QAAQ,mBAAmB;GAE5D,MAAM,eAAe,MAAM,QAAQ,IACjC,MAAM,IAAI,OAAO,SAAS;IACxB,IAAI;KACF,MAAM,aAAa,KAAK,cAAc,IAAI;KAQ1C,OAAO;MACL,SAAS;MACD,QAAA,MATW,KAAK,IACxB,WAAW,IACX,WAAW,MAEX,WAAW,WAAW,CAAC,CACzB;MAKE,OAAO;KACT;IACF,SAAS,OAAO;KACd,OAAO;MACL,SAAS;MACT,QAAQ;MACR,OAAO,iBAAiB,QAAQ,MAAM,UAAU,OAAO,KAAK;KAC9D;IACF;GACF,CAAC,CACH;GAEA,QAAQ,KAAK,GAAG,YAAY;EAC9B;EAEA,OAAO;CACT;CAEA,MAAM,SACJ,OACc;EACd,MAAM,UAAU,MAAM,KAAK,MAAM,KAAK;EACtC,MAAM,WAAW,QAAQ,QAAQ,WAAW,CAAC,OAAO,OAAO;EAE3D,IAAI,SAAS,SAAS,GAMpB,MAAM,IAAI,YALM,SACb,KAAK,YAAY,QAAQ,KAAK,CAAC,CAC/B,QAAQ,UAA2B,QAAQ,KAAK,CAAC,CAAC,CAClD,KAAK,IAGN,KAAW,iDACb;EAGF,OAAO,QAAQ,KAAK,WAAW,OAAO,MAAW;CACnD;CAEA,MAAM,OAAO,SAAgC;EAC3C,MAAM,UAAU,KAAK,OAAO;EAC5B,KAAK,OAAO,WAAW;EACvB,KAAK,UAAU,eAAe;GAAE;GAAS;EAAQ,CAAC;CACpD;CAEA,cAAsB;EACpB,OAAO,KAAK,OAAO;CACrB;CAEA,mBAA2B;EACzB,OAAO;CACT;CAEA,iBAAyB;EACvB,OAAO;CACT;CAEA,gBAAyB;EACvB,OAAO,KAAK;CACd;CAEA,YAA0B;EACxB,OAAO,EAAE,GAAG,KAAK,OAAO;CAC1B;CAEA,aAAa,WAAwC;EACnD,KAAK,SAAS;GAAE,GAAG,KAAK;GAAQ,GAAG;EAAU;CAC/C;CAEA,WAME;EACA,OAAO;GACL,eAAe,KAAK,iBAAiB;GACrC,aAAa,KAAK,IAAI,GAAG,KAAK,OAAO,WAAW,KAAK,iBAAiB,CAAC;GACvE,aAAa,KAAK,eAAe;GACjC,gBAAgB,KAAK;GACrB,sBACE,KAAK,iBAAiB,IAClB,KAAK,qBAAqB,KAAK,iBAC/B;EACR;CACF;CAEA,cAAsB;EACpB,OAAO,cAAc,eAAe;CACtC;CAEA,cAAuB;EACrB,OAAO,cAAc,sBAAsB;CAC7C;CAEA,iBAAiC;EAC/B,OAAO,QAAQ,EAAE,KAAK,YAAY,GAAG,KAAK,IAAI;CAChD;CAEA,MAAM,YAA2B;EAC/B,KAAK,UAAU;EACf,KAAK,iBAAiB;EACtB,KAAK,cAAc;EACnB,KAAK,qBAAqB;EAC1B,KAAK,cAAc;EACnB,KAAK,eAAe,MAAM;EAE1B,IAAI,SAAS,cAAc,MACzB,SAAS,YAAY;CAEzB;CAEA,aAAa,eAA8B;EACzC,IAAI,SAAS,WACX,MAAM,SAAS,UAAU,UAAU;CAEvC;CAGA,aAAa,IACX,MACA,MACA,UAAyB,CAAC,GACd;EAEZ,OADiB,SAAS,YACnB,CAAA,CAAS,IAAO,MAAM,MAAM,OAAO;CAC5C;CAEA,aAAa,IACX,OACA,MACA,UAAsB,CAAC,GACT;EAEd,OADiB,SAAS,YACnB,CAAA,CAAS,IAAU,OAAO,MAAM,OAAO;CAChD;CAEA,aAAa,OACX,OACA,MACA,UAAsB,CAAC,GACT;EAEd,OADiB,SAAS,YACnB,CAAA,CAAS,OAAO,OAAO,MAAM,OAAO;CAC7C;CAEA,aAAa,OACX,OACA,MACA,cACA,UAAyB,CAAC,GACd;EAEZ,OADiB,SAAS,YACnB,CAAA,CAAS,OAAO,OAAO,MAAM,cAAc,OAAO;CAC3D;CAEA,aAAa,QACX,OACA,MACA,UAAsB,CAAC,GACR;EAEf,OADiB,SAAS,YACnB,CAAA,CAAS,QAAQ,OAAO,MAAM,OAAO;CAC9C;;;;;CAMA,aAAa,KACX,OACA,WACA,UAAsB,CAAC,GACC;EAExB,OADiB,SAAS,YACnB,CAAA,CAAS,KAAK,OAAO,WAAW,OAAO;CAChD;;;;;CAMA,aAAa,UACX,OACA,WACA,UAAsB,CAAC,GACN;EAEjB,OADiB,SAAS,YACnB,CAAA,CAAS,UAAU,OAAO,WAAW,OAAO;CACrD;;;;;CAMA,aAAa,KACX,OACA,WACA,UAAsB,CAAC,GACL;EAElB,OADiB,SAAS,YACnB,CAAA,CAAS,KAAK,OAAO,WAAW,OAAO;CAChD;;;;;CAMA,aAAa,MACX,OACA,WACA,UAAsB,CAAC,GACL;EAElB,OADiB,SAAS,YACnB,CAAA,CAAS,MAAM,OAAO,WAAW,OAAO;CACjD;CAEA,aAAa,MACX,OACA,WACuB;EAEvB,OADiB,SAAS,YACnB,CAAA,CAAS,MAAM,OAAO,SAAS;CACxC;CAEA,aAAa,SACX,OACc;EAEd,OADiB,SAAS,YACnB,CAAA,CAAS,SAAS,KAAK;CAChC;CAEA,aAAa,OAAO,SAAgC;EAElD,OADiB,SAAS,YACnB,CAAA,CAAS,OAAO,OAAO;CAChC;CAEA,OAAO,cAAsB;EAE3B,OADiB,SAAS,YACnB,CAAA,CAAS,YAAY;CAC9B;CAEA,OAAO,mBAA2B;EAEhC,OADiB,SAAS,YACnB,CAAA,CAAS,iBAAiB;CACnC;CAEA,OAAO,iBAAyB;EAE9B,OADiB,SAAS,YACnB,CAAA,CAAS,eAAe;CACjC;CAEA,OAAO,gBAAyB;EAE9B,OADiB,SAAS,YACnB,CAAA,CAAS,cAAc;CAChC;CAEA,OAAO,YAA0B;EAE/B,OADiB,SAAS,YACnB,CAAA,CAAS,UAAU;CAC5B;CAEA,OAAO,aAAa,WAAwC;EAE1D,OADiB,SAAS,YACnB,CAAA,CAAS,aAAa,SAAS;CACxC;CAEA,OAAO,WAML;EAEA,OADiB,SAAS,YACnB,CAAA,CAAS,SAAS;CAC3B;CAEA,OAAO,cAAsB;EAC3B,OAAO,cAAc,eAAe;CACtC;CAEA,OAAO,cAAuB;EAC5B,OAAO,cAAc,sBAAsB;CAC7C;;;;;CAMA,aAAa,QACX,OACA,MACA,UAAsB,CAAC,GACT;EAEd,OADiB,SAAS,YACnB,CAAA,CAAS,QAAc,OAAO,MAAM,OAAO;CACpD;;;;;CAMA,aAAa,YACX,OACA,SACA,cACA,UAAyB,CAAC,GACd;EAEZ,OADiB,SAAS,YACnB,CAAA,CAAS,YAAkB,OAAO,SAAS,cAAc,OAAO;CACzE;;;;;CAMA,aAAa,QACX,OACA,OACA,UAAsB,CAAC,GACD;EAEtB,OADiB,SAAS,YACnB,CAAA,CAAS,QAAc,OAAO,OAAO,OAAO;CACrD;;;;;CAMA,aAAa,UACX,OACA,WACA,UAAsB,CAAC,GACF;EAErB,OADiB,SAAS,YACnB,CAAA,CAAS,UAAa,OAAO,WAAW,OAAO;CACxD;;;;;CAMA,aAAa,MACX,OACA,WACA,UAAsB,CAAC,GACN;EAEjB,OADiB,SAAS,YACnB,CAAA,CAAS,MAAS,OAAO,WAAW,OAAO;CACpD;;;;;CAMA,OAAO,KAAQ,OAAyB;EAEtC,OADiB,SAAS,YACnB,CAAA,CAAS,KAAQ,KAAK;CAC/B;;;;;CAQA,aAAa,QACX,OACA,eACA,YAAY,GACK;EAEjB,OADiB,SAAS,YACnB,CAAA,CAAS,QAAQ,OAAO,eAAe,SAAS;CACzD;;;;;CAMA,aAAa,YACX,OACA,eACA,WACiB;EAEjB,OADiB,SAAS,YACnB,CAAA,CAAS,YAAY,OAAO,eAAe,SAAS;CAC7D;;;;;CAMA,aAAa,GAAM,OAAY,OAAuC;EAEpE,OADiB,SAAS,YACnB,CAAA,CAAS,GAAG,OAAO,KAAK;CACjC;;;;;CAMA,aAAa,MACX,OACA,OACA,KACc;EAEd,OADiB,SAAS,YACnB,CAAA,CAAS,MAAM,OAAO,OAAO,GAAG;CACzC;;;;;CAMA,aAAa,OAAU,OAAY,GAAG,OAAkC;EAEtE,OADiB,SAAS,YACnB,CAAA,CAAS,OAAO,OAAO,GAAG,KAAK;CACxC;;;;;CAMA,aAAa,MAAM,OAAe,KAAa,OAAO,GAAsB;EAE1E,OADiB,SAAS,YACnB,CAAA,CAAS,MAAM,OAAO,KAAK,IAAI;CACxC;;;;;CAMA,aAAa,OAAU,OAAU,OAA6B;EAE5D,OADiB,SAAS,YACnB,CAAA,CAAS,OAAO,OAAO,KAAK;CACrC;;;;;CAMA,aAAa,OAAU,OAA0B;EAE/C,OADiB,SAAS,YACnB,CAAA,CAAS,OAAO,KAAK;CAC9B;;;;;CAMA,aAAa,SAAe,OAAY,OAAqC;EAE3E,OADiB,SAAS,YACnB,CAAA,CAAS,SAAS,OAAO,KAAK;CACvC;;;;;CAMA,aAAa,MAAS,OAAY,MAA8B;EAE9D,OADiB,SAAS,YACnB,CAAA,CAAS,MAAM,OAAO,IAAI;CACnC;;;;;CAMA,aAAa,IACX,GAAG,QACkE;EAErE,OADiB,SAAS,YACnB,CAAA,CAAS,IAAI,GAAG,MAAM;CAC/B;;;;;CAMA,OAAO,cAA+B;EAEpC,OADiB,SAAS,YACnB,CAAA,CAAS,YAAY;CAC9B;AACF;;AAtiD8C,UAAA,YAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;ACzE9C,SAAgB,sBACd,gBAK0B;CAC1B,OAAO,SACL,gBACA,sBACA,YACwB;EAExB,IACE,OAAO,mBAAmB,cAC1B,wBACA,OAAO,yBAAyB,YAChC,UAAU,sBACV;GACA,MAAM,UAAU;GAChB,IAAI,QAAQ,SAAS,UACnB,MAAM,IAAI,MAAM,0CAA0C;GAG5D,OAAO,eAAe,gBADH,OAAO,QAAQ,IACS,CAAU;EACvD;EAGA,IAAI,cAAc,OAAO,WAAW,UAAU,YAAY;GACxD,MAAM,aAAa,OAAO,oBAAoB;GAC9C,WAAW,QAAQ,eAAe,WAAW,OAAY,UAAU;GACnE,OAAO;EACT;EAEA,MAAM,IAAI,MAAM,0CAA0C;CAC5D;AACF;;;;;;;;;;;;;;;;;;;;;;;;AAyBA,SAAgB,+BACd,gBAS0B;CAC1B,OAAO,SACL,gBACA,sBACA,YACwB;EAExB,IACE,OAAO,mBAAmB,cAC1B,wBACA,OAAO,yBAAyB,YAChC,UAAU,sBACV;GACA,MAAM,UAAU;GAChB,IAAI,QAAQ,SAAS,UACnB,MAAM,IAAI,MAAM,0CAA0C;GAI5D,OAAO,eAAe,gBAFH,OAAO,QAAQ,IAES,GAAY,SAAS;EAClE;EAGA,IAAI,cAAc,OAAO,WAAW,UAAU,YAAY;GACxD,MAAM,aAAa,OAAO,oBAAoB;GAC9C,MAAM,YACH,gBAAwD,aACrD,QAAQ;GACd,WAAW,QAAQ,eACjB,WAAW,OACX,YACA,SACF;GACA,OAAO;EACT;EAEA,MAAM,IAAI,MAAM,0CAA0C;CAC5D;AACF;;;;;;;;AASA,SAAgB,qBAGd,gBACkB;CAClB,OAAO,SAAU,QAAc;EAE7B,OAAO,eAAe,QADJ,OAAO,QAAQ,gBACM;CACzC;AACF;;;;;;;;;;;;;;AClLA,SAAgB,eAAe,UAAiC,CAAC,GAAG;CAElE,MAAM,8BAAc,IAAI,IAAqB;CAE7C,OAAO,uBAAuB,mBAAmB;EAC/C,MAAM,gBAAgB,eAEpB,GAAG,MACe;GAElB,MAAM,WAAW,QAAQ,eAAe,KAAK,UAAU,IAAI,IAAI;GAG/D,IAAI,YAAY,YAAY,IAAI,QAAQ,GACtC,OAAO,YAAY,IAAI,QAAQ;GASjC,MAAM,SAAS,OALE,QAAQ,WACrB,SAAS,YAAY,EAAE,UAAU,QAAQ,SAAS,CAAC,IACnD,SAAS,YAAY,EAAA,CAGK,IAC5B,gBACA;IAAE,SAAS;IAAM;GAAK,GACtB;IACE,SAAS,QAAQ;IACjB,YAAY,QAAQ;IACpB,UAAU,QAAQ;GACpB,CACF;GAGA,IAAI,YAAY,QAAQ,cACtB,YAAY,IAAI,UAAU,MAAM;GAGlC,OAAO;EACT;EAEA,OAAO;CACT,CAAC;AACH;;;;AAKA,SAAgB,gBAAgB;CAC9B,OAAO,SACL,aACG;EACH,MAAM,kBACH,YACE,mBAAmB,CAAC;EAGzB,KAAK,MAAM,cAAc,iBAAiB;GACxC,MAAM,iBAAiB,YAAY,UAAU;GAC7C,IAAI,OAAO,mBAAmB,YAC5B,YAAY,UAAU,cAAc,eAClC,GAAG,MACH;IAEA,OADiB,SAAS,YACnB,CAAA,CAAS,IAAI,eAAe,KAAK,IAAI,GAAG,IAAI;GACrD;EAEJ;EAEA,OAAO;CACT;AACF;;;;AAKA,SAAgB,WAAW;CACzB,OAAO,uBAAuB,mBAAmB;EAC/C,eAA4C,YAAY;EACxD,OAAO;CACT,CAAC;AACH;;;;AAKA,SAAgB,cAAc,YAAoB,GAAG;CACnD,OAAO,uBAAuB,mBAAmB;EAC/C,MAAM,gBAAgB,eAEpB,MACA,GAAG,WACiB;GACpB,IAAI,CAAC,MAAM,QAAQ,IAAI,GACrB,MAAM,IAAI,MAAM,oDAAoD;GAGtE,MAAM,WAAW,SAAS,YAAY;GAGtC,MAAM,UAAuB,CAAC;GAC9B,KAAK,IAAI,IAAI,GAAG,IAAI,KAAK,QAAQ,KAAK,WACpC,QAAQ,KAAK,KAAK,MAAM,GAAG,IAAI,SAAS,CAAC;GAI3C,MAAM,gBAAgB,QAAQ,KAAK,UACjC,SAAS,IAAI,eAAe,KAAK,IAAI,GAAG,CAAC,OAAO,GAAG,SAAS,CAAC,CAC/D;GAGA,QAAO,MADoB,QAAQ,IAAI,aAAa,EAAA,CAChC,KAAK;EAC3B;EAEA,OAAO;CACT,CAAC;AACH;;;;AAKA,SAAgB,cAAc;CAC5B,OAAO,uBAAuB,mBAAmB;EAC/C,MAAM,gBAAgB,eAEpB,MACoB;GACpB,IAAI,CAAC,MAAM,QAAQ,IAAI,GACrB,MAAM,IAAI,MAAM,kDAAkD;GAGpE,MAAM,WAAW,SAAS,YAAY;GAGtC,MAAM,WAAW,KAAK,KAAK,SACzB,SAAS,IAAI,eAAe,KAAK,IAAI,GAAG,CAAC,IAAI,CAAC,CAChD;GAEA,OAAO,QAAQ,IAAI,QAAQ;EAC7B;EAEA,OAAO;CACT,CAAC;AACH;;;;;;;;;;;;;;;;;;;;;AC7GA,IAAa,WAAb,MAA4B;;;;;;CAe1B,YAAY,QAAwB;EAClC,KAAK,wBAAQ,IAAI,IAAI;EACrB,KAAK,UAAU,KAAK,IAAI,GAAG,OAAO,OAAO;EACzC,KAAK,QAAQ,OAAO,SAAS;CAC/B;;;;;;;;;;CAWA,IAAI,KAAuB;EACzB,MAAM,QAAQ,KAAK,MAAM,IAAI,GAAG;EAEhC,IAAI,CAAC,OACH;EAIF,IAAI,MAAM,WAAW,KAAA,KAAa,KAAK,IAAI,IAAI,MAAM,QAAQ;GAC3D,KAAK,MAAM,OAAO,GAAG;GACrB;EACF;EAGA,KAAK,MAAM,OAAO,GAAG;EACrB,KAAK,MAAM,IAAI,KAAK,KAAK;EAEzB,OAAO,MAAM;CACf;;;;;;;;;CAUA,IAAI,KAAQ,OAAgB;EAE1B,IAAI,KAAK,MAAM,IAAI,GAAG,GACpB,KAAK,MAAM,OAAO,GAAG;EAIvB,IAAI,KAAK,MAAM,QAAQ,KAAK,SAAS;GACnC,MAAM,YAAY,KAAK,MAAM,KAAK,CAAC,CAAC,KAAK,CAAC,CAAC;GAC3C,IAAI,cAAc,KAAA,GAChB,KAAK,MAAM,OAAO,SAAS;EAE/B;EAGA,MAAM,QAAuB;GAC3B;GACA,QAAQ,KAAK,QAAQ,IAAI,KAAK,IAAI,IAAI,KAAK,QAAQ,KAAA;EACrD;EACA,KAAK,MAAM,IAAI,KAAK,KAAK;CAC3B;;;;;;;CAQA,IAAI,KAAiB;EACnB,MAAM,QAAQ,KAAK,MAAM,IAAI,GAAG;EAEhC,IAAI,CAAC,OACH,OAAO;EAIT,IAAI,MAAM,WAAW,KAAA,KAAa,KAAK,IAAI,IAAI,MAAM,QAAQ;GAC3D,KAAK,MAAM,OAAO,GAAG;GACrB,OAAO;EACT;EAEA,OAAO;CACT;;;;;;;CAQA,OAAO,KAAiB;EACtB,OAAO,KAAK,MAAM,OAAO,GAAG;CAC9B;;;;CAKA,QAAc;EACZ,KAAK,MAAM,MAAM;CACnB;;;;;;CAOA,IAAI,OAAe;EACjB,OAAO,KAAK,MAAM;CACpB;;;;;;;;;CAUA,QAAgB;EACd,IAAI,KAAK,UAAU,GACjB,OAAO;EAGT,MAAM,MAAM,KAAK,IAAI;EACrB,IAAI,UAAU;EAEd,KAAK,MAAM,CAAC,KAAK,UAAU,KAAK,OAC9B,IAAI,MAAM,WAAW,KAAA,KAAa,MAAM,MAAM,QAAQ;GACpD,KAAK,MAAM,OAAO,GAAG;GACrB;EACF;EAGF,OAAO;CACT;;;;;;CAOA,QAAoB;EAClB,OAAO;GACL,MAAM,KAAK,MAAM;GACjB,SAAS,KAAK;GACd,OAAO,KAAK;EACd;CACF;AACF;;;;;;;;;;;;;;;;AA6BA,SAAgB,eAAe,MAAyB;CACtD,IAAI;EACF,OAAO,KAAK,UAAU,IAAI;CAC5B,QAAQ;EAEN,OAAO,KAAK,KAAK,QAAQ,OAAO,GAAG,CAAC,CAAC,CAAC,KAAK,IAAI;CACjD;AACF;;;;;;;;;AAUA,IAAa,kBAAb,MAAgC;;EAEC,KAAA,QAAA,KAAA;EAGT,KAAA,cAAA;EAGoB,KAAA,eAAA;;;;;;;;;;;CAW1C,MAAM,IAAI,aAA2C;EAEnD,IAAI,KAAK,aACP,OAAO,KAAK;EAId,IAAI,KAAK,iBAAiB,MACxB,OAAO,KAAK;EAId,KAAK,gBAAgB,YAAY;GAC/B,IAAI;IACF,KAAK,QAAQ,MAAM,YAAY;IAC/B,KAAK,cAAc;IACnB,OAAO,KAAK;GACd,UAAU;IACR,KAAK,eAAe;GACtB;EACF,EAAA,CAAG;EAEH,OAAO,KAAK;CACd;;;;;;CAOA,QAAc;EACZ,KAAK,QAAQ,KAAA;EACb,KAAK,cAAc;EACnB,KAAK,eAAe;CACtB;;;;;;CAOA,gBAAyB;EACvB,OAAO,KAAK;CACd;AACF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AC5QA,SAAgB,QAAQ,eAAuB,KAAK;CAElD,MAAM,WAAW,IAAI,SAA0B;EAC7C,SAAS;EACT,OAAO;CACT,CAAC;CAED,OAAO,uBAAuB,mBAAmB;EAC/C,MAAM,gBAAgB,eAEpB,GAAG,MACe;GAClB,MAAM,MAAM,eAAe,IAAI;GAG/B,IAAI,SAAS,IAAI,GAAG,GAClB,OAAO,SAAS,IAAI,GAAG;GAIzB,MAAM,SAAS,MAAM,eAAe,MAAM,MAAM,IAAI;GACpD,SAAS,IAAI,KAAK,MAAM;GACxB,OAAO;EACT;EAGA,MAAM,kBAAkB;EAExB,gBAAgB,mBAAmB,SAAS,MAAM;EAClD,gBAAgB,uBAAuB;GACrC,MAAM,SAAS;GACf,SAAS;EACX;EAEA,OAAO;CACT,CAAC;AACH;;;;;;;;;;;;;;;;;;;;;;;;;;AA2BA,SAAgB,MAAM,QAAgB,KAAO,UAAkB,KAAK;CAElE,MAAM,WAAW,IAAI,SAA0B;EAC7C;EACA;CACF,CAAC;CAED,OAAO,uBAAuB,mBAAmB;EAC/C,MAAM,gBAAgB,eAEpB,GAAG,MACe;GAClB,MAAM,MAAM,eAAe,IAAI;GAG/B,MAAM,SAAS,SAAS,IAAI,GAAG;GAC/B,IAAI,WAAW,KAAA,GACb,OAAO;GAIT,MAAM,SAAS,MAAM,eAAe,MAAM,MAAM,IAAI;GACpD,SAAS,IAAI,KAAK,MAAM;GACxB,OAAO;EACT;EAGA,MAAM,kBAAkB;EAExB,gBAAgB,mBAAmB,SAAS,MAAM;EAClD,gBAAgB,uBAAuB;GACrC,MAAM,SAAS;GACf;EACF;EAEA,OAAO;CACT,CAAC;AACH;;;;;;;;;;;;;;;;;;;;;;;;;;AA2BA,SAAgB,OAAO;CAErB,MAAM,cAAc,IAAI,gBAAyB;CAEjD,OAAO,uBAAuB,mBAAmB;EAC/C,MAAM,gBAAgB,eAEpB,GAAG,MACe;GAClB,OAAO,YAAY,UAAU,eAAe,MAAM,MAAM,IAAI,CAAC;EAC/D;EAGA,MAAM,aAAa;EACnB,WAAW,cAAc,YAAY,MAAM;EAC3C,WAAW,sBAAsB,YAAY,cAAc;EAE3D,OAAO;CACT,CAAC;AACH;;;;;;;;;;;;;;;AC5LA,SAAgB,MAAM,cAAsB,GAAG,YAAoB,KAAM;CACvE,OAAO,uBAAuB,mBAAmB;EAC/C,MAAM,gBAAgB,eAEpB,GAAG,MACe;GAClB,IAAI,4BAAmB,IAAI,MAAM,sBAAsB;GAEvD,KAAK,IAAI,UAAU,GAAG,WAAW,aAAa,WAC5C,IAAI;IACF,OAAO,MAAM,eAAe,MAAM,MAAM,IAAI;GAC9C,SAAS,OAAO;IACd,YAAY,iBAAiB,QAAQ,QAAQ,IAAI,MAAM,OAAO,KAAK,CAAC;IAEpE,IAAI,YAAY,aACd,MAAM;IAIR,MAAM,QAAQ,YAAY,KAAK,IAAI,GAAG,UAAU,CAAC;IACjD,MAAM,IAAI,SAAS,YAAY,WAAW,SAAS,KAAK,CAAC;GAC3D;GAGF,MAAM;EACR;EAEA,OAAO;CACT,CAAC;AACH;;;;AAKA,SAAgB,UAAU,iBAAyB,IAAI;CACrD,MAAM,QAKD,CAAC;CACN,MAAM,WAAW,MAAO;CACxB,IAAI,WAAW;CACf,IAAI,aAAa;CAEjB,OAAO,uBAAuB,mBAAmB;EAC/C,eAAe,eAAe;GAC5B,IAAI,cAAc,MAAM,WAAW,GAAG;GACtC,aAAa;GAEb,OAAO,MAAM,SAAS,GAAG;IAEvB,MAAM,oBADM,KAAK,IACS,IAAM;IAEhC,IAAI,qBAAqB,UAAU;KACjC,MAAM,EAAE,SAAS,QAAQ,MAAM,YAAY,MAAM,MAAM;KACvD,WAAW,KAAK,IAAI;KAEpB,IAAI;MAEF,QAAQ,MADa,eAAe,MAAM,SAAS,IAAI,CACzC;KAChB,SAAS,OAAO;MACd,OAAO,iBAAiB,QAAQ,QAAQ,IAAI,MAAM,OAAO,KAAK,CAAC,CAAC;KAClE;IACF,OAEE,MAAM,IAAI,SAAS,YACjB,WAAW,SAAS,WAAW,iBAAiB,CAClD;GAEJ;GAEA,aAAa;EACf;EAEA,MAAM,gBAAgB,eAEpB,GAAG,MACe;GAClB,OAAO,IAAI,SAAS,SAAS,WAAW;IACtC,MAAM,KAAK;KAAE;KAAS;KAAQ;KAAM,SAAS;IAAK,CAAC;IACnD,aAAa;GACf,CAAC;EACH;EAEA,OAAO;CACT,CAAC;AACH;;;;;AAMA,SAAgB,QAAQ,KAAa,KAAM;CACzC,OAAO,uBAAuB,mBAAmB;EAC/C,MAAM,gBAAgB,eAEpB,GAAG,MACe;GAClB,OAAO,QAAQ,KAAK,CAClB,eAAe,MAAM,MAAM,IAAI,GAC/B,IAAI,SAAS,GAAG,WACd,iBACQ,uBAAO,IAAI,MAAM,6BAA6B,GAAG,GAAG,CAAC,GAC3D,EACF,CACF,CACF,CAAC;EACH;EAEA,OAAO;CACT,CAAC;AACH;;;;;AAMA,SAAgB,SAAS,KAAa,KAAK;CACzC,IAAI,YAAkD;CACtD,IAAI,iBAAoD;CACxD,IAAI,gBAAiD;CAErD,OAAO,uBAAuB,mBAAmB;EAC/C,MAAM,gBAAgB,eAEpB,GAAG,MACe;GAClB,OAAO,IAAI,SAAS,SAAS,WAAW;IAEtC,IAAI,WAAW;KACb,aAAa,SAAS;KACtB,IAAI,eACF,8BAAc,IAAI,MAAM,mCAAmC,CAAC;IAEhE;IAEA,iBAAiB;IACjB,gBAAgB;IAEhB,YAAY,WAAW,YAAY;KACjC,IAAI;MACF,MAAM,SAAS,MAAM,eAAe,MAAM,MAAM,IAAI;MACpD,IAAI,gBACF,eAAe,MAAM;KAEzB,SAAS,OAAO;MACd,IAAI,eACF,cACE,iBAAiB,QAAQ,QAAQ,IAAI,MAAM,OAAO,KAAK,CAAC,CAC1D;KAEJ,UAAU;MACR,YAAY;MACZ,iBAAiB;MACjB,gBAAgB;KAClB;IACF,GAAG,EAAE;GACP,CAAC;EACH;EAEA,OAAO;CACT,CAAC;AACH;;;;;AAMA,SAAgB,SAAS,KAAa,KAAK;CACzC,IAAI,WAAW;CACf,IAAI,aAAsB,KAAA;CAE1B,OAAO,uBAAuB,mBAAmB;EAC/C,MAAM,gBAAgB,eAEpB,GAAG,MACe;GAClB,MAAM,MAAM,KAAK,IAAI;GAErB,IAAI,MAAM,YAAY,IAAI;IACxB,WAAW;IACX,aAAa,MAAM,eAAe,MAAM,MAAM,IAAI;GACpD;GAEA,OAAO;EACT;EAEA,OAAO;CACT,CAAC;AACH;;;;;;;;;;;;;;;;;AAkBA,SAAgB,WAAW,gBAAwB,GAAG;CACpD,IAAI,eAAe;CACnB,MAAM,QAGD,CAAC;CAEN,MAAM,gBAAgB;EACpB,IAAI,MAAM,SAAS,KAAK,eAAe,eAAe;GACpD;GACA,MAAM,EAAE,YAAY,MAAM,MAAM;GAChC,QAAQ;EACV;CACF;CAEA,OAAO,uBAAuB,mBAAmB;EAC/C,MAAM,gBAAgB,eAEpB,GAAG,MACe;GAElB,IAAI,gBAAgB,eAClB,MAAM,IAAI,SAAe,SAAS,WAAW;IAC3C,MAAM,KAAK;KAAE;KAAS;IAAO,CAAC;GAChC,CAAC;QAED;GAGF,IAAI;IACF,OAAO,MAAM,eAAe,MAAM,MAAM,IAAI;GAC9C,UAAU;IACR;IACA,QAAQ;GACV;EACF;EAEA,OAAO;CACT,CAAC;AACH;;;;;;;;;;;;;;;;;AAmCA,SAAgB,eAAe,UAAiC,CAAC,GAAG;CAClE,MAAM,EACJ,mBAAmB,GACnB,eAAe,KACf,mBAAmB,MACjB;CAEJ,IAAI,WAAW;CACf,IAAI,kBAAkB;CACtB,IAAI,QAAsB;CAC1B,IAAI,mBAAmB;CAEvB,OAAO,uBAAuB,gBAAgB,eAAe;EAC3D,MAAM,gBAAgB,eAEpB,GAAG,MACe;GAClB,MAAM,MAAM,KAAK,IAAI;GAGrB,IAAI,UAAU,UAAU,MAAM,mBAAmB,cAAc;IAC7D,QAAQ;IACR,mBAAmB;GACrB;GAGA,IAAI,UAAU,QACZ,MAAM,IAAI,MACR,+BAA+B,WAAW,mBAC5C;GAIF,IAAI,UAAU,eAAe,oBAAoB,kBAC/C,MAAM,IAAI,MACR,oCAAoC,WAAW,0BACjD;GAGF,IAAI,UAAU,aACZ;GAGF,IAAI;IACF,MAAM,SAAS,MAAM,eAAe,MAAM,MAAM,IAAI;IAGpD,IAAI,UAAU,aACZ,QAAQ;IAEV,WAAW;IAEX,OAAO;GACT,SAAS,OAAO;IACd;IACA,kBAAkB;IAElB,IAAI,UAAU,eAAe,YAAY,kBAAkB;KACzD,QAAQ;KACR,QAAQ,KACN,8BAA8B,WAAW,SAAS,SAAS,UAC7D;IACF;IAEA,MAAM;GACR;EACF;EAGA,cAAqD,iBAAiB;EAGtE,cAA0C,cAAc;GACtD,QAAQ;GACR,WAAW;GACX,mBAAmB;EACrB;EAEA,OAAO;CACT,CAAC;AACH;;;;;;;;;;;;;;;AC1WA,SAAgB,OACd,UAA2E,CAAC,GAC5E;CACA,MAAM,EAAE,UAAU,MAAM,YAAY,MAAM,YAAY,SAAS;CAE/D,OAAO,gCACJ,gBAAgB,YAAY,cAAc;EACzC,MAAM,gBAAgB,eAEpB,GAAG,MACe;GAClB,MAAM,YAAY,KAAK,IAAI;GAC3B,MAAM,UAAU,UAAU,eAAe,KAAK,UAAU,IAAI,MAAM;GAElE,QAAQ,IAAI,IAAI,UAAU,GAAG,WAAW,YAAY,SAAS;GAE7D,IAAI;IACF,MAAM,SAAS,MAAM,eAAe,MAAM,MAAM,IAAI;IACpD,MAAM,WAAW,KAAK,IAAI,IAAI;IAC9B,MAAM,YAAY,YAAY,OAAO,SAAS,MAAM;IACpD,MAAM,YAAY,YACd,YAAY,KAAK,UAAU,MAAM,MACjC;IAEJ,QAAQ,IACN,IAAI,UAAU,GAAG,WAAW,aAAa,UAAU,GAAG,WACxD;IAEA,OAAO;GACT,SAAS,OAAO;IACd,MAAM,WAAW,KAAK,IAAI,IAAI;IAC9B,MAAM,YAAY,YAAY,UAAU,SAAS,MAAM;IACvD,QAAQ,MACN,IAAI,UAAU,GAAG,WAAW,UAAU,UAAU,IAChD,KACF;IACA,MAAM;GACR;EACF;EAEA,OAAO;CACT,CACF;AACF;;;;;;;;;;;;;;;;AA8BA,SAAgB,UAAU;CACxB,MAAM,UAAoB,CAAC;CAE3B,OAAO,uBAAuB,mBAAmB;EAC/C,MAAM,gBAAgB,eAEpB,GAAG,MACe;GAClB,MAAM,QAAQ,YAAY,IAAI;GAE9B,IAAI;IACF,OAAO,MAAM,eAAe,MAAM,MAAM,IAAI;GAC9C,UAAU;IACR,MAAM,WAAW,YAAY,IAAI,IAAI;IACrC,QAAQ,KAAK,QAAQ;IAGrB,IAAI,QAAQ,SAAS,KACnB,QAAQ,MAAM;GAElB;EACF;EAGA,cAAyD,iBAAiB;GACxE,IAAI,QAAQ,WAAW,GACrB,OAAO;IACL,OAAO;IACP,KAAK;IACL,KAAK;IACL,KAAK;IACL,QAAQ;IACR,KAAK;IACL,KAAK;GACP;GAGF,MAAM,SAAS,CAAC,GAAG,OAAO,CAAC,CAAC,MAAM,GAAG,MAAM,IAAI,CAAC;GAChD,MAAM,MAAM,OAAO,QAAQ,GAAG,MAAM,IAAI,GAAG,CAAC;GAE5C,OAAO;IACL,OAAO,OAAO;IACd,KAAK,OAAO;IACZ,KAAK,OAAO,OAAO,SAAS;IAC5B,KAAK,MAAM,OAAO;IAClB,QAAQ,OAAO,KAAK,MAAM,OAAO,SAAS,CAAC;IAC3C,KAAK,OAAO,KAAK,MAAM,OAAO,SAAS,GAAI;IAC3C,KAAK,OAAO,KAAK,MAAM,OAAO,SAAS,GAAI;GAC7C;EACF;EAGA,cAA+C,mBAAmB;GAChE,QAAQ,SAAS;EACnB;EAEA,OAAO;CACT,CAAC;AACH;;;;;;;;;;;;;;;;;;;;AA0BA,SAAgB,SAAS,YAA2B;CAClD,OAAO,uBAAuB,gBAAgB,eAAe;EAC3D,MAAM,gBAAgB,eAEpB,GAAG,MACe;GAClB,KAAK,IAAI,IAAI,GAAG,IAAI,WAAW,QAAQ,KAAK;IAC1C,IAAI,KAAK,KAAK,QAAQ;IAEtB,MAAM,SAAS,WAAW,EAAE,CAAC,KAAK,EAAE;IACpC,IAAI,WAAW,OACb,MAAM,IAAI,MACR,kCAAkC,EAAE,MAAM,YAC5C;IAEF,IAAI,OAAO,WAAW,UACpB,MAAM,IAAI,MAAM,MAAM;GAE1B;GAEA,OAAO,eAAe,MAAM,MAAM,IAAI;EACxC;EAEA,OAAO;CACT,CAAC;AACH;;;;;;;;;;;ACtLA,SAAgB,kBAAkB,IAAkC;CAClE,IAAI,OAAO,OAAO,YAChB,MAAM,IAAI,mBAAmB,0BAA0B;CAGzD,MAAM,WAAW,GAAG,SAAS;CAG7B,IAAI,SAAS,SAAS,IAAI,KAAK,SAAS,WAAW,UAAU,GAC3D,OAAO;CAIT,IAAI,SAAS,SAAS,GAAG,KAAK,SAAS,SAAS,GAAG,GACjD,OAAO,YAAY;CAGrB,MAAM,IAAI,mBAAmB,8BAA8B;AAC7D;;;;AAKA,SAAgB,oBAAoB,UAAwC;CAC1E,IAAI;EAEF,OAAO,IAAI,SAAS,aAAa,WAAW,GAAG,CAAC,CAAC;CACnD,SAAS,OAAO;EACd,MAAM,IAAI,mBACR,kCACA,KACF;CACF;AACF;;;;AAKA,SAAgB,cAAc,MAG5B;CACA,MAAM,gBAAgC,CAAC;CAEvC,IAAI;EAEF,MAAM,YAAY,qBAAqB,MAAM,aAAa;EAE1D,OAAO;GACL,YAAY,KAAK,UAAU,SAAS;GACpC;EACF;CACF,SAAS,OAAO;EACd,MAAM,IAAI,mBAAmB,4BAA4B,KAAc;CACzE;AACF;;;;AAKA,SAAgB,gBAAgB,YAA6B;CAC3D,IAAI;EACF,OAAO,KAAK,MAAM,UAAU;CAC9B,SAAS,OAAO;EACd,MAAM,IAAI,mBAAmB,8BAA8B,KAAc;CAC3E;AACF;;;;AAKA,SAAS,qBACP,KACA,eACS;CACT,IAAI,QAAQ,QAAQ,OAAO,QAAQ,UACjC,OAAO;CAIT,IAAI,eAAe,aAAa;EAC9B,cAAc,KAAK,GAAG;EACtB,OAAO;GAAE,QAAQ;GAAe,QAAQ;EAAI;CAC9C;CAGA,IAAI,YAAY,OAAO,GAAG,GAAG;EAC3B,MAAM,aAAa;EACnB,MAAM,SAAS,WAAW,OAAO,MAC/B,WAAW,YACX,WAAW,aAAa,WAAW,UACrC;EACA,cAAc,KAAK,MAAM;EACzB,OAAO;GACL,QAAQ,WAAW,YAAY;GAC/B,QAAQ;GACR,cAAc,WAAW;GACzB,UAAU,WAAW;EACvB;CACF;CAGA,IAAI,OAAO,gBAAgB,eAAe,eAAe,aAAa;EACpE,cAAc,KAAK,GAAG;EACtB,OAAO;GAAE,QAAQ;GAAe,QAAQ;EAAI;CAC9C;CAGA,IACE,OAAO,oBAAoB,eAC3B,eAAe,iBACf;EACA,cAAc,KAAK,GAAG;EACtB,OAAO;GAAE,QAAQ;GAAmB,QAAQ;EAAI;CAClD;CAGA,IAAI,OAAO,gBAAgB,eAAe,eAAe,aAAa;EACpE,cAAc,KAAK,GAAG;EACtB,OAAO;GAAE,QAAQ;GAAe,QAAQ;EAAI;CAC9C;CAGA,IAAI,MAAM,QAAQ,GAAG,GACnB,OAAO,IAAI,KAAK,SAAS,qBAAqB,MAAM,aAAa,CAAC;CAIpE,MAAM,SAAkC,CAAC;CACzC,KAAK,MAAM,CAAC,KAAK,UAAU,OAAO,QAAQ,GAAG,GAC3C,OAAO,OAAO,qBAAqB,OAAO,aAAa;CAGzD,OAAO;AACT;;;;AAKA,SAAgB,qBAAqB,KAAuB;CAC1D,IAAI,QAAQ,QAAQ,OAAO,QAAQ,UACjC,OAAO;CAGT,MAAM,WAAW;CAGjB,IAAI,SAAS,QACX,QAAQ,SAAS,QAAjB;EACE,KAAK,eACH,OAAO,SAAS;EAElB,KAAK,eACH,OAAO,SAAS;EAElB,KAAK,mBACH,OAAO,SAAS;EAElB,KAAK,eACH,OAAO,SAAS;EAGlB,KAAK;EACL,KAAK;EACL,KAAK;EACL,KAAK;EACL,KAAK;EACL,KAAK;EACL,KAAK;EACL,KAAK;EACL,KAAK;EACL,KAAK;EACL,KAAK,kBAAkB;GACrB,MAAM,wBAAyB,WAC7B,SAAS;GAEX,OAAO,IAAI,sBAAsB,SAAS,MAAqB;EACjE;CACF;CAIF,IAAI,MAAM,QAAQ,GAAG,GACnB,OAAO,IAAI,IAAI,oBAAoB;CAIrC,MAAM,SAAkC,CAAC;CACzC,KAAK,MAAM,CAAC,KAAK,UAAU,OAAO,QAAQ,GAAG,GAC3C,OAAO,OAAO,qBAAqB,KAAK;CAG1C,OAAO;AACT;;;;AAKA,SAAgB,iBAAiB,KAAuB;CACtD,IAAI,QAAQ,QAAQ,OAAO,QAAQ,UACjC,OAAO;CAIT,IACE,eAAe,eACf,YAAY,OAAO,GAAG,KACrB,OAAO,gBAAgB,eAAe,eAAe,eACrD,OAAO,oBAAoB,eAC1B,eAAe,mBAChB,OAAO,gBAAgB,eAAe,eAAe,aAEtD,OAAO;CAIT,IAAI,MAAM,QAAQ,GAAG,GACnB,OAAO,IAAI,KAAK,gBAAgB;CAGlC,OAAO,OAAO,OAAO,GAAG,CAAC,CAAC,KAAK,gBAAgB;AACjD;;;;AAKA,SAAgB,mBACd,IACA,MACA,UAAgC,CAAC,GACzB;CACR,MAAM,WAAW,kBAAkB,EAAE;CACrC,MAAM,EAAE,YAAY,eAAe,cAAc,IAAwB;CAEzE,OAAO;;;yBAGgB,gBAAgB,SAAS,EAAE;8BACtB,qBAAqB,SAAS,EAAE;uBACvC,cAAc,SAAS,EAAE;;;iBAG/B,SAAS;yDAC+B,WAAW;;MAG9D,QAAQ,UACJ;;wDAE8C,QAAQ,QAAQ;SAC/D,QAAQ,QAAQ;QAEf,GACL;;;;;;;QAOG,QAAQ,UAAU,6BAA6B,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;QA2BlD,QAAQ,UAAU,6BAA6B,GAAG;;;;;;;AAO1D;AAGA,IAAa,qBAAb,MAAgC,CAQhC;;AAP6B,oBAAA,oBAAA;AACE,oBAAA,sBAAA;AACN,oBAAA,gBAAA;AACE,oBAAA,kBAAA;AACK,oBAAA,uBAAA;AACJ,oBAAA,mBAAA;AACE,oBAAA,qBAAA;;;;;;;;;;;;;;;ACxQ9B,IAAI,kBAAkB;;;;;;;;;AAUtB,SAAS,iBAAiB,UAA4B;CAEpD,mBAAmB,kBAAkB,KAAK,OAAO;CAIjD,OAAO,GAAG,SAAS,UAAU,gBAAQ,GAFnB,KAAK,IAAI,CAAC,CAAC,SAAS,EAEE,EAAU,GADnC,KAAK,OAAO,CAAC,CAAC,SAAS,EAAE,CAAC,CAAC,UAAU,GAAG,CACF;AACvD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAiCA,IAAsB,yBAAtB,MAAuE;;;;;;;CAsBrE,YACE,UACA,SAA2B,CAAC,GAC5B;EAFmB,KAAA,WAAA;EAlBI,KAAA,eAAA;EAGD,KAAA,cAAA;EAG+B,KAAA,mBAAA,CAAC;EAgBtD,KAAK,KAAK,iBAAiB,QAAQ;EAGnC,KAAK,SAAS;GACZ,aAAa,OAAO,eAAe;GACnC,oBAAoB,OAAO,sBAAsB;GACjD,cAAc,OAAO,gBAAgB;EACvC;CACF;;;;;;;;;;;;;;;;;CAkBA,MAAM,QACJ,IACA,MACA,UAAyB,CAAC,GACA;EAE1B,KAAK,cAAc;EAEnB,KAAK,cAAc;EACnB,MAAM,YAAY,oBAAoB;EAEtC,IAAI;GAEF,MAAM,eAAe,mBAAmB,IAAI,MAAM,EAChD,SAAS,QAAQ,QACnB,CAAC;GAGD,MAAM,SAAS,MAAM,KAAK,oBACxB,cACA,MACA,SACA,SACF;GAGA,KAAK,cAAc,WAAW,IAAI;GAElC,OAAO;EACT,SAAS,OAAO;GAEd,KAAK,cACH,WACA,OACA,iBAAiB,QAAQ,MAAM,UAAU,OAAO,KAAK,CACvD;GAGA,IAAI,KAAK,OAAO,oBACd,MAAM,KAAK,eAAe;GAG5B,MAAM;EACR,UAAU;GACR,KAAK,cAAc;EACrB;CACF;;;;;;;CAQA,MAAM,YAA2B;EAC/B,IAAI,KAAK,cACP;EAIF,MAAM,KAAK,sBAAsB;EAEjC,KAAK,eAAe;EACpB,KAAK,mBAAmB,CAAC;CAC3B;;;;;;CAOA,SAAkB;EAChB,OAAO,CAAC,KAAK,eAAe,CAAC,KAAK;CACpC;;;;;;;;CASA,oBAAoB,QAAQ,IAA8B;EACxD,OAAO,KAAK,iBAAiB,MAAM,CAAC,KAAK;CAC3C;;;;;;CAOA,0BAAkC;EAChC,IAAI,KAAK,iBAAiB,WAAW,GACnC,OAAO;EAQT,OALsB,KAAK,iBAAiB,QACzC,KAAK,WAAW,MAAM,OAAO,UAC9B,CAGK,IAAgB,KAAK,iBAAiB;CAC/C;;;;;;CAOA,iBAAyB;EACvB,IAAI,KAAK,iBAAiB,WAAW,GACnC,OAAO;EAIT,OADqB,KAAK,iBAAiB,QAAQ,MAAM,EAAE,OAAO,CAAC,CAAC,SAC9C,KAAK,iBAAiB;CAC9C;;;;;;CAWA,gBAAgC;EAC9B,IAAI,KAAK,cACP,MAAM,IAAI,YAAY,4BAA4B;EAGpD,IAAI,KAAK,aACP,MAAM,IAAI,YAAY,oCAAoC;CAE9D;;;;;;;;;;;;CAaA,MAAgB,oBACd,cACA,MACA,SACA,WAC0B;EAE1B,MAAM,mBAAmB,KAAK,yBAC5B,cACA,MACA,SACA,SACF;EAGA,MAAM,eAAe,QAAQ,SACzB,KAAK,mBAAsB,QAAQ,MAAM,IACzC;EAGJ,MAAM,iBAAiB,QAAQ,UAC3B,KAAK,qBAAwB,QAAQ,OAAO,IAC5C;EAGJ,MAAM,WAAuC,CAAC,gBAAgB;EAC9D,IAAI,cAAc,SAAS,KAAK,YAAY;EAC5C,IAAI,gBAAgB,SAAS,KAAK,cAAc;EAEhD,OAAO,QAAQ,KAAK,QAAQ;CAC9B;;;;;;;;CASA,mBACE,QAC0B;EAC1B,OAAO,IAAI,SAA0B,GAAG,WAAW;GACjD,IAAI,OAAO,SAAS;IAClB,OAAO,IAAI,YAAY,uBAAuB,CAAC;IAC/C;GACF;GAEA,MAAM,gBAAgB;IACpB,OAAO,oBAAoB,SAAS,OAAO;IAC3C,OAAO,IAAI,YAAY,uBAAuB,CAAC;GACjD;GAEA,OAAO,iBAAiB,SAAS,SAAS,EAAE,MAAM,KAAK,CAAC;EAC1D,CAAC;CACH;;;;;;;;CASA,qBAAkC,SAA2C;EAC3E,OAAO,IAAI,SAA0B,GAAG,WAAW;GACjD,iBAAiB;IACf,OAAO,IAAI,YAAY,6BAA6B,QAAQ,GAAG,CAAC;GAClE,GAAG,OAAO;EACZ,CAAC;CACH;;;;;;;;CASA,cACE,WACA,SACA,cACM;EACN,IAAI,CAAC,KAAK,OAAO,cACf;EAGF,MAAM,UAAU,oBAAoB;EACpC,MAAM,UAAkC;GACtC;GACA;GACA,UAAU,UAAU;GACpB;GACA;EACF;EAEA,KAAK,iBAAiB,KAAK,OAAO;EAGlC,IAAI,KAAK,iBAAiB,SAAS,KACjC,KAAK,mBAAmB,KAAK,iBAAiB,MAAM,IAAI;CAE5D;;;;;CAMA,MAAgB,iBAAgC;EAG9C,IAAI;GACF,MAAM,KAAK,sBAAsB;EACnC,QAAQ,CAER;CACF;AA+BF;;;;;;;;;;AAWA,IAAsB,wBAAtB,MAAqE;;;;;;CAiBnE,MAAM,gBAAgB,QAAuC;EAC3D,MAAM,OAAO,UAAU;CACzB;;;;;;;;CAgBA,4BAAoC;EAElC,OAAO,sBAAsB;CAC/B;AACF;;;;;;;;;;AAWA,SAAgB,yBACd,WACA,UACA,eACQ;CACR,IAAI,UAAU,IAAI,SAAS,WAAW,UAAU;CAEhD,IAAI,eACF,WAAW,KAAK,cAAc;CAGhC,OAAO;AACT;;;;;;;AAQA,SAAgB,iBAAiB,KAAqC;CACpE,IAAI,OAAO,QAAQ,YAAY,QAAQ,MACrC,OAAO;CAGT,MAAM,SAAS;CACf,OACE,OAAO,OAAO,OAAO,YACrB,OAAO,OAAO,YAAY,cAC1B,OAAO,OAAO,cAAc,cAC5B,OAAO,OAAO,WAAW;AAE7B;;;;;;;;;;;;;;;;;;;;;;;;;;;AA6CA,IAAsB,4BAAtB,cAAwD,uBAAuB;;;;;;;CAgB7E,YAAY,UAAoB,SAA0B,CAAC,GAAG;EAC5D,MAAM,UAAU,MAAM;EAfU,KAAA,SAAA;EAGG,KAAA,YAAA;EAanC,KAAK,YAAY;GACf,GAAG,KAAK;GACR,YAAY,OAAO,cAAc,KAAK;GACtC,YAAY,OAAO,cAAc;EACnC;CACF;;;;;;;;;;;;;;;CAgBA,MAAgB,yBACd,cACA,MACA,SACA,WAC0B;EAE1B,MAAM,OAAO,IAAI,KAAK,CAAC,YAAY,GAAG,EAAE,MAAM,yBAAyB,CAAC;EACxE,KAAK,YAAY,IAAI,gBAAgB,IAAI;EAEzC,OAAO,IAAI,SAA0B,SAAS,WAAW;GACvD,IAAI;GACJ,IAAI,aAAa;;;;;GAMjB,MAAM,eAAe,WAA4B;IAC/C,IAAI,YAAY;IAChB,aAAa;IACb,KAAK,iBAAiB,SAAS;IAC/B,QAAQ,MAAM;GAChB;;;;;GAMA,MAAM,cAAc,UAAiB;IACnC,IAAI,YAAY;IAChB,aAAa;IACb,KAAK,iBAAiB,SAAS;IAC/B,OAAO,KAAK;GACd;GAGA,IAAI;IACF,MAAM,gBAAgB,KAAK,4BAA4B;IACvD,KAAK,SAAS,IAAI,OAAO,KAAK,WAAY,aAAa;GACzD,SAAS,OAAO;IACd,WACE,IAAI,YACF,4BAA4B,iBAAiB,QAAQ,MAAM,UAAU,OAAO,KAAK,GACnF,CACF;IACA;GACF;GAGA,IAAI,QAAQ,QAAQ;IAClB,MAAM,gBAAgB;KACpB,WAAW,IAAI,YAAY,uBAAuB,CAAC;IACrD;IACA,QAAQ,OAAO,iBAAiB,SAAS,SAAS,EAAE,MAAM,KAAK,CAAC;GAClE;GAGA,IAAI,QAAQ,SACV,YAAY,iBAAiB;IAC3B,WACE,IAAI,YAAY,6BAA6B,QAAQ,QAAQ,GAAG,CAClE;GACF,GAAG,QAAQ,OAAO;GAIpB,KAAK,OAAO,aAAa,UAAwB;IAC/C,MAAM,EAAE,QAAQ,OAAO,kBAAkB,MAAM;IAM/C,IAAI,OACF,WAAW,IAAI,YAAY,KAAK,CAAC;SAEjC,YAAY;KACV;KACA,eAAe,iBAAiB,oBAAoB,IAAI;KACxD,UAAU,KAAK;IACjB,CAAC;GAEL;GAGA,KAAK,OAAO,WAAW,UAAsB;IAC3C,WAAW,IAAI,YAAY,iBAAiB,MAAM,SAAS,CAAC;GAC9D;GAGA,IAAI,oBAAoB,KAAK,QAC3B,KAAK,OAAO,kBAAkB,UAAwB;IACpD,WACE,IAAI,YAAY,gCAAgC,MAAM,MAAM,CAC9D;GACF;GAIF,KAAK,oBAAoB,MAAM,QAAQ,YAAY;EACrD,CAAC;CACH;;;;;;;;;;CAsBA,oBACE,MACA,cACM;EACN,IAAI,CAAC,KAAK,QACR,MAAM,IAAI,YAAY,wBAAwB;EAGhD,IAAI,gBAAgB,aAAa,SAAS,GACxC,KAAK,OAAO,YAAY,MAAM,YAAY;OAE1C,KAAK,OAAO,YAAY,IAAI;CAEhC;;;;;;CAOA,iBAA2B,WAAiD;EAE1E,IAAI,KAAK,QAAQ;GACf,KAAK,OAAO,UAAU;GACtB,KAAK,SAAS;EAChB;EAGA,IAAI,WACF,aAAa,SAAS;EAIxB,IAAI,KAAK,WAAW;GAClB,IAAI,gBAAgB,KAAK,SAAS;GAClC,KAAK,YAAY;EACnB;CACF;;;;;;CAOA,MAAgB,wBAAuC;EACrD,KAAK,iBAAiB;CACxB;AACF;;;;;;;;;;;;;;;;;;;;;;AClwBA,IAAa,uBAAb,cAA0C,sBAAsB;;;EAC1C,KAAA,WAAA;;CAEpB,MAAM,aAAa,QAAyC;EAC1D,OAAO,IAAI,sBAAsB,MAAM;CACzC;CAEA,cAAuB;EACrB,IAAI;GAEF,IACE,OAAO,WAAW,eAClB,OAAO,SAAS,eAChB,OAAO,QAAQ,aAEf,OAAO;GAKT,IAAI;IACF,MAAM,WAAW,IAAI,KAAK,CAAC,EAAE,GAAG,EAAE,MAAM,yBAAyB,CAAC;IAClE,MAAM,UAAU,IAAI,gBAAgB,QAAQ;IAC5C,IAAI,gBAAgB,OAAO;IAC3B,OAAO;GACT,SAAS,OAAO;IACd,QAAQ,KAAK,gCAAgC,KAAK;IAClD,OAAO;GACT;EACF,SAAS,OAAO;GACd,QAAQ,KAAK,oCAAoC,KAAK;GACtD,OAAO;EACT;CACF;AACF;;;;;;;;;AAUA,IAAM,wBAAN,cAAoC,0BAA0B;;;;;;CAM5D,YAAY,SAAiB;EAC3B,MAAM,WAAW;GACf,YAAY,KAAA;GACZ,YAAY;EACd,CAAC;CACH;;;;;;;;;CAUA,8BAAuD;EACrD,OAAO;GACL,MAAM,KAAK,UAAU;GACrB,MAAM,KAAK,UAAU;EACvB;CACF;AACF;;;;;;;;;;;;;;;;;;;;;ACOA,IAAa,mBAAb,cAAsC,sBAAsB;;;EACtC,KAAA,WAAA;;CAEpB,MAAM,aAAa,QAAyC;EAC1D,OAAO,IAAI,kBAAkB,MAAM;CACrC;CAEA,cAAuB;EACrB,OACE,OAAQ,WAAoC,QAAQ,eACpD,OAAO,WAAW;CAEtB;;;;;;;;;;;;CAaA,gBAA+B;EAE7B,OADa,WAAoC,KACrC,WAAW;CACzB;;;;;;CAOA,iBAAgC;EAE9B,OADa,WAAoC,KACrC,YAAY;CAC1B;;;;;;;;;;;;;;CAeA,GAAG,QAAQ,OAAa;EACtB,MAAM,MAAO,WAAoC;EACjD,IAAI,KAAK,IACP,IAAI,GAAG,KAAK;CAEhB;;;;;;;;;;;;;;;;CAiBA,cAAsB;EAEpB,OADa,WAAoC,KACrC,YAAY,KAAK,KAAK,IAAI,IAAI;CAC5C;AACF;;;;;;;;;;;AAYA,IAAM,oBAAN,cAAgC,0BAA0B;;;;;;CAMxD,YAAY,SAAiB;EAC3B,MAAM,OAAO;GACX,YAAY,KAAA;GACZ,YAAY;EACd,CAAC;CACH;;;;;;;;;;CAWA,8BAA0D;EACxD,OAAO;GACL,MAAM;GACN,MAAM,KAAK;GACX,aAAa;EACf;CACF;;;;;;;;;;;;CAaA,gBAKE;EACA,MAAM,MAAO,WAAoC;EACjD,OAAO;GACL,IAAI,KAAK;GACT,YAAY,KAAK,WAAW;GAC5B,aAAa,KAAK,YAAY;GAC9B,cAAc;IACZ;IACA;IACA;IACA;IACA;GACF;EACF;CACF;;;;;;CAOA,UAAgB;EACd,MAAM,MAAO,WAAoC;EACjD,IAAI,KAAK,IACP,IAAI,GAAG,IAAI;CAEf;;;;;;;;CASA,uBAA+B;EAE7B,OADa,WAAoC,KACrC,YAAY,KAAK,YAAY,IAAI,IAAI;CACnD;AACF;;;;;;;;;;;;;;;;;;;;ACxLA,IAAa,oBAAb,cAAuC,sBAAsB;;;EACvC,KAAA,WAAA;;CAEpB,MAAM,aAAa,QAAyC;EAC1D,OAAO,IAAI,mBAAmB,MAAM;CACtC;CAEA,cAAuB;EACrB,OACE,OAAQ,WAAmD,SACzD,eAAe,OAAO,WAAW;CAEvC;;;;;;;;;;;;CAaA,iBAAgC;EAE9B,OADc,WAAmD,MACpD,QAAQ,QAAQ;CAC/B;;;;;;;;;;;;;;;CAgBA,MAAM,gBACJ,MACA,YACkB;EAClB,MAAM,OAAQ,WAAmD;EACjE,IAAI,CAAC,MAAM,OAAO;EAElB,IAAI;GAIF,QAAO,MAHc,KAAK,YAAY,MACpC,cAAe,EAAE,KAAK,CACxB,EAAA,CACc,UAAU;EAC1B,QAAQ;GACN,OAAO;EACT;CACF;AACF;;;;;;;;;;;AAYA,IAAM,qBAAN,cAAiC,0BAA0B;;;;;;CAMzD,YAAY,SAAiB;EAC3B,MAAM,QAAQ;GACZ,YAAY,KAAA;GACZ,YAAY;EACd,CAAC;CACH;;;;;;;;;;;CAYA,8BAA2D;EACzD,OAAO;GACL,MAAM;GACN,MAAM,KAAK;GACX,MAAM;IACJ,aAAa;KAEX,KAAK;KACL,MAAM;KACN,OAAO;KACP,KAAK;KACL,KAAK;KACL,KAAK;KACL,QAAQ;KACR,KAAK;IACP;IACA,WAAW;GACb;EACF;CACF;;;;;;;;;;;;;CAcA,gBAIE;EACA,MAAM,OAAQ,WAAmD;EACjE,OAAO;GACL,IAAI,KAAK;GACT,aAAa,MAAM,QAAQ,QAAQ;GACnC,aAAa,CAAC,QAAQ;EACxB;CACF;;;;;;CAOA,aAAsB;EACpB,OACE,OAAQ,WAAmD,SAC3D;CAEJ;AACF;;;;CC9PA,OAAO,UAAU,CAAC;;;;;;AC8BlB,IAAa,oBAAb,MAAsD;CAWpD,YACE,SACA,SAAqB,CAAC,GACtB;EAFQ,KAAA,UAAA;EAX0B,KAAA,UAAA,CAAC;EACG,KAAA,cAAA,CAAC;EACE,KAAA,8BAAA,IAAI,IAAI;EACnB,KAAA,YAAA,CAAC;EACR,KAAA,iBAAA;EACI,KAAA,qBAAA;EACL,KAAA,gBAAA;EAQtB,MAAM,qBAAqB,sBAAsB;EAEjD,KAAK,SAAS;GACZ,YAAY,OAAO,cAAc;GACjC,YAAY,OAAO,cAAc;GACjC,aAAa,OAAO,eAAe;GACnC,WAAW,OAAO,aAAa;GAC/B,UAAU,OAAO,YAAY;EAC/B;EAGA,KAAK,kBAAkB,CAAC,CAAC,MAAM,QAAQ,KAAK;CAC9C;CAEA,MAAM,QACJ,IACA,MACA,UAAyB,CAAC,GACA;EAC1B,IAAI,KAAK,eAEP,OAAO;GACL,QAAQ,KAAA;GACR,eAAe;GACf,OAAO,IAAI,YAAY,qBAAqB;EAC9C;EAGF,OAAO,IAAI,SAA0B,SAAS,WAAW;GACvD,MAAM,WAAW,KAAK,YAAY,QAAQ,QAAQ;GAClD,MAAM,OAAiB;IACrB,IAAI,QAAQ,KAAK,IAAI,EAAE,GAAG,KAAK,OAAO,CAAC,CAAC,SAAS,EAAE,CAAC,CAAC,OAAO,GAAG,CAAC;IAChE;IACA;IACA;IACS;IACT;IACA;IACA,WAAW,KAAK,IAAI;GACtB;GAGA,IAAI,KAAK,UAAU,UAAU,KAAK,OAAO,WAAW;IAClD,OAAO,IAAI,YAAY,oBAAoB,CAAC;IAC5C;GACF;GAGA,KAAK,UAAU,KAAK,IAAI;GACxB,KAAK,UAAU,MAAM,GAAG,MAAM,EAAE,WAAW,EAAE,QAAQ;GAGrD,KAAK,aAAa,CAAC,CAAC,MAAM,MAAM;EAClC,CAAC;CACH;CAEA,MAAM,OAAO,MAA6B;EACxC,IAAI,OAAO,KAAK,OAAO,YACrB,OAAO,KAAK,OAAO;EAGrB,IAAI,OAAO,KAAK,OAAO,YACrB,OAAO,KAAK,OAAO;EAGrB,MAAM,cAAc,KAAK,QAAQ;EAEjC,IAAI,OAAO,aAAa;GAEtB,MAAM,eAAe,OAAO;GAC5B,MAAM,aAAa,MAAM,QAAQ,IAC/B,MAAM,YAAY,CAAC,CAChB,KAAK,IAAI,CAAC,CACV,UAAU,KAAK,QAAQ,aAAa,EAAE,CAAC,CAC5C;GAEA,KAAK,QAAQ,KAAK,GAAG,UAAU;GAC/B,KAAK,YAAY,KAAK,GAAG,UAAU;EACrC,OAAO,IAAI,OAAO,aAAa;GAE7B,MAAM,kBAAkB,cAAc;GACtC,MAAM,qBAAqB,KAAK,YAAY,OAAO,GAAG,eAAe;GAErE,KAAK,MAAM,UAAU,oBAAoB;IACvC,MAAM,KAAK,QAAQ,gBAAgB,MAAM;IACzC,MAAM,QAAQ,KAAK,QAAQ,QAAQ,MAAM;IACzC,IAAI,UAAU,IACZ,KAAK,QAAQ,OAAO,OAAO,CAAC;GAEhC;EACF;CACF;CAEA,MAAM,YAA2B;EAC/B,KAAK,gBAAgB;EAGrB,KAAK,MAAM,QAAQ,KAAK,WACtB,KAAK,QAAQ;GACX,QAAQ,KAAA;GACR,eAAe;GACf,OAAO,IAAI,YAAY,qBAAqB;EAC9C,CAAC;EAEH,KAAK,YAAY,CAAC;EAGlB,MAAM,qBAAqB,MAAM,KAAK,KAAK,WAAW,CAAC,CAAC,KACrD,WACC,IAAI,SAAe,YAAY;GAE7B,MAAM,UAAU,iBAAiB,QAAQ,GAAG,GAAI;GAGhD,MAAM,YAAY,kBAAkB;IAClC,IAAI,OAAO,OAAO,GAAG;KACnB,aAAa,OAAO;KACpB,cAAc,SAAS;KACvB,QAAQ;IACV;GACF,GAAG,GAAG;EACR,CAAC,CACL;EAEA,MAAM,QAAQ,IAAI,kBAAkB;EAGpC,MAAM,QAAQ,IACZ,KAAK,QAAQ,KAAK,WAAW,KAAK,QAAQ,gBAAgB,MAAM,CAAC,CACnE;EAEA,KAAK,UAAU,CAAC;EAChB,KAAK,cAAc,CAAC;EACpB,KAAK,YAAY,MAAM;CACzB;CAEA,WAAsB;EACpB,OAAO;GACL,eAAe,KAAK,YAAY;GAChC,aAAa,KAAK,YAAY;GAC9B,aAAa,KAAK,UAAU;GAC5B,gBAAgB,KAAK;GACrB,sBACE,KAAK,iBAAiB,IAClB,KAAK,qBAAqB,KAAK,iBAC/B;EACR;CACF;CAEA,MAAc,oBAAmC;EAC/C,MAAM,UAAU,MAAM,QAAQ,IAC5B,MAAM,KAAK,OAAO,UAAU,CAAC,CAC1B,KAAK,IAAI,CAAC,CACV,UAAU,KAAK,QAAQ,aAAa,EAAE,CAAC,CAC5C;EAEA,KAAK,QAAQ,KAAK,GAAG,OAAO;EAC5B,KAAK,YAAY,KAAK,GAAG,OAAO;CAClC;CAEA,MAAc,eAA8B;EAC1C,OAAO,KAAK,UAAU,SAAS,KAAK,CAAC,KAAK,eAAe;GACvD,MAAM,SAAS,MAAM,KAAK,mBAAmB;GAC7C,IAAI,CAAC,QAAQ;GAEb,MAAM,OAAO,KAAK,UAAU,MAAM;GAClC,IAAI,CAAC,MAAM;GAGX,KAAK,YAAY,QAAQ,IAAI,CAAC,CAAC,OAAO,UAAU;IAC9C,KAAK,OAAO,KAAK;IACjB,KAAK,cAAc,MAAM;GAC3B,CAAC;EACH;CACF;CAEA,MAAc,qBAAqD;EAEjE,IAAI,KAAK,YAAY,SAAS,GAAG;GAC/B,MAAM,SAAS,KAAK,YAAY,MAAM;GACtC,KAAK,YAAY,IAAI,MAAM;GAC3B,OAAO;EACT;EAGA,IAAI,KAAK,QAAQ,SAAS,KAAK,OAAO,YACpC,IAAI;GACF,MAAM,SAAS,MAAM,KAAK,QAAQ,aAAa,EAAE;GACjD,KAAK,QAAQ,KAAK,MAAM;GACxB,KAAK,YAAY,IAAI,MAAM;GAC3B,OAAO;EACT,SAAS,OAAO;GACd,QAAQ,MAAM,gCAAgC,KAAK;EACrD;EAIF,OAAO;CACT;CAEA,MAAc,YACZ,QACA,MACe;EACf,IAAI;GACF,MAAM,SAAS,MAAM,OAAO,QAAQ,KAAK,IAAI,KAAK,MAAM,KAAK,OAAO;GAGpE,KAAK;GACL,KAAK,sBAAsB,OAAO;GAElC,KAAK,QAAQ,MAAM;EACrB,SAAS,OAAO;GACd,KAAK,OAAO,KAAc;EAC5B,UAAU;GACR,KAAK,cAAc,MAAM;GAGzB,IAAI,KAAK,UAAU,SAAS,GAC1B,KAAK,aAAa,CAAC,CAAC,MAAM,QAAQ,KAAK;EAE3C;CACF;CAEA,cAAsB,QAA8B;EAClD,KAAK,YAAY,OAAO,MAAM;EAE9B,IAAI,CAAC,KAAK,iBAAiB,OAAO,OAAO,GAAG;GAC1C,KAAK,YAAY,KAAK,MAAM;GAG5B,iBAAiB;IACf,KAAK,kBAAkB,MAAM;GAC/B,GAAG,KAAK,OAAO,WAAW;EAC5B,OAAO,IAAI,CAAC,KAAK,eAEf,iBAAiB;GACf,IAAI,OAAO,OAAO,KAAK,CAAC,KAAK,YAAY,IAAI,MAAM,GACjD,KAAK,YAAY,KAAK,MAAM;EAEhC,GAAG,EAAE;CAET;CAEA,MAAc,kBAAkB,QAAuC;EAErE,IACE,OAAO,OAAO,KACd,KAAK,YAAY,SAAS,MAAM,KAChC,KAAK,QAAQ,SAAS,KAAK,OAAO,YAClC;GACA,MAAM,YAAY,KAAK,YAAY,QAAQ,MAAM;GACjD,IAAI,cAAc,IAChB,KAAK,YAAY,OAAO,WAAW,CAAC;GAGtC,MAAM,cAAc,KAAK,QAAQ,QAAQ,MAAM;GAC/C,IAAI,gBAAgB,IAClB,KAAK,QAAQ,OAAO,aAAa,CAAC;GAGpC,MAAM,KAAK,QAAQ,gBAAgB,MAAM;EAC3C;CACF;CAEA,YAAoB,UAA8C;EAChE,QAAQ,UAAR;GACE,KAAK,QACH,OAAO;GACT,KAAK,UACH,OAAO;GACT,KAAK,OACH,OAAO;GACT,SACE,OAAO;EACX;CACF;AACF;;;;;;;ACjSA,IAAa,eAAb,MAA0B;CAYxB,cAAc;EAXmD,KAAA,SAAA,CAAC;EACjB,KAAA,qBAAA,CAAC;EACnB,KAAA,uCAAA,IAAI,IAGjC;EACsB,KAAA,gCAAA,IAAI,IAG1B;EAGA,KAAK,4BAA4B;EACjC,KAAK,+BAA+B;CACtC;;;;CAKA,8BAA4C;EAE1C,KAAK,oBAAoB;GACvB,MAAM;GACN,UAAU;GACV,YAAY,UACV,MAAM,QAAQ,SAAS,eAAe,KACtC,MAAM,QAAQ,SAAS,MAAM,KAC7B,MAAM,SAAS;GACjB,QAAQ,OAAO,OAAO,YAAY;IAChC,QAAQ,IAAI,yCAAyC;IAGrD,IAAI,OAAO,WAAW,eAAe,OAAO,IAC1C,OAAO,GAAG;IAIZ,KAAK,oBAAoB;IAGzB,MAAM,KAAK,qBAAqB,OAAO;IAEvC,OAAO;GACT;EACF,CAAC;EAGD,KAAK,oBAAoB;GACvB,MAAM;GACN,UAAU;GACV,YAAY,UACV,iBAAiB,eACjB,MAAM,QAAQ,SAAS,QAAQ,KAC/B,MAAM,QAAQ,SAAS,YAAY;GACrC,QAAQ,OAEN,OAEA,YACG;IACH,QAAQ,IAAI,yCAAyC;IAIrD,OAAO;GACT;EACF,CAAC;EAGD,KAAK,oBAAoB;GACvB,MAAM;GACN,UAAU;GACV,YAAY,UACV,iBAAiB,sBACjB,MAAM,QAAQ,SAAS,WAAW,KAClC,MAAM,QAAQ,SAAS,MAAM;GAC/B,QAAQ,OAEN,OAEA,YACG;IACH,QAAQ,IAAI,iDAAiD;IAI7D,OAAO;GACT;EACF,CAAC;EAGD,KAAK,oBAAoB;GACvB,MAAM;GACN,UAAU;GACV,YAAY,UACV,iBAAiB,gBACjB,MAAM,QAAQ,SAAS,SAAS,KAChC,MAAM,QAAQ,SAAS,WAAW;GACpC,QAAQ,OAAO,OAAO,YAAY;IAChC,QAAQ,IAAI,2CAA2C;IAGvD,KAAK,eAAe,QAAQ,WAAW,GAAG;IAE1C,OAAO;GACT;EACF,CAAC;EAGD,KAAK,oBAAoB;GACvB,MAAM;GACN,UAAU;GACV,iBAAiB;GACjB,QAAQ,OAAO,OAAO,YAAY;IAChC,QAAQ,IAAI,wCAAwC;IAGpD,MAAM,aAAa,KAAK,IACtB,MACE,KAAK,IAAI,GAAI,QAAQ,gBAAgB,cAAyB,CAAC,GACjE,GACF;IACA,MAAM,IAAI,SAAS,YAAY,WAAW,SAAS,UAAU,CAAC;IAE9D,OAAO;GACT;EACF,CAAC;CACH;;;;CAKA,iCAA+C;EAC7C,KAAK,cAAc,IAAI,oBAAoB;GACzC,YAAY;GACZ,WAAW;GACX,YAAY;EACd,CAAC;EAED,KAAK,cAAc,IAAI,iBAAiB;GACtC,YAAY;GACZ,WAAW;GACX,YAAY;EACd,CAAC;EAED,KAAK,cAAc,IAAI,kBAAkB;GACvC,YAAY;GACZ,WAAW;GACX,YAAY;EACd,CAAC;CACH;;;;CAKA,MAAM,YAAY,OAAc,SAAyC;EAEvE,KAAK,YAAY,OAAO,OAAO;EAG/B,IAAI,KAAK,qBAAqB,QAAQ,SAAS,GAAG;GAChD,QAAQ,KACN,+BAA+B,QAAQ,UAAU,oBACnD;GACA,OAAO;EACT;EAGA,MAAM,aAAa,KAAK,mBACrB,QAAQ,aAAa,SAAS,UAAU,OAAO,OAAO,CAAC,CAAC,CACxD,MAAM,GAAG,MAAM,EAAE,WAAW,EAAE,QAAQ;EAEzC,KAAK,MAAM,YAAY,YACrB,IAAI;GACF,QAAQ,IAAI,oCAAoC,SAAS,MAAM;GAG/D,IAAI,MAFkB,SAAS,OAAO,OAAO,OAAO,GAEvC;IACX,QAAQ,IAAI,wCAAwC,SAAS,MAAM;IACnE,KAAK,sBAAsB,QAAQ,SAAS;IAC5C,OAAO;GACT;EACF,SAAS,eAAe;GACtB,QAAQ,KACN,uBAAuB,SAAS,KAAK,WACrC,aACF;GACA,KAAK,sBAAsB,QAAQ,SAAS;EAC9C;EAIF,KAAK,qBAAqB,QAAQ,WAAW,KAAK;EAElD,QAAQ,MACN,gDAAgD,MAAM,SACxD;EACA,OAAO;CACT;;;;CAKA,YAAoB,OAAc,SAA6B;EAC7D,KAAK,OAAO,KAAK;GAAE;GAAO;EAAQ,CAAC;EAGnC,IAAI,KAAK,OAAO,SAAS,KACvB,KAAK,SAAS,KAAK,OAAO,MAAM,IAAK;EAIvC,QAAQ,MAAM,sBAAsB,MAAM,KAAK,IAAI,MAAM,WAAW;GAClE,WAAW,QAAQ;GACnB,UAAU,QAAQ;GAClB,WAAW,IAAI,KAAK,QAAQ,SAAS,CAAC,CAAC,YAAY;EACrD,CAAC;CACH;;;;CAKA,qBAA6B,WAA4B;EACvD,MAAM,QAAQ,KAAK,qBAAqB,IAAI,SAAS;EACrD,IAAI,CAAC,OAAO,OAAO;EAGnB,IAAI,MAAM,UAAU,KAAK,IAAI,IAAI,MAAM,cAAc,KAAO;GAC1D,MAAM,SAAS;GACf,MAAM,WAAW;GACjB,QAAQ,IAAI,gCAAgC,WAAW;EACzD;EAEA,OAAO,MAAM;CACf;;;;CAKA,qBAA6B,WAAmB,SAAwB;EACtE,IAAI,QAAQ,KAAK,qBAAqB,IAAI,SAAS;EACnD,IAAI,CAAC,OAAO;GACV,QAAQ;IAAE,QAAQ;IAAO,UAAU;IAAG,aAAa;GAAE;GACrD,KAAK,qBAAqB,IAAI,WAAW,KAAK;EAChD;EAEA,IAAI,SAAS;GACX,MAAM,WAAW;GACjB,IAAI,MAAM,QAAQ;IAChB,MAAM,SAAS;IACf,QAAQ,IAAI,iCAAiC,WAAW;GAC1D;EACF,OAAO;GACL,MAAM;GACN,MAAM,cAAc,KAAK,IAAI;GAG7B,IAAI,MAAM,YAAY,KAAK,CAAC,MAAM,QAAQ;IACxC,MAAM,SAAS;IACf,QAAQ,KACN,iCAAiC,UAAU,SAAS,MAAM,SAAS,UACrE;GACF;EACF;CACF;;;;CAKA,sBAA8B,WAAyB;EACrD,KAAK,qBAAqB,WAAW,IAAI;CAC3C;;;;CAKA,sBAA8B,WAAyB;EACrD,KAAK,qBAAqB,WAAW,KAAK;CAC5C;;;;CAKA,oBAAoB,UAAkC;EACpD,KAAK,mBAAmB,KAAK,QAAQ;EACrC,KAAK,mBAAmB,MAAM,GAAG,MAAM,EAAE,WAAW,EAAE,QAAQ;EAC9D,QAAQ,IACN,8BAA8B,SAAS,KAAK,cAAc,SAAS,SAAS,EAC9E;CACF;;;;CAKA,eACE,WACA,QACM;EACN,KAAK,cAAc,IAAI,WAAW,MAAM;EACxC,QAAQ,IAAI,2BAA2B,UAAU,IAAI,MAAM;CAC7D;;;;CAKA,MAAM,iBACJ,WACA,IACA,UAAiC,CAAC,GACtB;EACZ,MAAM,SACJ,KAAK,cAAc,IAAI,SAAS,KAChC,KAAK,cAAc,IAAI,kBAAkB;EAC3C,IAAI,YAA0B;EAE9B,KAAK,IAAI,UAAU,GAAG,WAAW,OAAO,YAAY,WAClD,IAAI;GACF,MAAM,SAAS,MAAM,GAAG;GAGxB,KAAK,qBAAqB,WAAW,IAAI;GAEzC,OAAO;EACT,SAAS,OAAO;GACd,YAAY;GAEZ,MAAM,eAA6B;IACjC;IACA,WAAW,KAAK,IAAI;IACpB,UAAU,QAAQ,YAAY;IAC9B,aAAa,QAAQ,eAAe;IACpC,aAAa,QAAQ;IACrB,YAAY,UAAU;IACtB,gBAAgB;KACd,GAAG,QAAQ;KACX,YAAY;KACZ,YAAY,OAAO;IACrB;GACF;GAGA,IAAI,YAAY,OAAO,YAAY;IACjC,MAAM,KAAK,YAAY,WAAW,YAAY;IAC9C;GACF;GAKA,IAAI,CAAC,MAFmB,KAAK,YAAY,WAAW,YAAY,KAE9C,UAAU,OAAO,YAAY;IAE7C,MAAM,QAAQ,OAAO,YAAY,KAAK,IAAI,OAAO,YAAY,OAAO;IACpE,QAAQ,IACN,iBAAiB,MAAM,cAAc,UAAU,EAAE,GAAG,OAAO,WAAW,EACxE;IACA,MAAM,IAAI,SAAS,YAAY,WAAW,SAAS,KAAK,CAAC;GAC3D;EACF;EAGF,MACE,6BACA,IAAI,MACF,aAAa,UAAU,gBAAgB,OAAO,WAAW,SAC3D;CAEJ;;;;CAKA,kBAAgC;EAC9B,IAAI,KAAK,OAAO,WAAW,GACzB,OAAO;GACL,YAAY;GACZ,WAAW;GACX,eAAe;GACf,8BAAc,IAAI,IAAI;GACtB,gBAAgB;GAChB,qBAAqB;EACvB;EAGF,MAAM,MAAM,KAAK,IAAI;EACrB,MAAM,cAAc,KAAK,OAAO,QAC7B,MAAM,MAAM,EAAE,QAAQ,YAAY,KACrC;EAEA,MAAM,+BAAe,IAAI,IAAoB;EAC7C,IAAI,iBAAiB;EAErB,YAAY,SAAS,EAAE,YAAY;GACjC,MAAM,WAAW,GAAG,MAAM,KAAK,IAAI,MAAM;GACzC,aAAa,IAAI,WAAW,aAAa,IAAI,QAAQ,KAAK,KAAK,CAAC;GAEhE,IAAI,iBAAiB,gBAAgB,iBAAiB,aACpD;EAEJ,CAAC;EAED,OAAO;GACL,YAAY,KAAK,OAAO;GACxB,WAAW,YAAY,SAAS,KAAK,IAAI,GAAG,EAAE;GAC9C,eAAe,KAAK,OAAO,KAAK,OAAO,SAAS,EAAE,CAAC,QAAQ;GAC3D;GACA;GACA,qBAAqB,KAAK,6BAA6B;EACzD;CACF;;;;CAKA,+BAA+C;EAG7C,OAAO;CACT;;;;CAKA,sBAAoC;EAElC,QAAQ,IAAI,gCAAgC;CAC9C;CAEA,MAAc,qBAAqB,SAAsC;EAEvE,QAAQ,IACN,qCAAqC,QAAQ,YAAY,MAAM,KAAK,IAAI,GAAG,KAAK,MAAM,QAAQ,cAAc,CAAC,CAAC,GAChH;CACF;CAEA,eAAuB,WAAmB,YAA0B;EAClE,QAAQ,IAAI,6BAA6B,UAAU,MAAM,WAAW,EAAE;CAExE;;;;CAKA,sBAA8B;EAC5B,MAAM,UAAU,KAAK,gBAAgB;EAErC,IAAI,SAAS;EACb,UAAU;EACV,UAAU,oBAAoB,QAAQ,WAAW;EACjD,UAAU,iBAAiB,QAAQ,UAAU,QAAQ,CAAC,EAAE;EACxD,UAAU,uBAAuB,QAAQ,eAAe;EACxD,UAAU,6BAA6B,QAAQ,sBAAsB,IAAA,CAAK,QAAQ,CAAC,EAAE;EAErF,IAAI,QAAQ,gBAAgB,GAAG;GAC7B,MAAM,sBACH,KAAK,IAAI,IAAI,QAAQ,iBAAiB,MAAO;GAChD,UAAU,iBAAiB,mBAAmB,QAAQ,CAAC,EAAE;EAC3D;EAEA,IAAI,QAAQ,aAAa,OAAO,GAAG;GACjC,UAAU;GAKV,MAJ2B,KAAK,QAAQ,aAAa,QAAQ,CAAC,CAAC,CAC5D,MAAM,GAAG,MAAM,EAAE,KAAK,EAAE,EAAE,CAAC,CAC3B,MAAM,GAAG,CAEZ,CAAA,CAAa,SAAS,CAAC,OAAO,QAAQ,UAAU;IAC9C,UAAU,GAAG,QAAQ,EAAE,IAAI,MAAM,IAAI,MAAM;GAC7C,CAAC;EACH;EAGA,UAAU;EACV,KAAK,MAAM,CAAC,WAAW,UAAU,KAAK,sBAAsB;GAC1D,MAAM,SAAS,MAAM,SAAS,YAAY;GAC1C,UAAU,KAAK,UAAU,IAAI,OAAO,cAAc,MAAM,SAAS;EACnE;EAEA,OAAO;CACT;;;;CAKA,QAAc;EACZ,KAAK,SAAS,CAAC;EACf,KAAK,qBAAqB,MAAM;EAChC,QAAQ,IAAI,wBAAwB;CACtC;;;;CAKA,gBACE,QAAgB,IACgC;EAChD,OAAO,KAAK,OAAO,MAAM,CAAC,KAAK;CACjC;AACF;AAGA,IAAa,eAAe,IAAI,aAAa;;;AC/e7C,IAAa,qBAAb,MAAgC;;EACU,KAAA,UAAA,CAAC;EACJ,KAAA,SAAA,CAAC;EACf,KAAA,eAAA;EAGO,KAAA,aAAA;GAC5B,aAAa;GACb,UAAU;GACV,YAAY;GACZ,WAAW;GACX,eAAe;EACjB;;;;;CAKA,gBAAgB,aAAqB,KAAY;EAC/C,IAAI,KAAK,cAAc;GACrB,QAAQ,KAAK,0CAA0C;GACvD;EACF;EAEA,KAAK,eAAe;EACpB,KAAK,qBAAqB,kBAAkB;GAC1C,KAAK,eAAe;EACtB,GAAG,UAAU;EAEb,QAAQ,IACN,gDAAgD,WAAW,IAC7D;CACF;;;;CAKA,iBAAuB;EACrB,IAAI,KAAK,oBAAoB;GAC3B,cAAc,KAAK,kBAAkB;GACrC,KAAK,qBAAqB,KAAA;EAC5B;EACA,KAAK,eAAe;EACpB,QAAQ,IAAI,mCAAmC;CACjD;;;;CAKA,iBAAqC;EACnC,MAAM,UAA8B;GAClC,WAAW,KAAK,IAAI;GACpB,aAAa,KAAK,eAAe;GACjC,eAAe,KAAK,wBAAwB;GAC5C,YAAY,KAAK,oBAAoB;GACrC,WAAW,KAAK,mBAAmB;EACrC;EAGA,MAAM,WAAW,KAAK,YAAY;EAClC,IAAI,aAAa,MACf,QAAQ,WAAW;EAGrB,KAAK,QAAQ,KAAK,OAAO;EACzB,KAAK,gBAAgB,OAAO;EAG5B,IAAI,KAAK,QAAQ,SAAS,KACxB,KAAK,UAAU,KAAK,QAAQ,MAAM,IAAK;EAGzC,OAAO;CACT;;;;CAKA,iBAA4D;EAC1D,IAAI,OAAO,YAAY,eAAe,QAAQ,aAAa;GAEzD,MAAM,aAAa,QAAQ,YAAY;GACvC,OAAO;IACL,MAAM,WAAW;IACjB,OAAO,WAAW,MAAM,WAAW;IACnC,MAAM;KACJ,MAAM,WAAW;KACjB,OAAO,WAAW;KAClB,OAAO,WAAW,MAAM,WAAW;IACrC;GACF;EACF;EAEA,IAAI,OAAO,gBAAgB,eAAe,YAAY,aAAa;GAEjE,MAAM,gBACJ,YAOA;GACF,OAAO;IACL,MAAM,cAAc;IACpB,OAAO,cAAc;IACrB,MAAM;KACJ,MAAM,cAAc;KACpB,OAAO,cAAc;KACrB,OAAO,cAAc;IACvB;GACF;EACF;EAGA,OAAO;GACL,MAAM;GACN,OAAO;EACT;CACF;;;;CAKA,cAAqC;EACnC,IAAI,OAAO,YAAY,eAAe,QAAQ,UAAU;GACtD,MAAM,QAAQ,QAAQ,SAAS;GAC/B,QAAQ,MAAM,OAAO,MAAM,UAAU;EACvC;EACA,OAAO;CACT;;;;CAKA,0BAA0C;EACxC,IAAI,KAAK,QAAQ,WAAW,GAAG,OAAO;EAEtC,MAAM,gBAAgB,KAAK,QAAQ,MAAM,GAAG;EAK5C,OAJkB,cAAc,QAC7B,KAAK,WAAW,MAAM,OAAO,eAC9B,CAEK,IAAY,cAAc;CACnC;;;;CAKA,sBAAsC;EACpC,IAAI,KAAK,QAAQ,SAAS,GAAG,OAAO;EAEpC,MAAM,gBAAgB,KAAK,QAAQ,MAAM,EAAE;EAC3C,MAAM,aACJ,cAAc,cAAc,SAAS,EAAE,CAAC,YACxC,cAAc,EAAE,CAAC;EAEnB,IAAI,eAAe,GAAG,OAAO;EAE7B,OAAQ,cAAc,SAAS,MAAQ;CACzC;;;;CAKA,qBAAqC;EAGnC,OAAO;CACT;;;;CAKA,gBAAwB,SAAmC;EAEzD,IAAI,QAAQ,YAAY,OAAO,KAAK,WAAW,aAC7C,KAAK,YAAY;GACf,MAAM;GACN,UAAU;GACV,SAAS,+BAA+B,KAAK,MAAM,QAAQ,YAAY,OAAO,OAAO,IAAI,EAAE;GAC3F,WAAW,KAAK,WAAW;GAC3B,aAAa,QAAQ,YAAY;GACjC,WAAW,QAAQ;GACnB,iBAAiB;IACf;IACA;IACA;GACF;EACF,CAAC;EAIH,IAAI,QAAQ,YAAY,QAAQ,WAAW,KAAK,WAAW,UACzD,KAAK,YAAY;GACf,MAAM;GACN,UAAU;GACV,SAAS,4BAA4B,QAAQ,SAAS,QAAQ,CAAC,EAAE;GACjE,WAAW,KAAK,WAAW;GAC3B,aAAa,QAAQ;GACrB,WAAW,QAAQ;GACnB,iBAAiB;IACf;IACA;IACA;GACF;EACF,CAAC;EAIH,IAAI,QAAQ,gBAAgB,KAAK,WAAW,YAC1C,KAAK,YAAY;GACf,MAAM;GACN,UAAU;GACV,SAAS,0BAA0B,QAAQ,cAAc,QAAQ,CAAC,EAAE;GACpE,WAAW,KAAK,WAAW;GAC3B,aAAa,QAAQ;GACrB,WAAW,QAAQ;GACnB,iBAAiB;IACf;IACA;IACA;GACF;EACF,CAAC;EAIH,IAAI,QAAQ,aAAa,KAAK,WAAW,eACvC,KAAK,YAAY;GACf,MAAM;GACN,UAAU;GACV,SAAS,4BAA4B,QAAQ,WAAW,QAAQ,CAAC,EAAE;GACnE,WAAW,KAAK,WAAW;GAC3B,aAAa,QAAQ;GACrB,WAAW,QAAQ;GACnB,iBAAiB;IACf;IACA;IACA;GACF;EACF,CAAC;CAEL;;;;CAKA,YAAoB,OAA+B;EACjD,KAAK,OAAO,KAAK,KAAK;EAGtB,IAAI,KAAK,OAAO,SAAS,KACvB,KAAK,SAAS,KAAK,OAAO,MAAM,IAAI;EAWtC,QAAQ,KACN,GAAG;GAPH,KAAK;GACL,QAAQ;GACR,MAAM;GACN,UAAU;EAIP,EAAa,MAAM,UAAU,sBAAsB,MAAM,SAC9D;EAEA,IAAI,MAAM,aAAa,cAAc,MAAM,aAAa,QACtD,QAAQ,KAAK,oBAAoB,MAAM,gBAAgB,KAAK,IAAI,GAAG;CAEvE;;;;CAKA,WAAW,QAAgB,IAA0B;EACnD,OAAO,KAAK,QAAQ,MAAM,CAAC,KAAK;CAClC;;;;CAKA,UAAU,QAAgB,IAAwB;EAChD,OAAO,KAAK,OAAO,MAAM,CAAC,KAAK;CACjC;;;;CAKA,iBAAyB;EACvB,MAAM,gBAAgB,KAAK,WAAW,EAAE;EACxC,MAAM,eAAe,KAAK,UAAU,CAAC;EAErC,IAAI,cAAc,WAAW,GAC3B,OAAO;EAGT,MAAM,YACJ,cAAc,QAAQ,KAAK,MAAM,MAAM,EAAE,YAAY,MAAM,CAAC,IAC5D,cAAc;EAChB,MAAM,gBACJ,cAAc,QAAQ,KAAK,MAAM,MAAM,EAAE,YAAY,CAAC,IACtD,cAAc;EAChB,MAAM,aACJ,cAAc,QAAQ,KAAK,MAAM,MAAM,EAAE,eAAe,CAAC,IACzD,cAAc;EAEhB,IAAI,SAAS;EACb,UAAU;EACV,UAAU,mBAAmB,cAAc,OAAO;EAClD,UAAU,kBAAkB,KAAK,MAAM,YAAY,OAAO,IAAI,EAAE;EAChE,UAAU,qBAAqB,cAAc,QAAQ,CAAC,EAAE;EACxD,UAAU,mBAAmB,WAAW,QAAQ,CAAC,EAAE;EAEnD,IAAI,aAAa,SAAS,GAAG;GAC3B,UAAU,uBAAuB,aAAa,OAAO;GACrD,aAAa,SAAS,OAAO,UAAU;IACrC,UAAU,GAAG,QAAQ,EAAE,KAAK,MAAM,SAAS,YAAY,EAAE,IAAI,MAAM,QAAQ;GAC7E,CAAC;EACH,OACE,UAAU;EAGZ,OAAO;CACT;;;;CAKA,QAAc;EACZ,KAAK,UAAU,CAAC;EAChB,KAAK,SAAS,CAAC;EACf,QAAQ,IAAI,mCAAmC;CACjD;;;;CAKA,WAAoB;EAClB,OAAO,KAAK;CACd;AACF;AAGA,IAAa,qBAAqB,IAAI,mBAAmB;;;;;;;ACpWzD,IAAa,gBAAb,MAA2B;;EACG,KAAA,YAAA,KAAK,IAAI;EAGd,KAAA,eAAA;;;;;CAKvB,sBAAsB,aAAqB,KAAa;EACtD,IAAI,KAAK,cAAc;GACrB,QAAQ,KAAK,qCAAqC;GAClD;EACF;EAEA,KAAK,eAAe;EACpB,KAAK,sBAAsB,YAAY,YAAY;GACjD,MAAM,KAAK,mBAAmB;EAChC,GAAG,UAAU;EAEb,QAAQ,IAAI,2CAA2C,WAAW,IAAI;CACxE;;;;CAKA,uBAA6B;EAC3B,IAAI,KAAK,qBAAqB;GAC5B,cAAc,KAAK,mBAAmB;GACtC,KAAK,sBAAsB,KAAA;EAC7B;EACA,KAAK,eAAe;EACpB,QAAQ,IAAI,8BAA8B;CAC5C;;;;CAKA,MAAM,qBAA4C;EAChD,MAAM,SAAwB,CAAC;EAG/B,OAAO,KAAK,MAAM,KAAK,2BAA2B,CAAC;EAGnD,OAAO,KAAK,MAAM,KAAK,mBAAmB,CAAC;EAG3C,OAAO,KAAK,MAAM,KAAK,kBAAkB,CAAC;EAG1C,OAAO,KAAK,MAAM,KAAK,wBAAwB,CAAC;EAGhD,OAAO,KAAK,MAAM,KAAK,eAAe,CAAC;EAGvC,OAAO,KAAK,MAAM,KAAK,qBAAqB,CAAC;EAG7C,OAAO,KAAK,MAAM,KAAK,sBAAsB,CAAC;EAG9C,MAAM,UAAU,KAAK,uBAAuB,MAAM;EAClD,MAAM,SAAS,KAAK,IAAI,IAAI,KAAK;EAEjC,MAAM,eAA6B;GACjC;GACA,WAAW,KAAK,IAAI;GACpB;GACA;GACA,SAAS,KAAK,gBAAgB,SAAS,MAAM;GAC7C,iBAAiB,KAAK,wBAAwB,MAAM;EACtD;EAEA,KAAK,kBAAkB;EAGvB,IAAI,YAAY,WAAW;GACzB,QAAQ,KAAK,qBAAqB,QAAQ,YAAY,GAAG;GACzD,IAAI,YAAY,YACd,QAAQ,MACN,uCACA,aAAa,OACf;EAEJ;EAEA,OAAO;CACT;;;;CAKA,MAAc,6BAAmD;EAC/D,MAAM,QAAQ,KAAK,IAAI;EACvB,MAAM,WAAW,eAAe;EAGhC,MAAM,cAAc;GADQ;GAAW;GAAQ;GAAQ;EACnC,CAAA,CAAmB,SAAS,QAAQ;EAExD,OAAO;GACL,MAAM;GACN,QAAQ,cAAc,SAAS;GAC/B,SAAS,cACL,kCAAkC,aAClC,kCAAkC;GACtC,SAAS;IAAE;IAAU,WAAW;GAAY;GAC5C,UAAU,KAAK,IAAI,IAAI;EACzB;CACF;;;;CAKA,MAAc,qBAA2C;EACvD,MAAM,QAAQ,KAAK,IAAI;EACvB,MAAM,mBAAmB,sBAAsB;EAC/C,MAAM,WAAW,eAAe;EAEhC,IAAI,SAAmC;EACvC,IAAI,UAAU;EAEd,IAAI,CAAC,kBAAkB;GACrB,SAAS,aAAa,YAAY,SAAS;GAC3C,UAAU,mCAAmC,SAAS;EACxD;EAEA,OAAO;GACL,MAAM;GACN;GACA;GACA,SAAS;IACP,YAAY;IACZ;IACA,mBAAmB;GACrB;GACA,UAAU,KAAK,IAAI,IAAI;EACzB;CACF;;;;CAKA,MAAc,oBAA0C;EACtD,MAAM,QAAQ,KAAK,IAAI;EACvB,IAAI,cAAc;EAClB,IAAI,cAAc;EAClB,IAAI,WAAW;EAEf,IAAI;GACF,IAAI,OAAO,YAAY,eAAe,QAAQ,aAAa;IACzD,MAAM,aAAa,QAAQ,YAAY;IACvC,cAAc,WAAW;IACzB,cAAc,WAAW,MAAM,WAAW;IAC1C,WAAW,WAAW;GACxB,OAAO,IACL,OAAO,gBAAgB,eACvB,YAAY,aACZ;IACA,MAAM,gBACJ,YAOA;IACF,cAAc,cAAc;IAC5B,cAAc,cAAc;IAC5B,WAAW,cAAc;GAC3B;GAEA,MAAM,gBAAgB,cAAc,OAAO;GAC3C,IAAI,SAAmC;GACvC,IAAI,UAAU,4BAA4B,cAAc,QAAQ,CAAC,EAAE;GAEnE,IAAI,gBAAgB,KAAK;IACvB,SAAS;IACT,UAAU,+BAA+B,cAAc,QAAQ,CAAC,EAAE;GACpE,OAAO,IAAI,gBAAgB,KAAK;IAC9B,SAAS;IACT,UAAU,0BAA0B,cAAc,QAAQ,CAAC,EAAE;GAC/D;GAEA,OAAO;IACL,MAAM;IACN;IACA;IACA,SAAS;KACQ;KACf,eAAe,cAAc,OAAO;KACpC,YAAY,WAAW,OAAO;IAChC;IACA,UAAU,KAAK,IAAI,IAAI;GACzB;EACF,SAAS,OAAO;GACd,OAAO;IACL,MAAM;IACN,QAAQ;IACR,SAAS;IACT,SAAS,EAAE,OAAQ,MAAgB,QAAQ;IAC3C,UAAU,KAAK,IAAI,IAAI;GACzB;EACF;CACF;;;;CAKA,MAAc,0BAAgD;EAC5D,MAAM,QAAQ,KAAK,IAAI;EAEvB,IAAI,CAAC,mBAAmB,SAAS,GAC/B,OAAO;GACL,MAAM;GACN,QAAQ;GACR,SAAS;GACT,SAAS,EAAE,kBAAkB,MAAM;GACnC,UAAU,KAAK,IAAI,IAAI;EACzB;EAGF,MAAM,UAAU,mBAAmB,WAAW,CAAC;EAE/C,IAAI,QAAQ,WAAW,GACrB,OAAO;GACL,MAAM;GACN,QAAQ;GACR,SAAS;GACT,SAAS,EAAE,cAAc,EAAE;GAC3B,UAAU,KAAK,IAAI,IAAI;EACzB;EAGF,MAAM,gBACJ,QAAQ,QAAQ,KAAK,MAAM,MAAM,EAAE,YAAY,CAAC,IAAI,QAAQ;EAC9D,MAAM,aACJ,QAAQ,QAAQ,KAAK,MAAM,MAAM,EAAE,eAAe,CAAC,IAAI,QAAQ;EAEjE,IAAI,SAAmC;EACvC,IAAI,UAAU,wBAAwB,cAAc,QAAQ,CAAC,EAAE,YAAY,WAAW,QAAQ,CAAC,EAAE;EAEjG,IAAI,aAAa,KAAM;GACrB,SAAS;GACT,UAAU,kCAAkC,WAAW,QAAQ,CAAC,EAAE;EACpE,OAAO,IAAI,aAAa,OAAQ,gBAAgB,IAAI;GAClD,SAAS;GACT,UAAU,4BAA4B,cAAc,QAAQ,CAAC,EAAE,YAAY,WAAW,QAAQ,CAAC,EAAE;EACnG;EAEA,OAAO;GACL,MAAM;GACN;GACA;GACA,SAAS;IACP;IACA;IACA,cAAc,QAAQ;GACxB;GACA,UAAU,KAAK,IAAI,IAAI;EACzB;CACF;;;;CAKA,MAAc,iBAAuC;EACnD,MAAM,QAAQ,KAAK,IAAI;EACvB,MAAM,eAAe,aAAa,gBAAgB;EAElD,IAAI,SAAmC;EACvC,IAAI,UAAU,8BAA8B,aAAa,YAAY,IAAA,CAAK,QAAQ,CAAC,EAAE;EAErF,IAAI,aAAa,YAAY,IAAK;GAEhC,SAAS;GACT,UAAU,qBAAqB,aAAa,YAAY,IAAA,CAAK,QAAQ,CAAC,EAAE;EAC1E,OAAO,IAAI,aAAa,YAAY,KAAM;GAExC,SAAS;GACT,UAAU,yBAAyB,aAAa,YAAY,IAAA,CAAK,QAAQ,CAAC,EAAE;EAC9E;EAEA,OAAO;GACL,MAAM;GACN;GACA;GACA,SAAS;IACP,WAAW,aAAa;IACxB,aAAa,aAAa;IAC1B,gBAAgB,aAAa;IAC7B,cAAc,aAAa;GAC7B;GACA,UAAU,KAAK,IAAI,IAAI;EACzB;CACF;;;;CAKA,MAAc,uBAA6C;EACzD,MAAM,QAAQ,KAAK,IAAI;EAEvB,IAAI;GAEF,MAAM,YAAY,KAAK,IAAI;GAC3B,MAAM,eAAe,KAAK,IAAI,IAAI;GAElC,IAAI,SAAmC;GACvC,IAAI,UAAU,qDAAqD,aAAa;GAEhF,IAAI,eAAe,KAAM;IACvB,SAAS;IACT,UAAU,yBAAyB,aAAa;GAClD;GAEA,OAAO;IACL,MAAM;IACN;IACA;IACA,SAAS;KACP;KACA,oBAAoB;IACtB;IACA,UAAU,KAAK,IAAI,IAAI;GACzB;EACF,SAAS,OAAO;GACd,OAAO;IACL,MAAM;IACN,QAAQ;IACR,SAAS,iCAAkC,MAAgB;IAC3D,SAAS,EAAE,OAAQ,MAAgB,QAAQ;IAC3C,UAAU,KAAK,IAAI,IAAI;GACzB;EACF;CACF;;;;CAKA,MAAc,wBAA8C;EAC1D,MAAM,QAAQ,KAAK,IAAI;EAEvB,MAAM,eAAe;GACnB;IAAE,MAAM;IAAU,aAAa,OAAO,eAAe;GAAY;GACjE;IAAE,MAAM;IAAW,aAAa,OAAO,YAAY;GAAY;GAC/D;IAAE,MAAM;IAAc,aAAa,OAAO,eAAe;GAAY;GACrE;IAAE,MAAM;IAAW,aAAa,OAAO,YAAY;GAAY;EACjE;EAEA,MAAM,SAAS,aAAa,QAAQ,QAAQ,CAAC,IAAI,MAAM,CAAC;EAExD,IAAI,OAAO,WAAW,GACpB,OAAO;GACL,MAAM;GACN,QAAQ;GACR,SAAS;GACT,SAAS,EAAE,cAAc,aAAa,KAAK,MAAM,EAAE,IAAI,EAAE;GACzD,UAAU,KAAK,IAAI,IAAI;EACzB;OAEA,OAAO;GACL,MAAM;GACN,QAAQ;GACR,SAAS,yBAAyB,OAAO,KAAK,MAAM,EAAE,IAAI,CAAC,CAAC,KAAK,IAAI;GACrE,SAAS,EAAE,QAAQ,OAAO,KAAK,MAAM,EAAE,IAAI,EAAE;GAC7C,UAAU,KAAK,IAAI,IAAI;EACzB;CAEJ;;;;CAKA,uBACE,QACgD;EAChD,IAAI,OAAO,WAAW,GAAG,OAAO;EAEhC,MAAM,cAAc,OAAO,MAAM,UAAU,MAAM,WAAW,MAAM;EAClE,MAAM,cAAc,OAAO,MAAM,UAAU,MAAM,WAAW,MAAM;EAElE,IAAI,aAAa,OAAO;EACxB,IAAI,aAAa,OAAO;EACxB,OAAO;CACT;;;;CAKA,gBAAwB,SAAiB,QAA+B;EACtE,MAAM,YAAY,OAAO,QAAQ,MAAM,EAAE,WAAW,MAAM,CAAC,CAAC;EAC5D,MAAM,YAAY,OAAO,QAAQ,MAAM,EAAE,WAAW,MAAM,CAAC,CAAC;EAC5D,MAAM,YAAY,OAAO,QAAQ,MAAM,EAAE,WAAW,MAAM,CAAC,CAAC;EAE5D,OAAO,WAAW,QAAQ,YAAY,EAAE,aAAa,UAAU,SAAS,UAAU,SAAS,UAAU;CACvG;;;;CAKA,wBAAgC,QAAiC;EAC/D,MAAM,kBAA4B,CAAC;EAEnC,OAAO,SAAS,UAAU;GACxB,IAAI,MAAM,WAAW,QACnB,QAAQ,MAAM,MAAd;IACE,KAAK;KACH,gBAAgB,KACd,+DACF;KACA;IACF,KAAK;KACH,gBAAgB,KACd,iDACF;KACA;IACF,KAAK;KACH,gBAAgB,KAAK,sCAAsC;KAC3D;IACF,KAAK;KACH,gBAAgB,KAAK,0CAA0C;KAC/D;IACF,KAAK,oBACH,gBAAgB,KAAK,2CAA2C;GAEpE;QACK,IAAI,MAAM,WAAW,QAC1B,QAAQ,MAAM,MAAd;IACE,KAAK;KACH,gBAAgB,KAAK,6BAA6B;KAClD;IACF,KAAK;KACH,gBAAgB,KAAK,oCAAoC;KACzD;IACF,KAAK,cACH,gBAAgB,KACd,yDACF;GAEJ;EAEJ,CAAC;EAED,IAAI,gBAAgB,WAAW,GAC7B,gBAAgB,KAAK,yCAAyC;EAGhE,OAAO;CACT;;;;CAKA,qBAA+C;EAC7C,OAAO,KAAK;CACd;;;;CAKA,YAAoB;EAClB,OAAO,KAAK,IAAI,IAAI,KAAK;CAC3B;;;;CAKA,uBAA+B;EAC7B,MAAM,SAAS,KAAK;EAEpB,IAAI,CAAC,QACH,OAAO;EAGT,IAAI,SAAS;EACb,UAAU;EACV,UAAU,sBAAsB,OAAO,QAAQ,YAAY,EAAE;EAC7D,UAAU,gBAAgB,IAAI,KAAK,OAAO,SAAS,CAAC,CAAC,YAAY,EAAE;EACnE,UAAU,cAAc,KAAK,MAAM,OAAO,SAAS,MAAO,EAAE,EAAE;EAC9D,UAAU,eAAe,OAAO,QAAQ;EAExC,UAAU;EACV,OAAO,OAAO,SAAS,OAAO,UAAU;GACtC,MAAM,aACJ,MAAM,WAAW,SAAS,MAAM,MAAM,WAAW,SAAS,OAAO;GACnE,UAAU,GAAG,QAAQ,EAAE,IAAI,WAAW,GAAG,MAAM,KAAK,IAAI,MAAM,QAAQ;GAEtE,IAAI,MAAM,WAAW,OAAO,KAAK,MAAM,OAAO,CAAC,CAAC,SAAS,GACvD,UAAU,eAAe,KAAK,UAAU,MAAM,SAAS,MAAM,CAAC,CAAC,CAAC,QAAQ,OAAO,OAAO,EAAE;EAE5F,CAAC;EAED,IAAI,OAAO,gBAAgB,SAAS,GAAG;GACrC,UAAU;GACV,OAAO,gBAAgB,SAAS,KAAK,UAAU;IAC7C,UAAU,GAAG,QAAQ,EAAE,IAAI,IAAI;GACjC,CAAC;EACH;EAEA,OAAO;CACT;;;;CAKA,MAAM,mBAGH;EACD,MAAM,SAAS;GACb,MAAM,KAAK,2BAA2B;GACtC,MAAM,KAAK,mBAAmB;GAC9B,MAAM,KAAK,kBAAkB;EAC/B;EAEA,MAAM,UAAU,KAAK,uBAAuB,MAAM;EAClD,MAAM,eAAe,OAAO,QAAQ,MAAM,EAAE,WAAW,MAAM;EAC7D,MAAM,gBAAgB,OAAO,QAAQ,MAAM,EAAE,WAAW,MAAM;EAE9D,IAAI,UAAU;EACd,IAAI,aAAa,SAAS,GACxB,UAAU,oBAAoB,aAAa,KAAK,MAAM,EAAE,IAAI,CAAC,CAAC,KAAK,IAAI;OAClE,IAAI,cAAc,SAAS,GAChC,UAAU,aAAa,cAAc,KAAK,MAAM,EAAE,IAAI,CAAC,CAAC,KAAK,IAAI;EAMnE,OAAO;GAAE,QAFM,YAAY,YAAY,YAAY;GAElC;EAAQ;CAC3B;;;;CAKA,QAAc;EACZ,KAAK,YAAY,KAAK,IAAI;EAC1B,KAAK,kBAAkB,KAAA;EACvB,QAAQ,IAAI,yBAAyB;CACvC;AACF;AAGA,IAAa,gBAAgB,IAAI,cAAc;;;AC7Y/C,IAAA,cAAe"}