@dexto/core 1.3.0 → 1.5.0

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

@@ -0,0 +1,395 @@
+/**
+ * Zod schemas for local model configuration validation.
+ */
+import { z } from 'zod';
+/**
+ * GPU backend options.
+ */
+export declare const GPUBackendSchema: z.ZodEnum<["metal", "cuda", "vulkan", "cpu"]>;
+/**
+ * Quantization type options.
+ */
+export declare const QuantizationTypeSchema: z.ZodEnum<["Q2_K", "Q3_K_S", "Q3_K_M", "Q3_K_L", "Q4_0", "Q4_K_S", "Q4_K_M", "Q5_0", "Q5_K_S", "Q5_K_M", "Q6_K", "Q8_0", "F16", "F32"]>;
+/**
+ * Local model category options.
+ */
+export declare const LocalModelCategorySchema: z.ZodEnum<["general", "coding", "reasoning", "small", "vision"]>;
+/**
+ * Model source options.
+ */
+export declare const ModelSourceSchema: z.ZodEnum<["huggingface", "ollama"]>;
+/**
+ * Model download status.
+ */
+export declare const ModelDownloadStatusSchema: z.ZodEnum<["pending", "downloading", "verifying", "complete", "error"]>;
+/**
+ * Schema for local model info (registry entry).
+ */
+export declare const LocalModelInfoSchema: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+    description: z.ZodString;
+    huggingfaceId: z.ZodString;
+    filename: z.ZodString;
+    quantization: z.ZodEnum<["Q2_K", "Q3_K_S", "Q3_K_M", "Q3_K_L", "Q4_0", "Q4_K_S", "Q4_K_M", "Q5_0", "Q5_K_S", "Q5_K_M", "Q6_K", "Q8_0", "F16", "F32"]>;
+    sizeBytes: z.ZodNumber;
+    contextLength: z.ZodNumber;
+    categories: z.ZodArray<z.ZodEnum<["general", "coding", "reasoning", "small", "vision"]>, "many">;
+    minVRAM: z.ZodOptional<z.ZodNumber>;
+    minRAM: z.ZodOptional<z.ZodNumber>;
+    recommended: z.ZodOptional<z.ZodBoolean>;
+    author: z.ZodOptional<z.ZodString>;
+    license: z.ZodOptional<z.ZodString>;
+    supportsVision: z.ZodOptional<z.ZodBoolean>;
+    supportsTools: z.ZodOptional<z.ZodBoolean>;
+}, "strict", z.ZodTypeAny, {
+    filename: string;
+    description: string;
+    name: string;
+    id: string;
+    huggingfaceId: string;
+    quantization: "Q2_K" | "Q3_K_S" | "Q3_K_M" | "Q3_K_L" | "Q4_0" | "Q4_K_S" | "Q4_K_M" | "Q5_0" | "Q5_K_S" | "Q5_K_M" | "Q6_K" | "Q8_0" | "F16" | "F32";
+    sizeBytes: number;
+    contextLength: number;
+    categories: ("reasoning" | "small" | "general" | "coding" | "vision")[];
+    license?: string | undefined;
+    supportsVision?: boolean | undefined;
+    supportsTools?: boolean | undefined;
+    recommended?: boolean | undefined;
+    minVRAM?: number | undefined;
+    minRAM?: number | undefined;
+    author?: string | undefined;
+}, {
+    filename: string;
+    description: string;
+    name: string;
+    id: string;
+    huggingfaceId: string;
+    quantization: "Q2_K" | "Q3_K_S" | "Q3_K_M" | "Q3_K_L" | "Q4_0" | "Q4_K_S" | "Q4_K_M" | "Q5_0" | "Q5_K_S" | "Q5_K_M" | "Q6_K" | "Q8_0" | "F16" | "F32";
+    sizeBytes: number;
+    contextLength: number;
+    categories: ("reasoning" | "small" | "general" | "coding" | "vision")[];
+    license?: string | undefined;
+    supportsVision?: boolean | undefined;
+    supportsTools?: boolean | undefined;
+    recommended?: boolean | undefined;
+    minVRAM?: number | undefined;
+    minRAM?: number | undefined;
+    author?: string | undefined;
+}>;
+/**
+ * Schema for model download progress.
+ */
+export declare const ModelDownloadProgressSchema: z.ZodObject<{
+    modelId: z.ZodString;
+    status: z.ZodEnum<["pending", "downloading", "verifying", "complete", "error"]>;
+    bytesDownloaded: z.ZodNumber;
+    totalBytes: z.ZodNumber;
+    percentage: z.ZodNumber;
+    speed: z.ZodOptional<z.ZodNumber>;
+    eta: z.ZodOptional<z.ZodNumber>;
+    error: z.ZodOptional<z.ZodString>;
+}, "strict", z.ZodTypeAny, {
+    status: "error" | "pending" | "downloading" | "verifying" | "complete";
+    modelId: string;
+    bytesDownloaded: number;
+    totalBytes: number;
+    percentage: number;
+    error?: string | undefined;
+    speed?: number | undefined;
+    eta?: number | undefined;
+}, {
+    status: "error" | "pending" | "downloading" | "verifying" | "complete";
+    modelId: string;
+    bytesDownloaded: number;
+    totalBytes: number;
+    percentage: number;
+    error?: string | undefined;
+    speed?: number | undefined;
+    eta?: number | undefined;
+}>;
+/**
+ * Schema for GPU info.
+ */
+export declare const GPUInfoSchema: z.ZodObject<{
+    backend: z.ZodEnum<["metal", "cuda", "vulkan", "cpu"]>;
+    available: z.ZodBoolean;
+    deviceName: z.ZodOptional<z.ZodString>;
+    vramMB: z.ZodOptional<z.ZodNumber>;
+    driverVersion: z.ZodOptional<z.ZodString>;
+}, "strict", z.ZodTypeAny, {
+    backend: "metal" | "cuda" | "vulkan" | "cpu";
+    available: boolean;
+    deviceName?: string | undefined;
+    vramMB?: number | undefined;
+    driverVersion?: string | undefined;
+}, {
+    backend: "metal" | "cuda" | "vulkan" | "cpu";
+    available: boolean;
+    deviceName?: string | undefined;
+    vramMB?: number | undefined;
+    driverVersion?: string | undefined;
+}>;
+/**
+ * Schema for local LLM configuration.
+ */
+export declare const LocalLLMConfigSchema: z.ZodObject<{
+    provider: z.ZodEnum<["local", "ollama"]>;
+    model: z.ZodString;
+    gpuLayers: z.ZodOptional<z.ZodNumber>;
+    contextSize: z.ZodOptional<z.ZodNumber>;
+    threads: z.ZodOptional<z.ZodNumber>;
+    batchSize: z.ZodOptional<z.ZodNumber>;
+    modelPath: z.ZodOptional<z.ZodString>;
+}, "strict", z.ZodTypeAny, {
+    model: string;
+    provider: "local" | "ollama";
+    batchSize?: number | undefined;
+    modelPath?: string | undefined;
+    gpuLayers?: number | undefined;
+    contextSize?: number | undefined;
+    threads?: number | undefined;
+}, {
+    model: string;
+    provider: "local" | "ollama";
+    batchSize?: number | undefined;
+    modelPath?: string | undefined;
+    gpuLayers?: number | undefined;
+    contextSize?: number | undefined;
+    threads?: number | undefined;
+}>;
+/**
+ * Schema for installed model metadata.
+ */
+export declare const InstalledModelSchema: z.ZodObject<{
+    id: z.ZodString;
+    filePath: z.ZodString;
+    sizeBytes: z.ZodNumber;
+    downloadedAt: z.ZodString;
+    lastUsedAt: z.ZodOptional<z.ZodString>;
+    sha256: z.ZodOptional<z.ZodString>;
+    source: z.ZodEnum<["huggingface", "ollama"]>;
+}, "strict", z.ZodTypeAny, {
+    id: string;
+    source: "ollama" | "huggingface";
+    filePath: string;
+    sizeBytes: number;
+    downloadedAt: string;
+    sha256?: string | undefined;
+    lastUsedAt?: string | undefined;
+}, {
+    id: string;
+    source: "ollama" | "huggingface";
+    filePath: string;
+    sizeBytes: number;
+    downloadedAt: string;
+    sha256?: string | undefined;
+    lastUsedAt?: string | undefined;
+}>;
+/**
+ * Schema for model state (persisted state file).
+ */
+export declare const ModelStateSchema: z.ZodObject<{
+    version: z.ZodDefault<z.ZodString>;
+    installed: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodObject<{
+        id: z.ZodString;
+        filePath: z.ZodString;
+        sizeBytes: z.ZodNumber;
+        downloadedAt: z.ZodString;
+        lastUsedAt: z.ZodOptional<z.ZodString>;
+        sha256: z.ZodOptional<z.ZodString>;
+        source: z.ZodEnum<["huggingface", "ollama"]>;
+    }, "strict", z.ZodTypeAny, {
+        id: string;
+        source: "ollama" | "huggingface";
+        filePath: string;
+        sizeBytes: number;
+        downloadedAt: string;
+        sha256?: string | undefined;
+        lastUsedAt?: string | undefined;
+    }, {
+        id: string;
+        source: "ollama" | "huggingface";
+        filePath: string;
+        sizeBytes: number;
+        downloadedAt: string;
+        sha256?: string | undefined;
+        lastUsedAt?: string | undefined;
+    }>>>;
+    activeModelId: z.ZodOptional<z.ZodString>;
+    downloadQueue: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+}, "strict", z.ZodTypeAny, {
+    version: string;
+    installed: Record<string, {
+        id: string;
+        source: "ollama" | "huggingface";
+        filePath: string;
+        sizeBytes: number;
+        downloadedAt: string;
+        sha256?: string | undefined;
+        lastUsedAt?: string | undefined;
+    }>;
+    downloadQueue: string[];
+    activeModelId?: string | undefined;
+}, {
+    version?: string | undefined;
+    installed?: Record<string, {
+        id: string;
+        source: "ollama" | "huggingface";
+        filePath: string;
+        sizeBytes: number;
+        downloadedAt: string;
+        sha256?: string | undefined;
+        lastUsedAt?: string | undefined;
+    }> | undefined;
+    activeModelId?: string | undefined;
+    downloadQueue?: string[] | undefined;
+}>;
+/**
+ * Schema for model download options.
+ */
+export declare const ModelDownloadOptionsSchema: z.ZodObject<{
+    modelId: z.ZodString;
+    outputDir: z.ZodOptional<z.ZodString>;
+    showProgress: z.ZodDefault<z.ZodBoolean>;
+    hfToken: z.ZodOptional<z.ZodString>;
+}, "strict", z.ZodTypeAny, {
+    modelId: string;
+    showProgress: boolean;
+    outputDir?: string | undefined;
+    hfToken?: string | undefined;
+}, {
+    modelId: string;
+    outputDir?: string | undefined;
+    showProgress?: boolean | undefined;
+    hfToken?: string | undefined;
+}>;
+/**
+ * Schema for Ollama model info (from API).
+ */
+export declare const OllamaModelInfoSchema: z.ZodObject<{
+    name: z.ZodString;
+    size: z.ZodNumber;
+    digest: z.ZodString;
+    modifiedAt: z.ZodString;
+    details: z.ZodOptional<z.ZodObject<{
+        family: z.ZodOptional<z.ZodString>;
+        parameterSize: z.ZodOptional<z.ZodString>;
+        quantizationLevel: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        family?: string | undefined;
+        parameterSize?: string | undefined;
+        quantizationLevel?: string | undefined;
+    }, {
+        family?: string | undefined;
+        parameterSize?: string | undefined;
+        quantizationLevel?: string | undefined;
+    }>>;
+}, "strict", z.ZodTypeAny, {
+    name: string;
+    size: number;
+    digest: string;
+    modifiedAt: string;
+    details?: {
+        family?: string | undefined;
+        parameterSize?: string | undefined;
+        quantizationLevel?: string | undefined;
+    } | undefined;
+}, {
+    name: string;
+    size: number;
+    digest: string;
+    modifiedAt: string;
+    details?: {
+        family?: string | undefined;
+        parameterSize?: string | undefined;
+        quantizationLevel?: string | undefined;
+    } | undefined;
+}>;
+/**
+ * Schema for Ollama server status.
+ */
+export declare const OllamaStatusSchema: z.ZodObject<{
+    running: z.ZodBoolean;
+    url: z.ZodString;
+    version: z.ZodOptional<z.ZodString>;
+    models: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        size: z.ZodNumber;
+        digest: z.ZodString;
+        modifiedAt: z.ZodString;
+        details: z.ZodOptional<z.ZodObject<{
+            family: z.ZodOptional<z.ZodString>;
+            parameterSize: z.ZodOptional<z.ZodString>;
+            quantizationLevel: z.ZodOptional<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            family?: string | undefined;
+            parameterSize?: string | undefined;
+            quantizationLevel?: string | undefined;
+        }, {
+            family?: string | undefined;
+            parameterSize?: string | undefined;
+            quantizationLevel?: string | undefined;
+        }>>;
+    }, "strict", z.ZodTypeAny, {
+        name: string;
+        size: number;
+        digest: string;
+        modifiedAt: string;
+        details?: {
+            family?: string | undefined;
+            parameterSize?: string | undefined;
+            quantizationLevel?: string | undefined;
+        } | undefined;
+    }, {
+        name: string;
+        size: number;
+        digest: string;
+        modifiedAt: string;
+        details?: {
+            family?: string | undefined;
+            parameterSize?: string | undefined;
+            quantizationLevel?: string | undefined;
+        } | undefined;
+    }>, "many">>;
+    error: z.ZodOptional<z.ZodString>;
+}, "strict", z.ZodTypeAny, {
+    url: string;
+    running: boolean;
+    error?: string | undefined;
+    version?: string | undefined;
+    models?: {
+        name: string;
+        size: number;
+        digest: string;
+        modifiedAt: string;
+        details?: {
+            family?: string | undefined;
+            parameterSize?: string | undefined;
+            quantizationLevel?: string | undefined;
+        } | undefined;
+    }[] | undefined;
+}, {
+    url: string;
+    running: boolean;
+    error?: string | undefined;
+    version?: string | undefined;
+    models?: {
+        name: string;
+        size: number;
+        digest: string;
+        modifiedAt: string;
+        details?: {
+            family?: string | undefined;
+            parameterSize?: string | undefined;
+            quantizationLevel?: string | undefined;
+        } | undefined;
+    }[] | undefined;
+}>;
+export type LocalModelInfoInput = z.input<typeof LocalModelInfoSchema>;
+export type ModelDownloadProgressInput = z.input<typeof ModelDownloadProgressSchema>;
+export type GPUInfoInput = z.input<typeof GPUInfoSchema>;
+export type LocalLLMConfigInput = z.input<typeof LocalLLMConfigSchema>;
+export type InstalledModelInput = z.input<typeof InstalledModelSchema>;
+export type ModelStateInput = z.input<typeof ModelStateSchema>;
+//# sourceMappingURL=schemas.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"schemas.d.ts","sourceRoot":"","sources":["../../../../src/llm/providers/local/schemas.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB;;GAEG;AACH,eAAO,MAAM,gBAAgB,+CAA6C,CAAC;AAE3E;;GAEG;AACH,eAAO,MAAM,sBAAsB,yIAejC,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,wBAAwB,kEAMnC,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,iBAAiB,sCAAoC,CAAC;AAEnE;;GAEG;AACH,eAAO,MAAM,yBAAyB,yEAMpC,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAmBpB,CAAC;AAEd;;GAEG;AACH,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;;;;;;;;;;;;;;;EAW3B,CAAC;AAEd;;GAEG;AACH,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;EAQb,CAAC;AAEd;;GAEG;AACH,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;EAUpB,CAAC;AAEd;;GAEG;AACH,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;EAUpB,CAAC;AAEd;;GAEG;AACH,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAOhB,CAAC;AAEd;;GAEG;AACH,eAAO,MAAM,0BAA0B;;;;;;;;;;;;;;;EAO1B,CAAC;AAEd;;GAEG;AACH,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAcrB,CAAC;AAEd;;GAEG;AACH,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAQlB,CAAC;AAGd,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAC;AACvE,MAAM,MAAM,0BAA0B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,2BAA2B,CAAC,CAAC;AACrF,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,aAAa,CAAC,CAAC;AACzD,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAC;AACvE,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAC;AACvE,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAC"}

