nodepyx 1.0.0

package/LICENSE

@@ -0,0 +1,22 @@
+MIT License
+
+Copyright (c) 2026 nodepyx contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+

package/README.md

@@ -0,0 +1,399 @@
+# nodepyx
+
+> **Run Python libraries from Node.js as if they were native** — embed CPython in-process with full TypeScript types, Proxy-based API, async/await support, and Next.js integration.
+
+[![npm version](https://img.shields.io/npm/v/nodepyx.svg)](https://www.npmjs.com/package/nodepyx)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+[![Node.js](https://img.shields.io/badge/Node.js-≥18-green.svg)](https://nodejs.org)
+[![Python](https://img.shields.io/badge/Python-3.8%2B-blue.svg)](https://python.org)
+---
+
+
+<img src="assets/images/nodepyx.jpg" width="1024" height="636">
+
+
+
+## Why nodepyx?
+
+Traditional Python↔Node.js bridges spawn a **separate Python process** and communicate via stdin/stdout or HTTP — introducing serialization overhead, process startup latency, and complex lifecycle management.
+
+**nodepyx embeds CPython directly inside the Node.js process** via a native N-API addon. Every Python call happens in-process: no IPC, no child processes, no HTTP servers.
+
+| Feature | nodepyx | python-shell / pythonia | gRPC/HTTP |
+|---------|--------|------------------------|-----------|
+| In-process (zero IPC) | ✅ | ❌ | ❌ |
+| TypeScript types | ✅ Full .d.ts | Partial | Manual |
+| `await` on Python objects | ✅ Proxy thenable | ❌ | ❌ |
+| NumPy zero-copy | ✅ SharedArrayBuffer | ❌ | ❌ |
+| DataFrame native | ✅ DataFrameResult | ❌ | ❌ |
+| Next.js integration | ✅ withnodepyx() | ❌ | ❌ |
+| Auto venv/conda | ✅ | Partial | ❌ |
+
+---
+
+## Quick Start
+
+```bash
+npm install nodepyx
+```
+
+```typescript
+import { init, py } from 'nodepyx';
+
+await init({
+  virtualenv: {
+    path:        './.venv',
+    packages:    ['pandas', 'numpy', 'scikit-learn'],
+    autoInstall: true,
+  },
+});
+
+// Import Python modules — works exactly like Python `import`
+const pd  = await py.import('pandas');
+const np  = await py.import('numpy');
+
+// Call functions with await
+const df  = await pd.read_csv('data.csv');
+const arr = await np.arange(100);          // → Float64Array
+
+// Chain attribute access
+const mean = await df.describe().loc['mean'];
+
+// Iterate Python generators
+for await (const row of df.iterrows()) {
+  console.log(row);
+}
+```
+
+---
+
+## Installation
+
+### Prerequisites
+
+- **Node.js** ≥ 18.0.0
+- **Python** 3.8 – 3.12 (auto-detected; or set `nodepyx_PYTHON`)
+- **C++ build tools** (for native addon)
+  - Linux: `gcc`, `g++`, `make`, `python3`
+  - macOS: Xcode Command Line Tools (`xcode-select --install`)
+  - Windows: Visual Studio Build Tools + Python
+
+```bash
+# Install from npm
+npm install nodepyx
+
+# Or with pre-built binary (skips compilation)
+nodepyx_SKIP_BUILD=1 npm install nodepyx && npm run download-prebuilds
+```
+
+---
+
+## Configuration
+
+```typescript
+import { init } from 'nodepyx';
+
+await init({
+  // Python executable (default: auto-detect)
+  pythonExecutable: '/usr/bin/python3.11',
+
+  // Virtualenv (recommended)
+  virtualenv: {
+    path:        './.venv',
+    packages:    ['pandas>=2.0', 'numpy>=1.24', 'scikit-learn'],
+    autoInstall: true,    // install missing packages automatically
+    autoCreate:  true,    // create venv if it does not exist
+  },
+
+  // OR use Conda
+  conda: {
+    envName:  'my-env',
+    packages: ['pytorch', 'torchvision'],
+  },
+
+  // Thread pool for GIL management
+  threadPoolSize: 4,        // default: 4
+
+  // Logging
+  logLevel: 'info',         // 'debug' | 'info' | 'warn' | 'error'
+
+  // Memory limits
+  memory: {
+    heapLimitMB: 2048,
+    gcThresholdMB: 512,
+  },
+});
+```
+
+---
+
+## API Reference
+
+### Lifecycle
+
+```typescript
+import { init, shutdown, isInitialized } from 'nodepyx';
+
+await init(config?);      // Initialize Python runtime
+await shutdown();         // Release all Python resources
+isInitialized();          // → boolean
+```
+
+### `py` — Main Proxy Object
+
+```typescript
+import { py } from 'nodepyx';
+
+// Import a module
+const np = await py.import('numpy');
+
+// Evaluate a Python expression
+const result = await py.eval('1 + 2 + 3');  // → 6
+
+// Execute statements
+await py.exec(`
+  import sys
+  print(sys.version)
+`);
+
+// Run a .py file
+await py.runFile('./my_script.py');
+
+// Install packages at runtime
+await py.installPackages(['requests', 'httpx']);
+```
+
+### Proxy API
+
+Every Python object returned by nodepyx is a **JavaScript Proxy** with full `await` support:
+
+```typescript
+const pd = await py.import('pandas');
+
+// Attribute access
+const version = await pd.__version__;      // string
+
+// Method calls
+const df = await pd.DataFrame({ a: [1,2,3], b: [4,5,6] });
+const shape = await df.shape;              // [3, 2]
+const desc  = await df.describe();         // DataFrameResult
+
+// Chained calls
+const top5 = await df.sort_values('a', { ascending: false }).head(5);
+
+// Indexing  (df['column'])
+const col = await df['a'];                 // SeriesResult
+```
+
+### NumPy Arrays
+
+```typescript
+const np  = await py.import('numpy');
+const arr = await np.linspace(0, 1, 100);  // NumPyArrayResult
+
+// NumPyArrayResult interface:
+arr.data     // Float64Array (or Int32Array, Uint8Array, etc.)
+arr.shape    // number[]  — e.g. [100] or [3, 4]
+arr.dtype    // 'float64' | 'float32' | 'int32' | ...
+arr.ndim     // number
+arr.size     // number — total element count
+
+// Send TypedArrays back to Python
+const NumpyBridge = new NumpyBridge();
+const wire = NumpyBridge.serializeTypedArray(new Float64Array([1,2,3]), { dtype:'float64', itemsize:8 }, [3]);
+```
+
+### Pandas DataFrames
+
+```typescript
+const pd = await py.import('pandas');
+const df = await pd.read_csv('data.csv');  // DataFrameResult
+
+// DataFrameResult interface:
+df.columns   // string[]
+df.records   // Record<string, unknown>[]  — one object per row
+df.index     // unknown[]
+df.dtypes    // Record<string, string>
+df.shape     // [rows, cols]
+
+// Static helpers
+import { DataFrameBridge } from 'nodepyx';
+const cols = DataFrameBridge.toColumnArrays(df);  // column-keyed arrays
+const filtered = DataFrameBridge.filterRows(df, row => row.score > 0.9);
+const stats = DataFrameBridge.describeColumn(df, 'price');  // {count,mean,std,min,max}
+```
+
+### Error Handling
+
+```typescript
+import { PythonError, isPythonError, isPythonErrorOfType } from 'nodepyx';
+
+try {
+  await py.eval('1 / 0');
+} catch (err) {
+  if (isPythonError(err)) {
+    console.log(err.pythonType);   // 'ZeroDivisionError'
+    console.log(err.message);      // '[Python ZeroDivisionError] division by zero'
+    console.log(err.traceback);    // Full Python traceback
+  }
+}
+
+// Type-specific check
+if (isPythonErrorOfType(err, 'ImportError')) { ... }
+```
+
+---
+
+## Environment Management
+
+### Virtualenv (recommended)
+
+```typescript
+import { VenvManager } from 'nodepyx';
+
+const mgr = new VenvManager({
+  venvPath:   './.venv',
+  packages:   ['pandas', 'numpy', 'scikit-learn'],
+  autoCreate: true,
+});
+
+const result = await mgr.setup();
+console.log('Installed:', result.installedPackages);
+console.log('Venv python:', result.pythonExecutable);
+```
+
+### Conda
+
+```typescript
+import { CondaManager } from 'nodepyx';
+
+const conda = new CondaManager({ envName: 'ml-env', packages: ['pytorch', 'pip::some-pip-package'] });
+const result = await conda.setup();
+```
+
+### PackageInstaller
+
+```typescript
+import { PackageInstaller } from 'nodepyx';
+
+const pip = new PackageInstaller({ pythonExecutable: '/usr/bin/python3' });
+
+// Install with progress events
+pip.on('progress', (ev) => console.log(ev.package, ev.status));
+
+const result = await pip.install(['pandas>=2.0', 'numpy>=1.24']);
+console.log('installed:', result.installed);
+console.log('already present:', result.alreadyInstalled);
+```
+
+---
+
+## TypeScript Stubs
+
+```bash
+# Generate .d.ts stubs for Python modules
+npx nodepyx-stubs pandas numpy sklearn torch
+
+# Regenerate all cached stubs
+npx nodepyx-stubs --all
+
+# List cached stubs
+npx nodepyx-stubs --list
+```
+
+Then in your TypeScript code:
+```typescript
+import type { DataFrame } from 'nodepyx/pandas';   // full IDE autocomplete
+import type { ndarray }   from 'nodepyx/numpy';
+```
+
+---
+
+## Next.js Integration
+
+```js
+// next.config.js
+const { withnodepyx } = require('nodepyx/next');
+
+module.exports = withnodepyx({
+  // your Next.js config
+}, {
+  virtualenv: { path: './.venv', packages: ['pandas'], autoInstall: true },
+});
+```
+
+```typescript
+// app/api/python/route.ts  (Server Route — Node.js runtime only)
+import { NextResponse } from 'next/server';
+import { init, evalPython } from 'nodepyx';
+
+let ready = false;
+async function ensureReady() {
+  if (!ready) { await init(); ready = true; }
+}
+
+export async function GET() {
+  await ensureReady();
+  const result = await evalPython('list(range(10))');
+  return NextResponse.json(result);
+}
+```
+
+```tsx
+// Client component
+'use client';
+import { usePython } from 'nodepyx/next';
+
+export function Chart() {
+  const { data, loading, run } = usePython(async (py) => {
+    const np = await py.import('numpy');
+    return (np as any).random.randn(100).tolist();
+  });
+
+  return <button onClick={run}>{loading ? '…' : 'Generate'}</button>;
+}
+```
+
+---
+
+## Plugins
+
+```typescript
+import { init } from 'nodepyx';
+import type { nodepyxPlugin } from 'nodepyx';
+
+const myPlugin: nodepyxPlugin = {
+  name: 'my-plugin',
+  version: '1.0.0',
+  supportedModules: ['my_lib'],
+  handledTypes: ['MySpecialType'],
+
+  async onInit(ctx) {
+    ctx.registerTypeHandler('MySpecialType', (raw, typeHint) => {
+      // Transform raw wire dict into a JS value
+      return { specialData: JSON.parse(raw.data as string) };
+    });
+  },
+};
+
+await init({ plugins: [myPlugin] });
+```
+
+---
+
+## Supported Python Versions
+
+| Python | Status |
+|--------|--------|
+| 3.12   | ✅ Recommended |
+| 3.11   | ✅ Supported |
+| 3.10   | ✅ Supported |
+| 3.9    | ✅ Supported |
+| 3.8    | ✅ Supported (EOL) |
+| 3.7    | ❌ Not supported |
+
+---
+
+## License
+
+MIT © nodepyx contributors

package/binding.gyp

@@ -0,0 +1,73 @@
+{
+  "targets": [{
+    "target_name": "nodepyx_addon",
+    "sources": [
+      "src/native/nodepyx_addon.cpp",
+      "src/native/python_bridge.cpp",
+      "src/native/type_converter.cpp",
+      "src/native/thread_pool.cpp",
+      "src/native/gil_guard.cpp"
+    ],
+    "include_dirs": [
+      "<!@(node -p \"require('node-addon-api').include\")"
+    ],
+    "cflags_cc": [
+      "-std=c++17",
+      "-O2",
+      "-Wall",
+      "-Wextra",
+      "-Wno-unused-parameter"
+    ],
+    "defines": [
+      "NAPI_DISABLE_CPP_EXCEPTIONS",
+      "NAPI_VERSION=8",
+      "PY_SSIZE_T_CLEAN"
+    ],
+    "conditions": [
+      ["OS=='linux'", {
+        "include_dirs+": [
+          "<!@(python3-config --includes 2>/dev/null | sed 's/-I//g' | tr ' ' '\\n' | head -1)"
+        ],
+        "libraries": [
+          "<!@(python3-config --ldflags 2>/dev/null)",
+          "<!@(python3-config --libs 2>/dev/null)"
+        ],
+        "cflags_cc": [
+          "-fno-exceptions",
+          "-fvisibility=hidden"
+        ]
+      }],
+      ["OS=='mac'", {
+        "include_dirs+": [
+          "<!@(python3-config --includes 2>/dev/null | sed 's/-I//g' | tr ' ' '\\n' | head -1)"
+        ],
+        "libraries": [
+          "<!@(python3-config --ldflags 2>/dev/null)"
+        ],
+        "xcode_settings": {
+          "MACOSX_DEPLOYMENT_TARGET": "11.0",
+          "OTHER_CFLAGS": ["-std=c++17", "-stdlib=libc++"],
+          "GCC_ENABLE_CPP_EXCEPTIONS": "NO",
+          "OTHER_LDFLAGS": [
+            "<!@(python3-config --libs 2>/dev/null)"
+          ]
+        }
+      }],
+      ["OS=='win'", {
+        "include_dirs+": [
+          "<!@(python -c \"import sysconfig; print(sysconfig.get_path('include'))\" 2>nul)"
+        ],
+        "libraries": [
+          "<!@(python -c \"import sysconfig; import os; print(os.path.join(sysconfig.get_config_var('LIBDIR') or '', sysconfig.get_config_var('LDLIBRARY') or 'python3.lib'))\" 2>nul)"
+        ],
+        "msvs_settings": {
+          "VCCLCompilerTool": {
+            "ExceptionHandling": 0,
+            "AdditionalOptions": ["/std:c++17"]
+          }
+        }
+      }]
+    ]
+  }]
+}
+

package/dist/core/PyCallable.d.ts

@@ -0,0 +1,65 @@
+/**
+ * nodepyx — PyCallable
+ * Represents a Python callable (function, method, class constructor).
+ * Extends PyProxy with call metadata and convenience methods.
+ */
+import { PyProxy } from './PyProxy';
+import type { NativeAddon } from '../types/addon';
+import type { PyObjectId, AttributePath, PyCallableInfo } from '../types/python';
+/**
+ * PyCallable — wraps a Python function or method.
+ *
+ * @example
+ * ```typescript
+ * const np = await py.import('numpy');
+ * const zeros = await np.zeros;  // PyCallable
+ * const arr = await zeros([3, 3], { dtype: 'float64' });
+ *
+ * // Or more concisely:
+ * const arr2 = await np.zeros([3, 3]);
+ * ```
+ */
+export declare class PyCallable extends PyProxy {
+    private readonly _callableName;
+    private _info;
+    constructor(objectId: PyObjectId, path: AttributePath, callableName: string, addon: NativeAddon, callTimeout?: number);
+    /** Callable name */
+    get callableName(): string;
+    /**
+     * Call the callable with given arguments.
+     * Same as using the callable directly (proxy syntax).
+     *
+     * @example
+     * ```typescript
+     * const result = await callable.invoke([1, 2, 3], { axis: 0 });
+     * // equivalent to: await callable([1, 2, 3], { axis: 0 })
+     * ```
+     */
+    invoke(...args: unknown[]): Promise<unknown>;
+    /**
+     * Call with explicit positional args and keyword args.
+     *
+     * @example
+     * ```typescript
+     * const result = await callable.call([1, 2, 3], { axis: 0, keepdims: true });
+     * ```
+     */
+    call(args: unknown[], kwargs?: Record<string, unknown>): Promise<unknown>;
+    /**
+     * Partially apply arguments (like functools.partial in Python).
+     *
+     * @example
+     * ```typescript
+     * const readCsvUtf8 = await pd.read_csv.partial({ encoding: 'utf-8' });
+     * const df = await readCsvUtf8('data.csv');
+     * ```
+     */
+    partial(...partialArgs: unknown[]): PyCallable;
+    /**
+     * Get introspection information about this callable.
+     */
+    getInfo(): Promise<PyCallableInfo | null>;
+    static fromProxy(proxy: PyProxy, name: string): PyCallable;
+    toString(): string;
+}
+//# sourceMappingURL=PyCallable.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"PyCallable.d.ts","sourceRoot":"","sources":["../../src/core/PyCallable.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAE,OAAO,EAAoB,MAAM,WAAW,CAAC;AACtD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAC;AAClD,OAAO,KAAK,EAAE,UAAU,EAAE,aAAa,EAAE,cAAc,EAAE,MAAM,iBAAiB,CAAC;AAEjF;;;;;;;;;;;;GAYG;AACH,qBAAa,UAAW,SAAQ,OAAO;IACrC,OAAO,CAAC,QAAQ,CAAC,aAAa,CAAS;IACvC,OAAO,CAAC,KAAK,CAA+B;gBAG1C,QAAQ,EAAE,UAAU,EACpB,IAAI,EAAE,aAAa,EACnB,YAAY,EAAE,MAAM,EACpB,KAAK,EAAE,WAAW,EAClB,WAAW,CAAC,EAAE,MAAM;IAatB,oBAAoB;IACpB,IAAI,YAAY,IAAI,MAAM,CAEzB;IAED;;;;;;;;;OASG;IACG,MAAM,CAAC,GAAG,IAAI,EAAE,OAAO,EAAE,GAAG,OAAO,CAAC,OAAO,CAAC;IAIlD;;;;;;;OAOG;IACG,IAAI,CAAC,IAAI,EAAE,OAAO,EAAE,EAAE,MAAM,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,OAAO,CAAC,OAAO,CAAC;IAO/E;;;;;;;;OAQG;IACH,OAAO,CAAC,GAAG,WAAW,EAAE,OAAO,EAAE,GAAG,UAAU;IAuB9C;;OAEG;IACG,OAAO,IAAI,OAAO,CAAC,cAAc,GAAG,IAAI,CAAC;IAO/C,MAAM,CAAC,SAAS,CAAC,KAAK,EAAE,OAAO,EAAE,IAAI,EAAE,MAAM,GAAG,UAAU;IAWjD,QAAQ,IAAI,MAAM;CAG5B"}

package/dist/core/PyCallable.js

@@ -0,0 +1,109 @@
+"use strict";
+/**
+ * nodepyx — PyCallable
+ * Represents a Python callable (function, method, class constructor).
+ * Extends PyProxy with call metadata and convenience methods.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PyCallable = void 0;
+const PyProxy_1 = require("./PyProxy");
+/**
+ * PyCallable — wraps a Python function or method.
+ *
+ * @example
+ * ```typescript
+ * const np = await py.import('numpy');
+ * const zeros = await np.zeros;  // PyCallable
+ * const arr = await zeros([3, 3], { dtype: 'float64' });
+ *
+ * // Or more concisely:
+ * const arr2 = await np.zeros([3, 3]);
+ * ```
+ */
+class PyCallable extends PyProxy_1.PyProxy {
+    _callableName;
+    _info = null;
+    constructor(objectId, path, callableName, addon, callTimeout) {
+        super({
+            objectId,
+            path,
+            addon,
+            isResolved: false,
+            callTimeout,
+            childCache: new Map(),
+        });
+        this._callableName = callableName;
+    }
+    /** Callable name */
+    get callableName() {
+        return this._callableName;
+    }
+    /**
+     * Call the callable with given arguments.
+     * Same as using the callable directly (proxy syntax).
+     *
+     * @example
+     * ```typescript
+     * const result = await callable.invoke([1, 2, 3], { axis: 0 });
+     * // equivalent to: await callable([1, 2, 3], { axis: 0 })
+     * ```
+     */
+    async invoke(...args) {
+        return this(...args);
+    }
+    /**
+     * Call with explicit positional args and keyword args.
+     *
+     * @example
+     * ```typescript
+     * const result = await callable.call([1, 2, 3], { axis: 0, keepdims: true });
+     * ```
+     */
+    async call(args, kwargs) {
+        if (kwargs) {
+            return this(...args, kwargs);
+        }
+        return this(...args);
+    }
+    /**
+     * Partially apply arguments (like functools.partial in Python).
+     *
+     * @example
+     * ```typescript
+     * const readCsvUtf8 = await pd.read_csv.partial({ encoding: 'utf-8' });
+     * const df = await readCsvUtf8('data.csv');
+     * ```
+     */
+    partial(...partialArgs) {
+        const internal = this[PyProxy_1.PYPROXY_INTERNAL];
+        const callableName = `${this._callableName}(partial)`;
+        const wrapper = new PyCallable(internal.objectId, internal.path, callableName, internal.addon, internal.callTimeout);
+        // Override: always prepend partialArgs (use arrow to capture outer `this` lexically)
+        const callSelf = (...a) => this(...a);
+        const overrideProxy = new Proxy(wrapper, {
+            apply(_target, _thisArg, args) {
+                return callSelf(...partialArgs, ...args);
+            },
+        });
+        return overrideProxy;
+    }
+    /**
+     * Get introspection information about this callable.
+     */
+    async getInfo() {
+        if (this._info) {
+            return this._info;
+        }
+        // Not yet implemented — would require Python introspection
+        return null;
+    }
+    static fromProxy(proxy, name) {
+        const internal = proxy[PyProxy_1.PYPROXY_INTERNAL];
+        return new PyCallable(internal.objectId, internal.path, name, internal.addon, internal.callTimeout);
+    }
+    toString() {
+        return `[PyCallable '${this._callableName}' id=${this[PyProxy_1.PYPROXY_INTERNAL].objectId}]`;
+    }
+}
+exports.PyCallable = PyCallable;
+//# sourceMappingURL=PyCallable.js.map

package/dist/core/PyCallable.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"PyCallable.js","sourceRoot":"","sources":["../../src/core/PyCallable.ts"],"names":[],"mappings":";AAAA;;;;GAIG;;;AAEH,uCAAsD;AAItD;;;;;;;;;;;;GAYG;AACH,MAAa,UAAW,SAAQ,iBAAO;IACpB,aAAa,CAAS;IAC/B,KAAK,GAA0B,IAAI,CAAC;IAE5C,YACE,QAAoB,EACpB,IAAmB,EACnB,YAAoB,EACpB,KAAkB,EAClB,WAAoB;QAEpB,KAAK,CAAC;YACJ,QAAQ;YACR,IAAI;YACJ,KAAK;YACL,UAAU,EAAE,KAAK;YACjB,WAAW;YACX,UAAU,EAAE,IAAI,GAAG,EAAE;SACtB,CAAC,CAAC;QACH,IAAI,CAAC,aAAa,GAAG,YAAY,CAAC;IACpC,CAAC;IAED,oBAAoB;IACpB,IAAI,YAAY;QACd,OAAO,IAAI,CAAC,aAAa,CAAC;IAC5B,CAAC;IAED;;;;;;;;;OASG;IACH,KAAK,CAAC,MAAM,CAAC,GAAG,IAAe;QAC7B,OAAQ,IAAgD,CAAC,GAAG,IAAI,CAAC,CAAC;IACpE,CAAC;IAED;;;;;;;OAOG;IACH,KAAK,CAAC,IAAI,CAAC,IAAe,EAAE,MAAgC;QAC1D,IAAI,MAAM,EAAE,CAAC;YACX,OAAQ,IAAgD,CAAC,GAAG,IAAI,EAAE,MAAM,CAAC,CAAC;QAC5E,CAAC;QACD,OAAQ,IAAgD,CAAC,GAAG,IAAI,CAAC,CAAC;IACpE,CAAC;IAED;;;;;;;;OAQG;IACH,OAAO,CAAC,GAAG,WAAsB;QAC/B,MAAM,QAAQ,GAAG,IAAI,CAAC,0BAAgB,CAAC,CAAC;QACxC,MAAM,YAAY,GAAG,GAAG,IAAI,CAAC,aAAa,WAAW,CAAC;QACtD,MAAM,OAAO,GAAG,IAAI,UAAU,CAC5B,QAAQ,CAAC,QAAQ,EACjB,QAAQ,CAAC,IAAI,EACb,YAAY,EACZ,QAAQ,CAAC,KAAK,EACd,QAAQ,CAAC,WAAW,CACrB,CAAC;QAEF,qFAAqF;QACrF,MAAM,QAAQ,GAAG,CAAC,GAAG,CAAY,EAAE,EAAE,CAClC,IAAgD,CAAC,GAAG,CAAC,CAAC,CAAC;QAC1D,MAAM,aAAa,GAAG,IAAI,KAAK,CAAC,OAAO,EAAE;YACvC,KAAK,CAAC,OAAO,EAAE,QAAQ,EAAE,IAAe;gBACtC,OAAO,QAAQ,CAAC,GAAG,WAAW,EAAE,GAAG,IAAI,CAAC,CAAC;YAC3C,CAAC;SACF,CAAC,CAAC;QAEH,OAAO,aAA2B,CAAC;IACrC,CAAC;IAED;;OAEG;IACH,KAAK,CAAC,OAAO;QACX,IAAI,IAAI,CAAC,KAAK,EAAE,CAAC;YAAA,OAAO,IAAI,CAAC,KAAK,CAAC;QAAA,CAAC;QAEpC,6DAA6D;QAC7D,OAAO,IAAI,CAAC;IACd,CAAC;IAED,MAAM,CAAC,SAAS,CAAC,KAAc,EAAE,IAAY;QAC3C,MAAM,QAAQ,GAAG,KAAK,CAAC,0BAAgB,CAAC,CAAC;QACzC,OAAO,IAAI,UAAU,CACnB,QAAQ,CAAC,QAAQ,EACjB,QAAQ,CAAC,IAAI,EACb,IAAI,EACJ,QAAQ,CAAC,KAAK,EACd,QAAQ,CAAC,WAAW,CACrB,CAAC;IACJ,CAAC;IAEQ,QAAQ;QACf,OAAO,gBAAgB,IAAI,CAAC,aAAa,QAAQ,IAAI,CAAC,0BAAgB,CAAC,CAAC,QAAQ,GAAG,CAAC;IACtF,CAAC;CACF;AAhHD,gCAgHC"}