@dexto/core 1.4.0 → 1.5.1

package/dist/llm/providers/local/ai-sdk-adapter.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Vercel AI SDK adapter for node-llama-cpp.
+ *
+ * This module creates a LanguageModelV2 implementation that wraps node-llama-cpp,
+ * allowing local GGUF models to be used with the Vercel AI SDK.
+ */
+import type { LanguageModelV2 } from '@ai-sdk/provider';
+/**
+ * Configuration for the local model AI SDK adapter.
+ */
+export interface LocalModelAdapterConfig {
+    /** Model ID from the local registry */
+    modelId: string;
+    /** Direct path to model file (optional, overrides modelId lookup) */
+    modelPath?: string;
+    /** Context window size (default: 4096) */
+    contextSize?: number;
+    /** Number of GPU layers to offload (-1 = all, 0 = CPU only) */
+    gpuLayers?: number;
+    /** Number of CPU threads */
+    threads?: number;
+}
+/**
+ * Create a Vercel AI SDK compatible LanguageModelV2 from a local GGUF model.
+ * This is a synchronous function that returns a LanguageModel with lazy initialization.
+ * The actual model loading happens on first use.
+ */
+export declare function createLocalLanguageModel(config: LocalModelAdapterConfig): LanguageModelV2;
+//# sourceMappingURL=ai-sdk-adapter.d.ts.map

package/dist/llm/providers/local/ai-sdk-adapter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ai-sdk-adapter.d.ts","sourceRoot":"","sources":["../../../../src/llm/providers/local/ai-sdk-adapter.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAIH,OAAO,KAAK,EACR,eAAe,EAOlB,MAAM,kBAAkB,CAAC;AAa1B;;GAEG;AACH,MAAM,WAAW,uBAAuB;IACpC,uCAAuC;IACvC,OAAO,EAAE,MAAM,CAAC;IAChB,qEAAqE;IACrE,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,0CAA0C;IAC1C,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,+DAA+D;IAC/D,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,4BAA4B;IAC5B,OAAO,CAAC,EAAE,MAAM,CAAC;CACpB;AA+FD;;;;GAIG;AACH,wBAAgB,wBAAwB,CAAC,MAAM,EAAE,uBAAuB,GAAG,eAAe,CAEzF"}

package/dist/llm/providers/local/ai-sdk-adapter.js