package/dist/llm/providers/local/schemas.js

@@ -0,0 +1,133 @@
+import "../../../chunk-PTJYTZNU.js";
+import { z } from "zod";
+const GPUBackendSchema = z.enum(["metal", "cuda", "vulkan", "cpu"]);
+const QuantizationTypeSchema = z.enum([
+  "Q2_K",
+  "Q3_K_S",
+  "Q3_K_M",
+  "Q3_K_L",
+  "Q4_0",
+  "Q4_K_S",
+  "Q4_K_M",
+  "Q5_0",
+  "Q5_K_S",
+  "Q5_K_M",
+  "Q6_K",
+  "Q8_0",
+  "F16",
+  "F32"
+]);
+const LocalModelCategorySchema = z.enum([
+  "general",
+  "coding",
+  "reasoning",
+  "small",
+  "vision"
+]);
+const ModelSourceSchema = z.enum(["huggingface", "ollama"]);
+const ModelDownloadStatusSchema = z.enum([
+  "pending",
+  "downloading",
+  "verifying",
+  "complete",
+  "error"
+]);
+const LocalModelInfoSchema = z.object({
+  id: z.string().min(1).describe("Unique model identifier"),
+  name: z.string().min(1).describe("Human-readable display name"),
+  description: z.string().describe("Short description of model capabilities"),
+  huggingfaceId: z.string().min(1).describe("HuggingFace repository ID"),
+  filename: z.string().min(1).describe("GGUF filename to download"),
+  quantization: QuantizationTypeSchema.describe("Quantization level"),
+  sizeBytes: z.number().int().positive().describe("File size in bytes"),
+  contextLength: z.number().int().positive().describe("Maximum context window"),
+  categories: z.array(LocalModelCategorySchema).describe("Model categories"),
+  minVRAM: z.number().positive().optional().describe("Minimum VRAM in GB"),
+  minRAM: z.number().positive().optional().describe("Minimum RAM in GB"),
+  recommended: z.boolean().optional().describe("Whether model is featured"),
+  author: z.string().optional().describe("Model author/organization"),
+  license: z.string().optional().describe("License type"),
+  supportsVision: z.boolean().optional().describe("Whether model supports images"),
+  supportsTools: z.boolean().optional().describe("Whether model supports function calling")
+}).strict();
+const ModelDownloadProgressSchema = z.object({
+  modelId: z.string().min(1),
+  status: ModelDownloadStatusSchema,
+  bytesDownloaded: z.number().int().nonnegative(),
+  totalBytes: z.number().int().nonnegative(),
+  percentage: z.number().min(0).max(100),
+  speed: z.number().nonnegative().optional(),
+  eta: z.number().nonnegative().optional(),
+  error: z.string().optional()
+}).strict();
+const GPUInfoSchema = z.object({
+  backend: GPUBackendSchema,
+  available: z.boolean(),
+  deviceName: z.string().optional(),
+  vramMB: z.number().int().nonnegative().optional(),
+  driverVersion: z.string().optional()
+}).strict();
+const LocalLLMConfigSchema = z.object({
+  provider: z.enum(["local", "ollama"]),
+  model: z.string().min(1).describe("Model ID or GGUF path"),
+  gpuLayers: z.number().int().optional().describe("GPU layers (-1=auto, 0=CPU)"),
+  contextSize: z.number().int().positive().optional().describe("Override context size"),
+  threads: z.number().int().positive().optional().describe("CPU threads"),
+  batchSize: z.number().int().positive().optional().describe("Inference batch size"),
+  modelPath: z.string().optional().describe("Resolved path to model file")
+}).strict();
+const InstalledModelSchema = z.object({
+  id: z.string().min(1),
+  filePath: z.string().min(1),
+  sizeBytes: z.number().int().positive(),
+  downloadedAt: z.string().datetime(),
+  lastUsedAt: z.string().datetime().optional(),
+  sha256: z.string().optional(),
+  source: ModelSourceSchema
+}).strict();
+const ModelStateSchema = z.object({
+  version: z.string().default("1.0"),
+  installed: z.record(z.string(), InstalledModelSchema).default({}),
+  activeModelId: z.string().optional(),
+  downloadQueue: z.array(z.string()).default([])
+}).strict();
+const ModelDownloadOptionsSchema = z.object({
+  modelId: z.string().min(1),
+  outputDir: z.string().optional(),
+  showProgress: z.boolean().default(true),
+  hfToken: z.string().optional()
+}).strict();
+const OllamaModelInfoSchema = z.object({
+  name: z.string().min(1),
+  size: z.number().int().nonnegative(),
+  digest: z.string(),
+  modifiedAt: z.string(),
+  details: z.object({
+    family: z.string().optional(),
+    parameterSize: z.string().optional(),
+    quantizationLevel: z.string().optional()
+  }).optional()
+}).strict();
+const OllamaStatusSchema = z.object({
+  running: z.boolean(),
+  url: z.string().url(),
+  version: z.string().optional(),
+  models: z.array(OllamaModelInfoSchema).optional(),
+  error: z.string().optional()
+}).strict();
+export {
+  GPUBackendSchema,
+  GPUInfoSchema,
+  InstalledModelSchema,
+  LocalLLMConfigSchema,
+  LocalModelCategorySchema,
+  LocalModelInfoSchema,
+  ModelDownloadOptionsSchema,
+  ModelDownloadProgressSchema,
+  ModelDownloadStatusSchema,
+  ModelSourceSchema,
+  ModelStateSchema,
+  OllamaModelInfoSchema,
+  OllamaStatusSchema,
+  QuantizationTypeSchema
+};

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

@@ -0,0 +1,16 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var types_exports = {};
+module.exports = __toCommonJS(types_exports);