tywrap 0.5.0 → 0.6.0

package/src/types/index.ts

@@ -310,7 +310,14 @@ export interface TywrapOptions {
 
 export interface PythonModuleConfig {
   version?: string;
-  runtime: RuntimeStrategy;
+  /**
+   * @deprecated Dead input. The per-module runtime is never read during code
+   * generation — the active runtime is resolved from the top-level
+   * {@link RuntimeConfig} (`runtime.node`, etc.). Kept optional so existing
+   * configs that still set it continue to validate; it has no effect and will
+   * be removed in a future major release.
+   */
+  runtime?: RuntimeStrategy;
   functions?: string[];
   classes?: string[];
   /** Exclude specific exports by exact name. */
@@ -343,11 +350,13 @@ export interface PyodideConfig {
 export interface NodeConfig {
   pythonPath?: string;
   virtualEnv?: string;
+  /** Per-call timeout in milliseconds for the subprocess bridge. */
   timeout?: number;
 }
 
 export interface HttpConfig {
   baseURL: string;
+  /** Per-request timeout in milliseconds for the HTTP bridge. */
   timeout?: number;
   headers?: Record<string, string>;
 }

package/src/tywrap.ts

@@ -18,7 +18,6 @@ import type {
 } from './types/index.js';
 import { fsUtils, pathUtils, processUtils, isWindows } from './utils/runtime.js';
 import { globalCache } from './utils/cache.js';
-import { globalParallelProcessor } from './utils/parallel-processor.js';
 import { resolvePythonExecutable } from './utils/python.js';
 import { computeIrCacheFilename } from './utils/ir-cache.js';
 
@@ -45,7 +44,6 @@ export async function tywrap(options: Partial<TywrapOptions> = {}): Promise<Tywr
   const generator = new CodeGenerator(mapper);
 
   globalCache.setDebug(options.debug ?? false);
-  globalParallelProcessor.setDebug(options.debug ?? false);
 
   return {
     mapper,
@@ -155,7 +153,7 @@ export async function generate(
     const moduleConfig = entry[1];
     // reset collector for each module
     unknownTypeNamesCollector = new Map();
-    // Prefer Python IR extractor over TS analyzer with optional cache
+    // Resolve module IR via the Python extractor (with optional cache)
     const cacheKey = await computeCacheKey(moduleKey, resolvedOptions);
     let ir: unknown | null = null;
     let irError: string | undefined;

package/src/utils/cache.ts

@@ -47,7 +47,7 @@ export interface CacheConfig {
   debug?: boolean;
 }
 
-export class IntelligentCache {
+export class ArtifactCache {
   private memoryCache = new Map<string, CacheEntry>();
   private stats = {
     hits: 0,
@@ -685,4 +685,4 @@ export class IntelligentCache {
 }
 
 // Export singleton instance
-export const globalCache = new IntelligentCache();
+export const globalCache = new ArtifactCache();

package/src/utils/codec.ts

@@ -40,7 +40,7 @@ export interface SklearnEstimator {
   params: Record<string, unknown>;
 }
 
-export type CodecEnvelope =
+export type ValueEnvelope =
   | {
       readonly __tywrap__: 'dataframe';
       readonly codecVersion?: number;
@@ -337,7 +337,7 @@ function reshapeArray(flat: unknown[], shape: readonly number[]): unknown {
 // Why: decoding needs to reject incompatible envelopes before we attempt to interpret payloads.
 const CODEC_VERSION = 1;
 
-function assertCodecVersion(envelope: { codecVersion?: unknown }, marker: string): void {
+function assertCodecVersion(envelope: { codecVersion?: unknown }, typeTag: string): void {
   if (!('codecVersion' in envelope)) {
     return;
   }
@@ -346,235 +346,256 @@ function assertCodecVersion(envelope: { codecVersion?: unknown }, marker: string
     return;
   }
   if (typeof version !== 'number' || !Number.isFinite(version)) {
-    throw new Error(`Invalid ${marker} envelope: codecVersion must be a number`);
+    throw new Error(`Invalid ${typeTag} envelope: codecVersion must be a number`);
   }
   if (version !== CODEC_VERSION) {
-    throw new Error(`Unsupported ${marker} envelope codecVersion: ${version}`);
+    throw new Error(`Unsupported ${typeTag} envelope codecVersion: ${version}`);
   }
 }
 
-function decodeEnvelopeCore<T>(
-  value: unknown,
+/**
+ * Per-typeTag decode handler.
+ *
+ * Why: each scientific value envelope type (dataframe, series, ndarray, scipy.sparse,
+ * torch.tensor, sklearn.estimator) has its own validation and decode logic. Splitting
+ * the dispatch into one handler per type keeps each branch focused and testable while
+ * preserving byte-identical decoded output.
+ */
+type EnvelopeHandler = <T>(
+  value: { [k: string]: unknown },
   decodeArrow: (bytes: Uint8Array) => MaybePromise<T>,
   recurse: (value: unknown) => MaybePromise<T | unknown>
-): MaybePromise<T | unknown> {
-  if (!isObject(value)) {
-    return value;
-  }
-  const marker = (value as { __tywrap__?: unknown }).__tywrap__;
-  if (typeof marker !== 'string') {
-    return value as unknown;
-  }
+) => MaybePromise<T | unknown>;
 
-  if (
-    marker === 'dataframe' ||
-    marker === 'series' ||
-    marker === 'ndarray' ||
-    marker === 'scipy.sparse' ||
-    marker === 'torch.tensor' ||
-    marker === 'sklearn.estimator'
-  ) {
-    assertCodecVersion(value as { codecVersion?: unknown }, marker);
-  }
-
-  if (marker === 'dataframe') {
-    const encoding = (value as { encoding?: unknown }).encoding;
-    if (encoding === 'arrow') {
-      const b64 = (value as { b64?: unknown }).b64;
-      if (typeof b64 !== 'string') {
-        throw new Error('Invalid dataframe envelope: missing b64');
-      }
-      const bytes = fromBase64(b64);
-      return decodeArrow(bytes);
-    }
-    if (encoding === 'json') {
-      if (!('data' in (value as object))) {
-        throw new Error('Invalid dataframe envelope: missing data');
-      }
-      return (value as { data: unknown }).data;
+/**
+ * Decode an Arrow-or-JSON envelope (dataframe / series).
+ *
+ * Why: dataframe and series share identical arrow/json handling; the only difference
+ * is the typeTag name used in error messages.
+ */
+function decodeArrowOrJsonEnvelope<T>(
+  value: { [k: string]: unknown },
+  decodeArrow: (bytes: Uint8Array) => MaybePromise<T>,
+  typeTag: string
+): MaybePromise<T | unknown> {
+  const encoding = value.encoding;
+  if (encoding === 'arrow') {
+    const b64 = value.b64;
+    if (typeof b64 !== 'string') {
+      throw new Error(`Invalid ${typeTag} envelope: missing b64`);
     }
-    throw new Error(`Invalid dataframe envelope: unsupported encoding ${String(encoding)}`);
+    const bytes = fromBase64(b64);
+    return decodeArrow(bytes);
   }
-
-  if (marker === 'series') {
-    const encoding = (value as { encoding?: unknown }).encoding;
-    if (encoding === 'arrow') {
-      const b64 = (value as { b64?: unknown }).b64;
-      if (typeof b64 !== 'string') {
-        throw new Error('Invalid series envelope: missing b64');
-      }
-      const bytes = fromBase64(b64);
-      return decodeArrow(bytes);
+  if (encoding === 'json') {
+    if (!('data' in value)) {
+      throw new Error(`Invalid ${typeTag} envelope: missing data`);
     }
-    if (encoding === 'json') {
-      if (!('data' in (value as object))) {
-        throw new Error('Invalid series envelope: missing data');
-      }
-      return (value as { data: unknown }).data;
-    }
-    throw new Error(`Invalid series envelope: unsupported encoding ${String(encoding)}`);
+    return value.data;
   }
+  throw new Error(`Invalid ${typeTag} envelope: unsupported encoding ${String(encoding)}`);
+}
 
-  if (marker === 'ndarray') {
-    const encoding = (value as { encoding?: unknown }).encoding;
-    const shapeValue = (value as { shape?: unknown }).shape;
-    const shape = isNumberArray(shapeValue) ? shapeValue : undefined;
+const decodeDataframeEnvelope: EnvelopeHandler = (value, decodeArrow) =>
+  decodeArrowOrJsonEnvelope(value, decodeArrow, 'dataframe');
 
-    if (encoding === 'arrow') {
-      const b64 = (value as { b64?: unknown }).b64;
-      if (typeof b64 !== 'string') {
-        throw new Error('Invalid ndarray envelope: missing b64');
-      }
-      const bytes = fromBase64(b64);
-      const decoded = decodeArrow(bytes);
-
-      // Extract values from Arrow table and reshape if needed
-      // Arrow only handles 1D arrays, so we flatten on encode and reshape here
-      // Reshape for: scalars (shape.length === 0) and multi-dim (shape.length > 1)
-      // Skip reshape for: 1D arrays (shape.length === 1) - return as-is
-      if (isPromiseLike(decoded)) {
-        return decoded.then(data => {
-          const values = extractArrowValues(data);
-          if (!values) {
-            return data; // Fallback: return raw data if extraction fails
-          }
-          // Reshape scalars and multi-dimensional arrays, but not 1D
-          if (shape && shape.length !== 1) {
-            return reshapeArray(values, shape);
-          }
-          return values;
-        });
-      }
-      const values = extractArrowValues(decoded);
-      if (!values) {
-        return decoded; // Fallback: return raw data if extraction fails
-      }
-      // Reshape scalars and multi-dimensional arrays, but not 1D
-      if (shape && shape.length !== 1) {
-        return reshapeArray(values, shape);
-      }
-      return values;
-    }
-    if (encoding === 'json') {
-      if (!('data' in (value as object))) {
-        throw new Error('Invalid ndarray envelope: missing data');
-      }
-      return (value as { data: unknown }).data;
-    }
-    throw new Error(`Invalid ndarray envelope: unsupported encoding ${String(encoding)}`);
-  }
+const decodeSeriesEnvelope: EnvelopeHandler = (value, decodeArrow) =>
+  decodeArrowOrJsonEnvelope(value, decodeArrow, 'series');
 
-  if (marker === 'scipy.sparse') {
-    const encoding = (value as { encoding?: unknown }).encoding;
-    if (encoding !== 'json') {
-      throw new Error(`Invalid scipy.sparse envelope: unsupported encoding ${String(encoding)}`);
+const decodeNdarrayEnvelope: EnvelopeHandler = (value, decodeArrow) => {
+  const encoding = value.encoding;
+  const shapeValue = value.shape;
+  const shape = isNumberArray(shapeValue) ? shapeValue : undefined;
+
+  if (encoding === 'arrow') {
+    const b64 = value.b64;
+    if (typeof b64 !== 'string') {
+      throw new Error('Invalid ndarray envelope: missing b64');
     }
-    const format = (value as { format?: unknown }).format;
-    if (format !== 'csr' && format !== 'csc' && format !== 'coo') {
-      throw new Error(`Invalid scipy.sparse envelope: unsupported format ${String(format)}`);
+    const bytes = fromBase64(b64);
+    const decoded = decodeArrow(bytes);
+
+    // Extract values from Arrow table and reshape if needed
+    // Arrow only handles 1D arrays, so we flatten on encode and reshape here
+    // Reshape for: scalars (shape.length === 0) and multi-dim (shape.length > 1)
+    // Skip reshape for: 1D arrays (shape.length === 1) - return as-is
+    if (isPromiseLike(decoded)) {
+      return decoded.then(data => {
+        const values = extractArrowValues(data);
+        if (!values) {
+          return data; // Fallback: return raw data if extraction fails
+        }
+        // Reshape scalars and multi-dimensional arrays, but not 1D
+        if (shape && shape.length !== 1) {
+          return reshapeArray(values, shape);
+        }
+        return values;
+      });
     }
-    const shape = (value as { shape?: unknown }).shape;
-    if (
-      !Array.isArray(shape) ||
-      shape.length !== 2 ||
-      typeof shape[0] !== 'number' ||
-      typeof shape[1] !== 'number'
-    ) {
-      throw new Error('Invalid scipy.sparse envelope: shape must be a 2-item number[]');
+    const values = extractArrowValues(decoded);
+    if (!values) {
+      return decoded; // Fallback: return raw data if extraction fails
     }
-    const data = (value as { data?: unknown }).data;
-    if (!Array.isArray(data)) {
-      throw new Error('Invalid scipy.sparse envelope: data must be an array');
+    // Reshape scalars and multi-dimensional arrays, but not 1D
+    if (shape && shape.length !== 1) {
+      return reshapeArray(values, shape);
     }
-    const dtypeValue = (value as { dtype?: unknown }).dtype;
-    const dtype = typeof dtypeValue === 'string' ? dtypeValue : undefined;
-
-    if (format === 'coo') {
-      const row = (value as { row?: unknown }).row;
-      const col = (value as { col?: unknown }).col;
-      if (!Array.isArray(row) || !Array.isArray(col)) {
-        throw new Error('Invalid scipy.sparse envelope: coo requires row and col arrays');
-      }
-      return {
-        format,
-        shape,
-        data,
-        row,
-        col,
-        dtype,
-      } satisfies SparseMatrix;
+    return values;
+  }
+  if (encoding === 'json') {
+    if (!('data' in value)) {
+      throw new Error('Invalid ndarray envelope: missing data');
     }
+    return value.data;
+  }
+  throw new Error(`Invalid ndarray envelope: unsupported encoding ${String(encoding)}`);
+};
 
-    const indices = (value as { indices?: unknown }).indices;
-    const indptr = (value as { indptr?: unknown }).indptr;
-    if (!Array.isArray(indices) || !Array.isArray(indptr)) {
-      throw new Error('Invalid scipy.sparse envelope: csr/csc requires indices and indptr arrays');
+const decodeScipySparseEnvelope: EnvelopeHandler = value => {
+  const encoding = value.encoding;
+  if (encoding !== 'json') {
+    throw new Error(`Invalid scipy.sparse envelope: unsupported encoding ${String(encoding)}`);
+  }
+  const format = value.format;
+  if (format !== 'csr' && format !== 'csc' && format !== 'coo') {
+    throw new Error(`Invalid scipy.sparse envelope: unsupported format ${String(format)}`);
+  }
+  const shape = value.shape;
+  if (
+    !Array.isArray(shape) ||
+    shape.length !== 2 ||
+    typeof shape[0] !== 'number' ||
+    typeof shape[1] !== 'number'
+  ) {
+    throw new Error('Invalid scipy.sparse envelope: shape must be a 2-item number[]');
+  }
+  const data = value.data;
+  if (!Array.isArray(data)) {
+    throw new Error('Invalid scipy.sparse envelope: data must be an array');
+  }
+  const dtypeValue = value.dtype;
+  const dtype = typeof dtypeValue === 'string' ? dtypeValue : undefined;
+
+  if (format === 'coo') {
+    const row = value.row;
+    const col = value.col;
+    if (!Array.isArray(row) || !Array.isArray(col)) {
+      throw new Error('Invalid scipy.sparse envelope: coo requires row and col arrays');
     }
     return {
       format,
       shape,
       data,
-      indices,
-      indptr,
+      row,
+      col,
       dtype,
     } satisfies SparseMatrix;
   }
 
-  if (marker === 'torch.tensor') {
-    const encoding = (value as { encoding?: unknown }).encoding;
-    if (encoding !== 'ndarray') {
-      throw new Error(`Invalid torch.tensor envelope: unsupported encoding ${String(encoding)}`);
-    }
-    if (!('value' in (value as object))) {
-      throw new Error('Invalid torch.tensor envelope: missing value');
-    }
-    const nested = (value as { value: unknown }).value;
-    if (!isObject(nested) || (nested as { __tywrap__?: unknown }).__tywrap__ !== 'ndarray') {
-      throw new Error('Invalid torch.tensor envelope: value must be an ndarray envelope');
-    }
-    const decoded = recurse(nested);
-    const shapeValue = (value as { shape?: unknown }).shape;
-    const shape = isNumberArray(shapeValue) ? shapeValue : undefined;
-    const dtypeValue = (value as { dtype?: unknown }).dtype;
-    const dtype = typeof dtypeValue === 'string' ? dtypeValue : undefined;
-    const deviceValue = (value as { device?: unknown }).device;
-    const device = typeof deviceValue === 'string' ? deviceValue : undefined;
+  const indices = value.indices;
+  const indptr = value.indptr;
+  if (!Array.isArray(indices) || !Array.isArray(indptr)) {
+    throw new Error('Invalid scipy.sparse envelope: csr/csc requires indices and indptr arrays');
+  }
+  return {
+    format,
+    shape,
+    data,
+    indices,
+    indptr,
+    dtype,
+  } satisfies SparseMatrix;
+};
+
+const decodeTorchTensorEnvelope: EnvelopeHandler = <T>(
+  value: { [k: string]: unknown },
+  _decodeArrow: (bytes: Uint8Array) => MaybePromise<T>,
+  recurse: (value: unknown) => MaybePromise<T | unknown>
+): MaybePromise<T | unknown> => {
+  const encoding = value.encoding;
+  if (encoding !== 'ndarray') {
+    throw new Error(`Invalid torch.tensor envelope: unsupported encoding ${String(encoding)}`);
+  }
+  if (!('value' in value)) {
+    throw new Error('Invalid torch.tensor envelope: missing value');
+  }
+  const nested = value.value;
+  if (!isObject(nested) || (nested as { __tywrap__?: unknown }).__tywrap__ !== 'ndarray') {
+    throw new Error('Invalid torch.tensor envelope: value must be an ndarray envelope');
+  }
+  const decoded = recurse(nested);
+  const shapeValue = value.shape;
+  const shape = isNumberArray(shapeValue) ? shapeValue : undefined;
+  const dtypeValue = value.dtype;
+  const dtype = typeof dtypeValue === 'string' ? dtypeValue : undefined;
+  const deviceValue = value.device;
+  const device = typeof deviceValue === 'string' ? deviceValue : undefined;
 
-    if (isPromiseLike(decoded)) {
-      return decoded.then(data => ({ data, shape, dtype, device })) as Promise<T | unknown>;
-    }
-    return { data: decoded, shape, dtype, device } satisfies TorchTensor;
+  if (isPromiseLike(decoded)) {
+    return decoded.then(data => ({ data, shape, dtype, device })) as Promise<T | unknown>;
   }
+  return { data: decoded, shape, dtype, device } satisfies TorchTensor;
+};
 
-  if (marker === 'sklearn.estimator') {
-    const encoding = (value as { encoding?: unknown }).encoding;
-    if (encoding !== 'json') {
-      throw new Error(
-        `Invalid sklearn.estimator envelope: unsupported encoding ${String(encoding)}`
-      );
-    }
-    const className = (value as { className?: unknown }).className;
-    const module = (value as { module?: unknown }).module;
-    const params = (value as { params?: unknown }).params;
-    if (typeof className !== 'string' || typeof module !== 'string' || !isObject(params)) {
-      throw new Error(
-        'Invalid sklearn.estimator envelope: expected className/module strings + params object'
-      );
-    }
-    const versionValue = (value as { version?: unknown }).version;
-    if (versionValue !== undefined && typeof versionValue !== 'string') {
-      throw new Error('Invalid sklearn.estimator envelope: version must be a string when provided');
-    }
-    const version = typeof versionValue === 'string' ? versionValue : undefined;
-    return {
-      className,
-      module,
-      version,
-      params,
-    } satisfies SklearnEstimator;
+const decodeSklearnEstimatorEnvelope: EnvelopeHandler = value => {
+  const encoding = value.encoding;
+  if (encoding !== 'json') {
+    throw new Error(`Invalid sklearn.estimator envelope: unsupported encoding ${String(encoding)}`);
+  }
+  const className = value.className;
+  const module = value.module;
+  const params = value.params;
+  if (typeof className !== 'string' || typeof module !== 'string' || !isObject(params)) {
+    throw new Error(
+      'Invalid sklearn.estimator envelope: expected className/module strings + params object'
+    );
+  }
+  const versionValue = value.version;
+  if (versionValue !== undefined && typeof versionValue !== 'string') {
+    throw new Error('Invalid sklearn.estimator envelope: version must be a string when provided');
+  }
+  const version = typeof versionValue === 'string' ? versionValue : undefined;
+  return {
+    className,
+    module,
+    version,
+    params,
+  } satisfies SklearnEstimator;
+};
+
+// Why: dispatch over the __tywrap__ typeTag instead of a long if-chain so each type's
+// decode logic lives in one focused handler. The typeTag strings are the on-the-wire keys
+// emitted by the Python bridge and MUST stay byte-identical. A Map keyed by the typeTag
+// avoids prototype-chain lookups when dispatching on attacker-controlled typeTag strings.
+const ENVELOPE_HANDLERS: ReadonlyMap<string, EnvelopeHandler> = new Map([
+  ['dataframe', decodeDataframeEnvelope],
+  ['series', decodeSeriesEnvelope],
+  ['ndarray', decodeNdarrayEnvelope],
+  ['scipy.sparse', decodeScipySparseEnvelope],
+  ['torch.tensor', decodeTorchTensorEnvelope],
+  ['sklearn.estimator', decodeSklearnEstimatorEnvelope],
+]);
+
+function decodeEnvelopeCore<T>(
+  value: unknown,
+  decodeArrow: (bytes: Uint8Array) => MaybePromise<T>,
+  recurse: (value: unknown) => MaybePromise<T | unknown>
+): MaybePromise<T | unknown> {
+  if (!isObject(value)) {
+    return value;
+  }
+  const typeTag = (value as { __tywrap__?: unknown }).__tywrap__;
+  if (typeof typeTag !== 'string') {
+    return value as unknown;
+  }
+
+  const handler = ENVELOPE_HANDLERS.get(typeTag);
+  if (!handler) {
+    return value as unknown;
   }
 
-  return value as unknown;
+  assertCodecVersion(value as { codecVersion?: unknown }, typeTag);
+  return handler(value, decodeArrow, recurse);
 }
 
 function decodeEnvelope<T>(value: unknown, decodeArrow: (bytes: Uint8Array) => T): T | unknown {

package/src/version.ts

@@ -0,0 +1,12 @@
+/**
+ * AUTO-GENERATED — DO NOT EDIT.
+ *
+ * Source: package.json (version field)
+ * Generator: scripts/generate-version.mjs (runs in `npm run build`)
+ *
+ * Single-sources the package version so the public API can re-export it without
+ * importing package.json from outside tsconfig `rootDir`.
+ * Regenerate with: node scripts/generate-version.mjs
+ */
+
+export const VERSION: string = "0.6.0";

package/dist/core/analyzer.d.ts

@@ -1,64 +0,0 @@
-/**
- * PyAnalyzer - Python AST analysis and type extraction
- */
-import type { SyntaxNode } from 'tree-sitter';
-import type { AnalysisResult, PythonFunction, PythonClass, PythonType } from '../types/index.js';
-export declare class PyAnalyzer {
-    private parser;
-    private initialized;
-    constructor();
-    /**
-     * Initialize the tree-sitter parser with Python grammar
-     */
-    initialize(): Promise<void>;
-    /**
-     * Analyze Python module source code and extract structure with caching
-     */
-    analyzePythonModule(source: string, modulePath?: string): Promise<AnalysisResult>;
-    /**
-     * Extract function definitions from AST
-     */
-    extractFunctions(node: SyntaxNode): Promise<PythonFunction[]>;
-    /**
-     * Extract class definitions from AST
-     */
-    extractClasses(node: SyntaxNode): Promise<PythonClass[]>;
-    /**
-     * Extract single function from function_definition node
-     */
-    private extractFunction;
-    /**
-     * Extract single class from class_definition node
-     */
-    private extractClass;
-    /**
-     * Extract function parameters from parameters node
-     */
-    private extractParameters;
-    /**
-     * Parse type annotation node into PythonType
-     */
-    parseTypeAnnotation(node: SyntaxNode): PythonType;
-    private parseGenericType;
-    private parseUnionType;
-    private parseGenericArguments;
-    /**
-     * Extract import statements
-     */
-    private extractImports;
-    /**
-     * Utility methods
-     */
-    private findNodesByType;
-    private findDirectDefinitions;
-    private extractModuleName;
-    private extractDecorators;
-    private extractDocstring;
-    private containsYield;
-    private extractBases;
-    private extractProperty;
-    private extractExports;
-    private collectSyntaxErrors;
-    private generateStatistics;
-}
-//# sourceMappingURL=analyzer.d.ts.map

package/dist/core/analyzer.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"analyzer.d.ts","sourceRoot":"","sources":["../../src/core/analyzer.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAI9C,OAAO,KAAK,EACV,cAAc,EAKd,cAAc,EACd,WAAW,EAEX,UAAU,EAIX,MAAM,mBAAmB,CAAC;AAS3B,qBAAa,UAAU;IACrB,OAAO,CAAC,MAAM,CAAS;IACvB,OAAO,CAAC,WAAW,CAAS;;IAM5B;;OAEG;IACG,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC;IAajC;;OAEG;IACG,mBAAmB,CAAC,MAAM,EAAE,MAAM,EAAE,UAAU,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,cAAc,CAAC;IAiFvF;;OAEG;IACG,gBAAgB,CAAC,IAAI,EAAE,UAAU,GAAG,OAAO,CAAC,cAAc,EAAE,CAAC;IAiBnE;;OAEG;IACG,cAAc,CAAC,IAAI,EAAE,UAAU,GAAG,OAAO,CAAC,WAAW,EAAE,CAAC;IAiB9D;;OAEG;YACW,eAAe;IAyC7B;;OAEG;YACW,YAAY;IAuD1B;;OAEG;IACH,OAAO,CAAC,iBAAiB;IAkHzB;;OAEG;IACH,mBAAmB,CAAC,IAAI,EAAE,UAAU,GAAG,UAAU;IA0FjD,OAAO,CAAC,gBAAgB;IAqBxB,OAAO,CAAC,cAAc;IAatB,OAAO,CAAC,qBAAqB;IAiC7B;;OAEG;IACH,OAAO,CAAC,cAAc;IAwFtB;;OAEG;IACH,OAAO,CAAC,eAAe;IAqBvB,OAAO,CAAC,qBAAqB;IAoB7B,OAAO,CAAC,iBAAiB;IAQzB,OAAO,CAAC,iBAAiB;IAYzB,OAAO,CAAC,gBAAgB;IAyBxB,OAAO,CAAC,aAAa;IAKrB,OAAO,CAAC,YAAY;IAUpB,OAAO,CAAC,eAAe;IAavB,OAAO,CAAC,cAAc;IAiBtB,OAAO,CAAC,mBAAmB;IAe3B,OAAO,CAAC,kBAAkB;CA0B3B"}