@@ -0,0 +1,278 @@
+import "../../../chunk-PTJYTZNU.js";
+import {
+  loadModel,
+  isNodeLlamaCppInstalled
+} from "./node-llama-provider.js";
+import { LocalModelError } from "./errors.js";
+import { getLocalModelById } from "./registry.js";
+import * as fs from "fs";
+import * as path from "path";
+import * as os from "os";
+function getModelsDirectory() {
+  return path.join(os.homedir(), ".dexto", "models");
+}
+function getInstalledModelInfo(modelId) {
+  const stateFile = path.join(getModelsDirectory(), "state.json");
+  try {
+    if (!fs.existsSync(stateFile)) {
+      return null;
+    }
+    const content = fs.readFileSync(stateFile, "utf-8");
+    const state = JSON.parse(content);
+    return state.installed[modelId] ?? null;
+  } catch {
+    return null;
+  }
+}
+function getCustomModelFilePath(modelId) {
+  const customModelsFile = path.join(getModelsDirectory(), "custom-models.json");
+  try {
+    if (!fs.existsSync(customModelsFile)) {
+      return null;
+    }
+    const content = fs.readFileSync(customModelsFile, "utf-8");
+    const storage = JSON.parse(content);
+    const customModel = storage.models.find(
+      (m) => m.name === modelId && m.provider === "local" && m.filePath
+    );
+    return customModel?.filePath ?? null;
+  } catch {
+    return null;
+  }
+}
+function createLocalLanguageModel(config) {
+  return new LocalLanguageModel(config);
+}
+class LocalLanguageModel {
+  specificationVersion = "v2";
+  provider = "local";
+  modelId;
+  // Local models don't support URL-based content natively
+  supportedUrls = {};
+  config;
+  session = null;
+  loadedModel = null;
+  initPromise = null;
+  deviceName = "Local";
+  constructor(config) {
+    this.modelId = config.modelId;
+    this.config = config;
+  }
+  /**
+   * Initialize the model lazily on first use.
+   */
+  async ensureInitialized() {
+    if (this.session) {
+      return;
+    }
+    if (this.initPromise) {
+      return this.initPromise;
+    }
+    this.initPromise = this.initialize();
+    return this.initPromise;
+  }
+  async initialize() {
+    const {
+      modelId,
+      modelPath: directPath,
+      contextSize,
+      // Let node-llama-cpp default to "auto" if not specified
+      gpuLayers = -1,
+      threads
+    } = this.config;
+    const isInstalled = await isNodeLlamaCppInstalled();
+    if (!isInstalled) {
+      throw LocalModelError.nodeLlamaNotInstalled();
+    }
+    let modelPath;
+    if (directPath) {
+      modelPath = directPath;
+    } else {
+      const installedModel = getInstalledModelInfo(modelId);
+      if (installedModel) {
+        modelPath = installedModel.filePath;
+      } else {
+        const customPath = getCustomModelFilePath(modelId);
+        if (customPath) {
+          modelPath = customPath;
+        } else {
+          const registryModel = getLocalModelById(modelId);
+          if (!registryModel) {
+            throw LocalModelError.modelNotFound(modelId);
+          }
+          throw LocalModelError.modelNotDownloaded(modelId);
+        }
+      }
+    }
+    const loadConfig = {
+      modelPath,
+      gpuLayers
+    };
+    if (contextSize !== void 0) {
+      loadConfig.contextSize = contextSize;
+    }
+    if (threads !== void 0) {
+      loadConfig.threads = threads;
+    }
+    this.loadedModel = await loadModel(loadConfig);
+    this.deviceName = this.loadedModel.gpuInfo.deviceName || "Local";
+    this.session = await this.loadedModel.createSession();
+  }
+  /**
+   * Non-streaming text generation (V2 interface).
+   */
+  async doGenerate(options) {
+    await this.ensureInitialized();
+    const prompt = this.formatPrompt(options);
+    const maxTokens = options.maxOutputTokens ?? 1024;
+    const temperature = options.temperature ?? 0.7;
+    const promptOptions = {
+      maxTokens,
+      temperature
+    };
+    if (options.abortSignal) {
+      promptOptions.signal = options.abortSignal;
+    }
+    const response = await this.session.prompt(prompt, promptOptions);
+    const inputTokens = Math.ceil(prompt.length / 4);
+    const outputTokens = Math.ceil(response.length / 4);
+    const content = [{ type: "text", text: response }];
+    const finishReason = "stop";
+    const usage = {
+      inputTokens,
+      outputTokens,
+      totalTokens: inputTokens + outputTokens
+    };
+    const warnings = [];
+    return {
+      content,
+      finishReason,
+      usage,
+      providerMetadata: {
+        local: {
+          device: this.deviceName
+        }
+      },
+      warnings
+    };
+  }
+  /**
+   * Streaming text generation (V2 interface).
+   */
+  async doStream(options) {
+    await this.ensureInitialized();
+    const prompt = this.formatPrompt(options);
+    const maxTokens = options.maxOutputTokens ?? 1024;
+    const temperature = options.temperature ?? 0.7;
+    const inputTokens = Math.ceil(prompt.length / 4);
+    let outputTokens = 0;
+    const session = this.session;
+    const textId = "text-0";
+    const streamPromptOptions = {
+      maxTokens,
+      temperature,
+      onToken: (_token) => {
+      }
+    };
+    if (options.abortSignal) {
+      streamPromptOptions.signal = options.abortSignal;
+    }
+    let controller;
+    const stream = new ReadableStream({
+      async start(ctrl) {
+        controller = ctrl;
+        controller.enqueue({
+          type: "stream-start",
+          warnings: []
+        });
+        controller.enqueue({
+          type: "text-start",
+          id: textId
+        });
+        try {
+          streamPromptOptions.onToken = (token) => {
+            outputTokens += 1;
+            controller.enqueue({
+              type: "text-delta",
+              id: textId,
+              delta: token
+            });
+          };
+          await session.prompt(prompt, streamPromptOptions);
+          controller.enqueue({
+            type: "text-end",
+            id: textId
+          });
+          controller.enqueue({
+            type: "finish",
+            finishReason: "stop",
+            usage: {
+              inputTokens,
+              outputTokens,
+              totalTokens: inputTokens + outputTokens
+            }
+          });
+          controller.close();
+        } catch (error) {
+          if (error instanceof Error && error.name === "AbortError") {
+            controller.enqueue({
+              type: "text-end",
+              id: textId
+            });
+            controller.enqueue({
+              type: "finish",
+              finishReason: "stop",
+              usage: {
+                inputTokens,
+                outputTokens,
+                totalTokens: inputTokens + outputTokens
+              }
+            });
+            controller.close();
+          } else {
+            controller.enqueue({
+              type: "error",
+              error
+            });
+            controller.close();
+          }
+        }
+      }
+    });
+    return {
+      stream
+    };
+  }
+  /**
+   * Format the prompt from AI SDK message format.
+   */
+  formatPrompt(options) {
+    const parts = [];
+    if (options.prompt && Array.isArray(options.prompt)) {
+      for (const message of options.prompt) {
+        if (message.role === "system") {
+          parts.push(`System: ${message.content}`);
+        } else if (message.role === "user") {
+          if (Array.isArray(message.content)) {
+            const textParts = message.content.filter((p) => p.type === "text").map((p) => p.text);
+            if (textParts.length > 0) {
+              parts.push(`User: ${textParts.join("\n")}`);
+            }
+          }
+        } else if (message.role === "assistant") {
+          if (Array.isArray(message.content)) {
+            const textParts = message.content.filter((p) => p.type === "text").map((p) => p.text);
+            if (textParts.length > 0) {
+              parts.push(`Assistant: ${textParts.join("\n")}`);
+            }
+          }
+        }
+      }
+    }
+    parts.push("Assistant:");
+    return parts.join("\n\n");
+  }
+}
+export {
+  createLocalLanguageModel
+};

package/dist/llm/providers/local/downloader.cjs

@@ -0,0 +1,291 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var downloader_exports = {};
+__export(downloader_exports, {
+  calculateFileHash: () => calculateFileHash,
+  checkDiskSpace: () => checkDiskSpace,
+  cleanupPartialDownload: () => cleanupPartialDownload,
+  downloadModel: () => downloadModel,
+  downloadModelFromUrl: () => downloadModelFromUrl,
+  getPartialDownloadProgress: () => getPartialDownloadProgress,
+  isDownloadInProgress: () => isDownloadInProgress,
+  validateDiskSpace: () => validateDiskSpace
+});
+module.exports = __toCommonJS(downloader_exports);
+var import_fs = require("fs");
+var import_crypto = require("crypto");
+var path = __toESM(require("path"), 1);
+var import_errors = require("./errors.js");
+var import_registry = require("./registry.js");
+function buildHuggingFaceUrl(huggingfaceId, filename) {
+  return `https://huggingface.co/${huggingfaceId}/resolve/main/${filename}`;
+}
+async function getPartialSize(filePath) {
+  try {
+    const stats = await import_fs.promises.stat(filePath);
+    return stats.size;
+  } catch {
+    return 0;
+  }
+}
+async function calculateFileHash(filePath) {
+  return new Promise((resolve, reject) => {
+    const hash = (0, import_crypto.createHash)("sha256");
+    const stream = (0, import_fs.createReadStream)(filePath);
+    stream.on("data", (chunk) => hash.update(chunk));
+    stream.on("end", () => resolve(hash.digest("hex")));
+    stream.on("error", reject);
+  });
+}
+function createProgressEvent(modelId, status, bytesDownloaded, totalBytes, speed, eta, error) {
+  const progress = {
+    modelId,
+    status,
+    bytesDownloaded,
+    totalBytes,
+    percentage: totalBytes > 0 ? bytesDownloaded / totalBytes * 100 : 0
+  };
+  if (speed !== void 0) {
+    progress.speed = speed;
+  }
+  if (eta !== void 0) {
+    progress.eta = eta;
+  }
+  if (error !== void 0) {
+    progress.error = error;
+  }
+  return progress;
+}
+async function downloadFromHuggingFace(url, targetPath, options, modelId, expectedSize) {
+  const { events, hfToken, signal } = options;
+  const tempPath = `${targetPath}.download`;
+  const partialSize = await getPartialSize(tempPath);
+  const resumed = partialSize > 0;
+  const headers = {
+    "User-Agent": "Dexto/1.0"
+  };
+  if (hfToken) {
+    headers["Authorization"] = `Bearer ${hfToken}`;
+  }
+  if (partialSize > 0) {
+    headers["Range"] = `bytes=${partialSize}-`;
+  }
+  try {
+    const fetchOptions = { headers };
+    if (signal) {
+      fetchOptions.signal = signal;
+    }
+    const response = await fetch(url, fetchOptions);
+    if (response.status === 401 || response.status === 403) {
+      throw import_errors.LocalModelError.hfAuthRequired(modelId);
+    }
+    if (!response.ok && response.status !== 206) {
+      throw import_errors.LocalModelError.downloadFailed(
+        modelId,
+        `HTTP ${response.status}: ${response.statusText}`
+      );
+    }
+    const contentLengthHeader = response.headers.get("content-length");
+    const contentLength = contentLengthHeader ? parseInt(contentLengthHeader, 10) : 0;
+    const totalSize = partialSize + contentLength;
+    await import_fs.promises.mkdir(path.dirname(tempPath), { recursive: true });
+    const writeStream = (0, import_fs.createWriteStream)(tempPath, {
+      flags: resumed ? "a" : "w"
+    });
+    let bytesDownloaded = partialSize;
+    const startTime = Date.now();
+    let lastProgressUpdate = startTime;
+    const reader = response.body?.getReader();
+    if (!reader) {
+      writeStream.destroy();
+      throw import_errors.LocalModelError.downloadFailed(modelId, "No response body");
+    }
+    try {
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done) break;
+        writeStream.write(value);
+        bytesDownloaded += value.length;
+        const now = Date.now();
+        if (now - lastProgressUpdate > 100 || done) {
+          lastProgressUpdate = now;
+          const elapsedSeconds = (now - startTime) / 1e3;
+          const speed = elapsedSeconds > 0 ? (bytesDownloaded - partialSize) / elapsedSeconds : 0;
+          const remainingBytes = totalSize - bytesDownloaded;
+          const eta = speed > 0 ? remainingBytes / speed : 0;
+          const progress = createProgressEvent(
+            modelId,
+            "downloading",
+            bytesDownloaded,
+            totalSize || expectedSize,
+            speed,
+            eta
+          );
+          events?.onProgress?.(progress);
+        }
+      }
+      await new Promise((resolve, reject) => {
+        writeStream.end((err) => {
+          if (err) reject(err);
+          else resolve();
+        });
+      });
+    } catch (error) {
+      writeStream.destroy();
+      throw error;
+    }
+    events?.onProgress?.(createProgressEvent(modelId, "verifying", bytesDownloaded, totalSize));
+    await import_fs.promises.rename(tempPath, targetPath);
+    const stats = await import_fs.promises.stat(targetPath);
+    events?.onProgress?.(createProgressEvent(modelId, "complete", stats.size, stats.size));
+    return {
+      success: true,
+      filePath: targetPath,
+      sizeBytes: stats.size,
+      resumed
+    };
+  } catch (error) {
+    if (error instanceof Error && error.name === "AbortError") {
+      throw import_errors.LocalModelError.downloadInterrupted(modelId);
+    }
+    throw error;
+  }
+}
+async function downloadModel(modelId, options) {
+  const modelInfo = (0, import_registry.getLocalModelById)(modelId);
+  if (!modelInfo) {
+    throw import_errors.LocalModelError.modelNotFound(modelId);
+  }
+  const targetPath = path.join(options.targetDir, modelInfo.filename);
+  const url = buildHuggingFaceUrl(modelInfo.huggingfaceId, modelInfo.filename);
+  if ((0, import_fs.existsSync)(targetPath)) {
+    const stats = await import_fs.promises.stat(targetPath);
+    if (stats.size === modelInfo.sizeBytes) {
+      return {
+        success: true,
+        filePath: targetPath,
+        sizeBytes: stats.size,
+        resumed: false
+      };
+    }
+    await import_fs.promises.unlink(targetPath);
+  }
+  try {
+    options.events?.onProgress?.(
+      createProgressEvent(modelId, "pending", 0, modelInfo.sizeBytes)
+    );
+    const result = await downloadFromHuggingFace(
+      url,
+      targetPath,
+      options,
+      modelId,
+      modelInfo.sizeBytes
+    );
+    if (options.verifyHash && options.expectedHash) {
+      const actualHash = await calculateFileHash(targetPath);
+      if (actualHash !== options.expectedHash) {
+        await import_fs.promises.unlink(targetPath);
+        throw import_errors.LocalModelError.hashMismatch(modelId, options.expectedHash, actualHash);
+      }
+      result.sha256 = actualHash;
+    }
+    options.events?.onComplete?.(modelId, targetPath);
+    return result;
+  } catch (error) {
+    options.events?.onError?.(modelId, error);
+    throw error;
+  }
+}
+async function downloadModelFromUrl(modelId, url, filename, options) {
+  const targetPath = path.join(options.targetDir, filename);
+  try {
+    options.events?.onProgress?.(createProgressEvent(modelId, "pending", 0, 0));
+    const result = await downloadFromHuggingFace(url, targetPath, options, modelId, 0);
+    options.events?.onComplete?.(modelId, targetPath);
+    return result;
+  } catch (error) {
+    options.events?.onError?.(modelId, error);
+    throw error;
+  }
+}
+async function checkDiskSpace(targetDir) {
+  try {
+    await import_fs.promises.access(targetDir);
+    return Number.MAX_SAFE_INTEGER;
+  } catch {
+    try {
+      await import_fs.promises.mkdir(targetDir, { recursive: true });
+      return Number.MAX_SAFE_INTEGER;
+    } catch {
+      return 0;
+    }
+  }
+}
+async function validateDiskSpace(modelId, requiredBytes, targetDir) {
+  const available = await checkDiskSpace(targetDir);
+  if (available < requiredBytes) {
+    throw import_errors.LocalModelError.insufficientDiskSpace(modelId, requiredBytes, available);
+  }
+}
+async function cleanupPartialDownload(targetDir, filename) {
+  const tempPath = path.join(targetDir, `${filename}.download`);
+  try {
+    await import_fs.promises.unlink(tempPath);
+  } catch {
+  }
+}
+async function isDownloadInProgress(targetDir, filename) {
+  const tempPath = path.join(targetDir, `${filename}.download`);
+  try {
+    await import_fs.promises.access(tempPath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function getPartialDownloadProgress(modelId, targetDir, filename, totalBytes) {
+  const tempPath = path.join(targetDir, `${filename}.download`);
+  try {
+    const stats = await import_fs.promises.stat(tempPath);
+    return createProgressEvent(modelId, "downloading", stats.size, totalBytes);
+  } catch {
+    return null;
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  calculateFileHash,
+  checkDiskSpace,
+  cleanupPartialDownload,
+  downloadModel,
+  downloadModelFromUrl,
+  getPartialDownloadProgress,
+  isDownloadInProgress,
+  validateDiskSpace
+});

package/dist/llm/providers/local/downloader.d.ts

@@ -0,0 +1,82 @@
+/**
+ * Model downloader for local GGUF models.
+ *
+ * Downloads models from HuggingFace with:
+ * - Progress tracking via events
+ * - Resume support for interrupted downloads
+ * - Hash verification after download
+ */
+import type { ModelDownloadProgress } from './types.js';
+/**
+ * Event emitter interface for download progress.
+ */
+export interface DownloadEvents {
+    onProgress?: (progress: ModelDownloadProgress) => void;
+    onComplete?: (modelId: string, filePath: string) => void;
+    onError?: (modelId: string, error: Error) => void;
+}
+/**
+ * Download options.
+ */
+export interface DownloadOptions {
+    /** Directory to save the model */
+    targetDir: string;
+    /** Events for progress tracking */
+    events?: DownloadEvents;
+    /** HuggingFace token for gated models */
+    hfToken?: string;
+    /** Whether to verify hash after download */
+    verifyHash?: boolean;
+    /** Abort signal for cancellation */
+    signal?: AbortSignal;
+    /** Expected SHA-256 hash for verification */
+    expectedHash?: string;
+}
+/**
+ * Download result.
+ */
+export interface DownloadResult {
+    /** Whether download succeeded */
+    success: boolean;
+    /** Full path to downloaded file */
+    filePath: string;
+    /** File size in bytes */
+    sizeBytes: number;
+    /** SHA-256 hash of the file */
+    sha256?: string;
+    /** Whether download was resumed from partial */
+    resumed: boolean;
+}
+/**
+ * Calculate SHA-256 hash of a file.
+ */
+export declare function calculateFileHash(filePath: string): Promise<string>;
+/**
+ * Download a local model by ID.
+ */
+export declare function downloadModel(modelId: string, options: DownloadOptions): Promise<DownloadResult>;
+/**
+ * Download a model directly from a URL (for custom models).
+ */
+export declare function downloadModelFromUrl(modelId: string, url: string, filename: string, options: DownloadOptions): Promise<DownloadResult>;
+/**
+ * Check available disk space at a path.
+ */
+export declare function checkDiskSpace(targetDir: string): Promise<number>;
+/**
+ * Validate that there's enough disk space for a model.
+ */
+export declare function validateDiskSpace(modelId: string, requiredBytes: number, targetDir: string): Promise<void>;
+/**
+ * Clean up partial download files.
+ */
+export declare function cleanupPartialDownload(targetDir: string, filename: string): Promise<void>;
+/**
+ * Check if a download is in progress (partial file exists).
+ */
+export declare function isDownloadInProgress(targetDir: string, filename: string): Promise<boolean>;
+/**
+ * Get the progress of a partial download.
+ */
+export declare function getPartialDownloadProgress(modelId: string, targetDir: string, filename: string, totalBytes: number): Promise<ModelDownloadProgress | null>;
+//# sourceMappingURL=downloader.d.ts.map

package/dist/llm/providers/local/downloader.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"downloader.d.ts","sourceRoot":"","sources":["../../../../src/llm/providers/local/downloader.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAKH,OAAO,KAAK,EAAE,qBAAqB,EAAuB,MAAM,YAAY,CAAC;AAI7E;;GAEG;AACH,MAAM,WAAW,cAAc;IAC3B,UAAU,CAAC,EAAE,CAAC,QAAQ,EAAE,qBAAqB,KAAK,IAAI,CAAC;IACvD,UAAU,CAAC,EAAE,CAAC,OAAO,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,KAAK,IAAI,CAAC;IACzD,OAAO,CAAC,EAAE,CAAC,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE,KAAK,KAAK,IAAI,CAAC;CACrD;AAED;;GAEG;AACH,MAAM,WAAW,eAAe;IAC5B,kCAAkC;IAClC,SAAS,EAAE,MAAM,CAAC;IAClB,mCAAmC;IACnC,MAAM,CAAC,EAAE,cAAc,CAAC;IACxB,yCAAyC;IACzC,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,4CAA4C;IAC5C,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,oCAAoC;IACpC,MAAM,CAAC,EAAE,WAAW,CAAC;IACrB,6CAA6C;IAC7C,YAAY,CAAC,EAAE,MAAM,CAAC;CACzB;AAED;;GAEG;AACH,MAAM,WAAW,cAAc;IAC3B,iCAAiC;IACjC,OAAO,EAAE,OAAO,CAAC;IACjB,mCAAmC;IACnC,QAAQ,EAAE,MAAM,CAAC;IACjB,yBAAyB;IACzB,SAAS,EAAE,MAAM,CAAC;IAClB,+BAA+B;IAC/B,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,gDAAgD;IAChD,OAAO,EAAE,OAAO,CAAC;CACpB;AAsBD;;GAEG;AACH,wBAAsB,iBAAiB,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CASzE;AAqLD;;GAEG;AACH,wBAAsB,aAAa,CAC/B,OAAO,EAAE,MAAM,EACf,OAAO,EAAE,eAAe,GACzB,OAAO,CAAC,cAAc,CAAC,CAwDzB;AAED;;GAEG;AACH,wBAAsB,oBAAoB,CACtC,OAAO,EAAE,MAAM,EACf,GAAG,EAAE,MAAM,EACX,QAAQ,EAAE,MAAM,EAChB,OAAO,EAAE,eAAe,GACzB,OAAO,CAAC,cAAc,CAAC,CAczB;AAED;;GAEG;AACH,wBAAsB,cAAc,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAevE;AAED;;GAEG;AACH,wBAAsB,iBAAiB,CACnC,OAAO,EAAE,MAAM,EACf,aAAa,EAAE,MAAM,EACrB,SAAS,EAAE,MAAM,GAClB,OAAO,CAAC,IAAI,CAAC,CAKf;AAED;;GAEG;AACH,wBAAsB,sBAAsB,CAAC,SAAS,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAO/F;AAED;;GAEG;AACH,wBAAsB,oBAAoB,CAAC,SAAS,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAQhG;AAED;;GAEG;AACH,wBAAsB,0BAA0B,CAC5C,OAAO,EAAE,MAAM,EACf,SAAS,EAAE,MAAM,EACjB,QAAQ,EAAE,MAAM,EAChB,UAAU,EAAE,MAAM,GACnB,OAAO,CAAC,qBAAqB,GAAG,IAAI,CAAC,CAQvC"}