@code0-tech/triangulum 0.1.0 → 0.2.0

package/dist/triangulum.es.js

@@ -1,5 +1,215 @@
-import t from "typescript";
-const w = `
+import v, { flattenDiagnosticMessageText as Z } from "typescript";
+function A() {
+  return A = Object.assign ? Object.assign.bind() : function(e) {
+    for (var t = 1; t < arguments.length; t++) {
+      var n = arguments[t];
+      for (var r in n) ({}).hasOwnProperty.call(n, r) && (e[r] = n[r]);
+    }
+    return e;
+  }, A.apply(null, arguments);
+}
+var W = !1;
+try {
+  W = typeof localStorage < "u";
+} catch {
+}
+var X = typeof process < "u", ee = W && typeof localStorage.getItem == "function" && /* @__PURE__ */ localStorage.getItem("DEBUG") || X && process.env.DEBUG, J = ee ? console.log : function(e) {
+  return "";
+};
+function te(e, t, n, r, o) {
+  r === void 0 && (r = {});
+  var c = A({}, G(n), r), s = re(e, t, c, n, o), a = s.languageServiceHost, u = s.updateFile, m = s.deleteFile, g = n.createLanguageService(a), p = g.getCompilerOptionsDiagnostics();
+  if (p.length) {
+    var i = Y(e, r, n);
+    throw new Error(n.formatDiagnostics(p, i.compilerHost));
+  }
+  return {
+    // @ts-ignore
+    name: "vfs",
+    sys: e,
+    languageService: g,
+    getSourceFile: function(F) {
+      var f;
+      return (f = g.getProgram()) == null ? void 0 : f.getSourceFile(F);
+    },
+    createFile: function(F, f) {
+      u(n.createSourceFile(F, f, c.target, !1));
+    },
+    updateFile: function(F, f, T) {
+      var d = g.getProgram().getSourceFile(F);
+      if (!d)
+        throw new Error("Did not find a source file for " + F);
+      var S = d.text, y = T ?? n.createTextSpan(0, S.length), x = S.slice(0, y.start) + f + S.slice(y.start + y.length), h = n.updateSourceFile(d, x, {
+        span: y,
+        newLength: f.length
+      });
+      u(h);
+    },
+    deleteFile: function(F) {
+      var f = g.getProgram().getSourceFile(F);
+      f && m(f);
+    }
+  };
+}
+function R(e) {
+  throw new Error("Method '" + e + "' is not implemented.");
+}
+function w(e, t) {
+  return function() {
+    for (var n = arguments.length, r = new Array(n), o = 0; o < n; o++)
+      r[o] = arguments[o];
+    var c = t.apply(void 0, r), s = typeof c == "string" ? c.slice(0, 80) + "..." : c;
+    return J.apply(void 0, ["> " + e].concat(r)), J("< " + s), c;
+  };
+}
+var G = function(t) {
+  return A({}, t.getDefaultCompilerOptions(), {
+    jsx: t.JsxEmit.React,
+    strict: !0,
+    esModuleInterop: !0,
+    module: t.ModuleKind.ESNext,
+    suppressOutputPathCheck: !0,
+    skipLibCheck: !0,
+    skipDefaultLibCheck: !0
+  }, t.versionMajorMinor && Number(t.versionMajorMinor.split(".")[0]) >= 6 ? {
+    ignoreDeprecations: "6.0"
+  } : {
+    moduleResolution: t.ModuleResolutionKind.NodeJs
+  });
+}, K = function(t) {
+  return t.replace("/", "/lib.").toLowerCase();
+};
+function ne(e) {
+  return {
+    args: [],
+    createDirectory: function() {
+      return R("createDirectory");
+    },
+    // TODO: could make a real file tree
+    directoryExists: w("directoryExists", function(t) {
+      return Array.from(e.keys()).some(function(n) {
+        return n.startsWith(t);
+      });
+    }),
+    exit: function() {
+      return R("exit");
+    },
+    fileExists: w("fileExists", function(t) {
+      return e.has(t) || e.has(K(t));
+    }),
+    getCurrentDirectory: function() {
+      return "/";
+    },
+    getDirectories: function() {
+      return [];
+    },
+    getExecutingFilePath: function() {
+      return R("getExecutingFilePath");
+    },
+    readDirectory: w("readDirectory", function(t) {
+      return t === "/" ? Array.from(e.keys()) : [];
+    }),
+    readFile: w("readFile", function(t) {
+      var n;
+      return (n = e.get(t)) != null ? n : e.get(K(t));
+    }),
+    resolvePath: function(n) {
+      return n;
+    },
+    newLine: `
+`,
+    useCaseSensitiveFileNames: !0,
+    write: function() {
+      return R("write");
+    },
+    writeFile: function(n, r) {
+      e.set(n, r);
+    },
+    deleteFile: function(n) {
+      e.delete(n);
+    }
+  };
+}
+function Y(e, t, n) {
+  var r = /* @__PURE__ */ new Map(), o = function(a) {
+    return r.set(a.fileName, a), a;
+  }, c = {
+    compilerHost: A({}, e, {
+      getCanonicalFileName: function(a) {
+        return a;
+      },
+      getDefaultLibFileName: function() {
+        return "/" + n.getDefaultLibFileName(t);
+      },
+      // '/lib.d.ts',
+      // getDefaultLibLocation: () => '/',
+      getNewLine: function() {
+        return e.newLine;
+      },
+      getSourceFile: function(a, u) {
+        var m;
+        return r.get(a) || o(n.createSourceFile(a, e.readFile(a), (m = u ?? t.target) != null ? m : G(n).target, !1));
+      },
+      useCaseSensitiveFileNames: function() {
+        return e.useCaseSensitiveFileNames;
+      }
+    }),
+    updateFile: function(a) {
+      var u = r.has(a.fileName);
+      return e.writeFile(a.fileName, a.text), r.set(a.fileName, a), u;
+    },
+    deleteFile: function(a) {
+      var u = r.has(a.fileName);
+      return r.delete(a.fileName), e.deleteFile(a.fileName), u;
+    }
+  };
+  return c;
+}
+function re(e, t, n, r, o) {
+  var c = [].concat(t), s = Y(e, n, r), a = s.compilerHost, u = s.updateFile, m = s.deleteFile, g = /* @__PURE__ */ new Map(), p = 0, i = A({}, a, {
+    getProjectVersion: function() {
+      return p.toString();
+    },
+    getCompilationSettings: function() {
+      return n;
+    },
+    getCustomTransformers: function() {
+      return o;
+    },
+    // A couple weeks of 4.8 TypeScript nightlies had a bug where the Program's
+    // list of files was just a reference to the array returned by this host method,
+    // which means mutations by the host that ought to result in a new Program being
+    // created were not detected, since the old list of files and the new list of files
+    // were in fact a reference to the same underlying array. That was fixed in
+    // https://github.com/microsoft/TypeScript/pull/49813, but since the twoslash runner
+    // is used in bisecting for changes, it needs to guard against being busted in that
+    // couple-week period, so we defensively make a slice here.
+    getScriptFileNames: function() {
+      return c.slice();
+    },
+    getScriptSnapshot: function(f) {
+      var T = e.readFile(f);
+      if (T && typeof T == "string")
+        return r.ScriptSnapshot.fromString(T);
+    },
+    getScriptVersion: function(f) {
+      return g.get(f) || "0";
+    },
+    writeFile: e.writeFile
+  }), l = {
+    languageServiceHost: i,
+    updateFile: function(f) {
+      p++, g.set(f.fileName, p.toString()), c.includes(f.fileName) || c.push(f.fileName), u(f);
+    },
+    deleteFile: function(f) {
+      p++, g.set(f.fileName, p.toString());
+      var T = c.indexOf(f.fileName);
+      T !== -1 && c.splice(T, 1), m(f);
+    }
+  };
+  return l;
+}
+const ie = `
     interface Array<T> { 
         [n: number]: T; 
         length: number; 
@@ -15,570 +225,566 @@ const w = `
     interface RegExp { }
     type ReturnType<T extends (...args: any) => any> = T extends (...args: any) => infer R ? R : any;
 `;
-function I(n, s, r) {
-  return {
-    getSourceFile: (e) => {
-      if (e === n) return r;
-      if (e.includes("lib.") || e.endsWith(".d.ts")) return t.createSourceFile(e, w, t.ScriptTarget.Latest);
-    },
-    writeFile: () => {
-    },
-    getDefaultLibFileName: () => "lib.d.ts",
-    useCaseSensitiveFileNames: () => !0,
-    getCanonicalFileName: (e) => e,
-    getCurrentDirectory: () => "/",
-    getNewLine: () => `
-`,
-    fileExists: (e) => e === n || e.includes("lib.") || e.endsWith(".d.ts"),
-    readFile: (e) => e === n ? s : e.includes("lib.") || e.endsWith(".d.ts") ? w : void 0,
-    directoryExists: () => !0,
-    getDirectories: () => []
-  };
+function I(e, t) {
+  const n = /* @__PURE__ */ new Map();
+  n.set(e, t), n.set("lib.codezero.d.ts", ie);
+  const r = ne(n);
+  return te(r, [e, "lib.codezero.d.ts"], v, oe);
 }
-const x = {
-  target: t.ScriptTarget.Latest,
-  lib: ["lib.esnext.d.ts"],
+const oe = {
+  target: v.ScriptTarget.Latest,
+  lib: ["lib.codezero.d.ts"],
   noEmit: !0,
   strictNullChecks: !0
 };
-function E(n) {
-  const s = Array.from(new Set(n.flatMap((e) => e.genericKeys || []))).map((e) => `type ${e} = any;`).join(`
-`), r = n.map(
-    (e) => `type ${e.identifier}${e.genericKeys ? `<${e.genericKeys.join(",")}>` : ""} = ${e.type};`
+function E(e) {
+  const t = Array.from(new Set(e.flatMap((r) => r.genericKeys || []))).map((r) => `type ${r} = any;`).join(`
+`), n = e.map(
+    (r) => `type ${r.identifier}${r.genericKeys ? `<${r.genericKeys.join(",")}>` : ""} = ${r.type};`
   ).join(`
 `);
-  return `${s}
-${r}`;
+  return `${t}
+${n}`;
 }
-function Y(n, s) {
-  let r = n;
-  for (const e of s) {
-    if (r == null) return "unknown";
-    typeof e.path == "string" && (r = r[e.path]);
+function ae(e, t) {
+  let n = e;
+  for (const r of t) {
+    if (n == null) return "unknown";
+    typeof r.path == "string" && (n = n[r.path]);
   }
-  return typeof r;
+  return typeof n;
 }
-function j(n, s) {
-  const r = n.nodes;
-  if (r)
-    return Array.isArray(r) ? r.find((e) => e.id === s) : r.nodes?.find((e) => e.id === s);
+function B(e, t) {
+  const n = e.nodes;
+  if (n)
+    return Array.isArray(n) ? n.find((r) => r.id === t) : n.nodes?.find((r) => r.id === t);
 }
-function K(n, s, r) {
-  const e = n?.value;
-  if (!e) return "undefined";
-  if (e.__typename === "ReferenceValue") {
-    const o = e, c = j(s, o.nodeFunctionId);
+function q(e, t, n) {
+  const r = e?.value;
+  if (!r) return "undefined";
+  if (r.__typename === "ReferenceValue") {
+    const o = r, c = B(t, o.nodeFunctionId);
     if (!c) return "undefined";
-    let u = r(s, c).inferredType;
+    let s = n(t, c).returnType;
     if (o.referencePath && o.referencePath.length > 0) {
-      let d;
-      const y = c.parameters?.nodes;
-      if (y && y.length > 0) {
-        const p = y[0];
-        p?.value?.__typename === "LiteralValue" && (d = p.value.value);
+      let a;
+      const u = c.parameters?.nodes;
+      if (u && u.length > 0) {
+        const m = u[0];
+        m?.value?.__typename === "LiteralValue" && (a = m.value.value);
       }
-      u = Y(d, o.referencePath);
+      s = ae(a, o.referencePath);
     }
-    return `({} as ${u})`;
+    return `({} as ${s})`;
   }
-  if (e.__typename === "NodeFunctionIdWrapper") {
-    const o = e.id, c = j(s, o);
+  if (r.__typename === "NodeFunctionIdWrapper") {
+    const o = r.id, c = B(t, o);
     if (!c) return "(() => undefined)";
-    const u = (p) => {
-      if (p.functionDefinition?.identifier === "std::control::return")
-        return p;
-      const m = p.nextNodeId ? j(s, p.nextNodeId) : void 0;
-      return m ? u(m) : void 0;
-    }, d = u(c);
-    return d ? `(() => ({} as ${r(s, d).inferredType}))` : "(() => undefined)";
+    const s = (m) => {
+      if (m.functionDefinition?.identifier === "std::control::return")
+        return m;
+      const g = m.nextNodeId ? B(t, m.nextNodeId) : void 0;
+      return g ? s(g) : void 0;
+    }, a = s(c);
+    return a ? `(() => ({} as ${n(t, a).returnType}))` : "(() => undefined)";
   }
-  return e.__typename === "LiteralValue" ? JSON.stringify(e.value) : "undefined";
+  return r.__typename === "LiteralValue" ? JSON.stringify(r.value) : "undefined";
 }
-const B = (n, s) => {
-  const r = n.nodes?.nodes;
-  if (r)
-    return r.find(
-      (e) => e?.parameters?.nodes?.some(
-        (o) => o?.value?.__typename === "NodeFunctionIdWrapper" && o.value.id === s
+const H = (e, t) => {
+  const n = e.nodes?.nodes;
+  if (n)
+    return n.find(
+      (r) => r?.parameters?.nodes?.some(
+        (o) => o?.value?.__typename === "NodeFunctionIdWrapper" && o.value.id === t
       )
     );
-}, J = (n, s, r, e = /* @__PURE__ */ new Set()) => {
-  const o = s.id;
-  if (!o || e.has(o)) return !1;
-  e.add(o);
-  const c = (d) => {
-    const y = n.nodes?.nodes?.find((p) => p?.nextNodeId === d);
-    return y ? y.id === r ? !0 : c(y.id) : !1;
+}, Q = (e, t, n, r = /* @__PURE__ */ new Set()) => {
+  const o = t.id;
+  if (!o || r.has(o)) return !1;
+  r.add(o);
+  const c = (a) => {
+    const u = e.nodes?.nodes?.find((m) => m?.nextNodeId === a);
+    return u ? u.id === n ? !0 : c(u.id) : !1;
   };
   if (c(o)) return !0;
-  const u = B(n, o);
-  return u ? u.id === r ? !0 : J(n, u, r, e) : !1;
-}, z = (n, s, r) => {
-  if (!r.nodeFunctionId)
+  const s = H(e, o);
+  return s ? s.id === n ? !0 : Q(e, s, n, r) : !1;
+}, se = (e, t, n) => {
+  if (!n.nodeFunctionId)
     return { isValid: !0 };
-  if (r.parameterIndex !== void 0 && r.inputIndex !== void 0) {
-    if (s.id === r.nodeFunctionId) return { isValid: !0 };
-    let e = B(n, s.id);
-    for (; e; ) {
-      if (e.id === r.nodeFunctionId) return { isValid: !0 };
-      e = B(n, e.id);
+  if (n.parameterIndex !== void 0 && n.inputIndex !== void 0) {
+    if (t.id === n.nodeFunctionId) return { isValid: !0 };
+    let r = H(e, t.id);
+    for (; r; ) {
+      if (r.id === n.nodeFunctionId) return { isValid: !0 };
+      r = H(e, r.id);
     }
     return {
       isValid: !1,
-      error: `Invalid input reference: Node ${s.id} is not in the scope of Node ${r.nodeFunctionId}.`
+      error: `Invalid input reference: Node ${t.id} is not in the scope of Node ${n.nodeFunctionId}.`
     };
   }
-  return J(n, s, r.nodeFunctionId) ? { isValid: !0 } : {
+  return Q(e, t, n.nodeFunctionId) ? { isValid: !0 } : {
     isValid: !1,
-    error: `Node ${r.nodeFunctionId} has not been executed yet or is not visible in this scope.`
+    error: `Node ${n.nodeFunctionId} has not been executed yet or is not visible in this scope.`
   };
-}, M = (n) => n.replace(/[^a-zA-Z0-9]/g, "_"), Z = (n, s, r) => {
-  const e = /* @__PURE__ */ new Set(), o = n.nodes?.nodes || [], c = new Map(s.map((f) => [f.identifier, f])), u = (f, N = "") => {
-    if (e.has(f)) return "";
-    const l = o.find((R) => R?.id === f);
-    if (!l || !l.functionDefinition) return "";
-    e.add(f);
-    const v = c.get(l.functionDefinition?.identifier);
-    if (!v) return `${N}// Error: Function ${l.functionDefinition.identifier} not found
-`;
-    const S = (l.parameters?.nodes || []).map((R, D) => {
-      const P = R.value;
-      if (!P) return "undefined";
-      if (P.__typename === "ReferenceValue") {
-        const L = P;
-        if (!L.nodeFunctionId) return "undefined";
-        let b = L.parameterIndex !== void 0 ? `p_${M(L.nodeFunctionId)}_${L.parameterIndex}` : `node_${M(L.nodeFunctionId)}`;
-        return L.referencePath?.forEach((O) => {
-          b += `?.${O.path}`;
-        }), b;
-      }
-      if (P.__typename === "LiteralValue")
-        return JSON.stringify(P.value);
-      if (P.__typename === "NodeFunctionIdWrapper") {
-        const L = P, b = `p_${M(l.id)}_${D}`, O = u(L.id, N + "  ");
-        return `(${b}) => {
-${O}${N}}`;
+}, de = (e) => {
+  const n = `const tempValue = ${JSON.stringify(e?.value) ?? "any"};`, r = "index.ts", o = I(r, n), c = o.getSourceFile(r), a = o.languageService.getProgram().getTypeChecker();
+  let u = "any";
+  const m = (g) => {
+    if (v.isVariableDeclaration(g) && g.name.getText() === "tempValue") {
+      const p = a.getTypeAtLocation(g);
+      u = a.typeToString(
+        p,
+        g,
+        v.TypeFormatFlags.NoTruncation | v.TypeFormatFlags.UseFullyQualifiedType
+      );
+    }
+    v.forEachChild(g, m);
+  };
+  return m(c), u;
+};
+var ce = /* @__PURE__ */ ((e) => (e[e.PRIMITIVE = 0] = "PRIMITIVE", e[e.TYPE = 1] = "TYPE", e[e.ARRAY = 2] = "ARRAY", e[e.OBJECT = 3] = "OBJECT", e))(ce || {});
+const fe = (e, t) => {
+  const r = `
+        ${E(t)}
+        type TargetType = ${e};
+        const val: TargetType = {} as any;
+    `, o = "index.ts", c = I(o, r), s = c.getSourceFile(o), u = c.languageService.getProgram().getTypeChecker();
+  let m = 1;
+  const g = (p) => {
+    if (v.isVariableDeclaration(p) && p.name.getText() === "val") {
+      const i = u.getTypeAtLocation(p);
+      u.isArrayType(i) ? m = 2 : i.isStringLiteral() || i.isNumberLiteral() || (i.getFlags() & (v.TypeFlags.String | v.TypeFlags.Number | v.TypeFlags.Boolean | v.TypeFlags.EnumLiteral | v.TypeFlags.BigInt | v.TypeFlags.ESSymbol)) !== 0 ? m = 0 : (i.isClassOrInterface() || (i.getFlags() & v.TypeFlags.Object) !== 0) && i.getProperties().length > 0 ? m = 3 : m = 1;
+    }
+    v.forEachChild(p, g);
+  };
+  return g(s), m;
+}, ge = (e, t) => {
+  const n = `
+        ${E(t)}
+        type Target = ${e};
+    `, r = "index.ts", o = I(r, n), c = o.getSourceFile(r), a = o.languageService.getProgram().getTypeChecker(), u = c.statements.find(
+    (i) => v.isTypeAliasDeclaration(i) && i.name.text === "Target"
+  );
+  if (!u)
+    return { __typename: "LiteralValue", value: null };
+  const m = a.getTypeAtLocation(u.type), g = (i, l, F = /* @__PURE__ */ new Set()) => {
+    if (F.has(i)) return null;
+    F.add(i);
+    const f = i.getFlags();
+    if (i.isUnion()) {
+      if (l.type, v.isTypeAliasDeclaration(l) && l.type && v.isUnionTypeNode(l.type)) {
+        const S = a.getTypeFromTypeNode(l.type.types[0]);
+        return g(S, l, F);
       }
-      return "undefined";
-    }).join(", "), $ = `node_${M(l.id)}`, C = `fn_${v.identifier?.replace(/::/g, "_")}`, A = S.includes("undefined") || (v.genericKeys?.length ?? 0) > 0;
-    let V = `${N}const ${$} = ${C}(${S})${A ? " as any" : ""} ;
-`;
-    return l.nextNodeId && (V += u(l.nextNodeId, N)), V;
-  }, d = E(r), y = s.map((f) => `declare function fn_${f.identifier?.replace(/::/g, "_")}${f.signature}`).join(`
-`), p = o.map((f) => f?.id ? u(f.id) : "").filter((f) => f !== "").join(`
-`), m = `${d}
-${y}
-
-// --- Flow ---
-${p}`, a = "flow_virtual.ts", i = t.createSourceFile(a, m, t.ScriptTarget.Latest), g = I(a, m, i), h = t.createProgram([a], x, g).getSemanticDiagnostics(i).map((f) => {
-    const N = t.flattenDiagnosticMessageText(f.messageText, `
-`);
-    return N.includes("Argument of type 'undefined'") || N.includes("not assignable to type 'undefined'") ? null : {
+      const T = i.types.filter((S) => {
+        const y = S.getFlags();
+        return !(y & v.TypeFlags.Undefined) && !(y & v.TypeFlags.Null);
+      }), d = T.length > 0 ? T[0] : i.types[0];
+      return g(d, l, F);
+    }
+    if (f & v.TypeFlags.StringLiteral) return i.value;
+    if (f & v.TypeFlags.String) return "sample";
+    if (f & v.TypeFlags.NumberLiteral) return i.value;
+    if (f & v.TypeFlags.Number) return 1;
+    if (f & v.TypeFlags.BooleanLiteral) return i.intrinsicName === "true";
+    if (f & v.TypeFlags.Boolean) return !1;
+    if (a.isArrayType(i)) {
+      const d = i.typeArguments?.[0] || a.getAnyType();
+      return [g(d, l, F)];
+    }
+    if (i.isClassOrInterface() || f & v.TypeFlags.Object || i.getProperties().length > 0) {
+      const T = {};
+      return i.getProperties().forEach((S) => {
+        const y = a.getTypeOfSymbolAtLocation(S, l);
+        y && (T[S.getName()] = g(y, l, F));
+      }), T;
+    }
+    return null;
+  };
+  return {
+    value: g(m, u)
+  };
+}, z = (e, t, n, r) => {
+  const c = new Map(n.map((h) => [h.identifier, h])).get(t.functionDefinition?.identifier);
+  if (!c)
+    return {
+      isValid: !1,
+      returnType: "any",
+      diagnostics: [{ message: `Function ${t.id} not found`, nodeId: t.id, code: 404, severity: "error" }]
+    };
+  const s = t.parameters?.nodes || [], a = [];
+  for (const h of s) {
+    const N = h.value;
+    if (N?.__typename === "ReferenceValue") {
+      const $ = se(e, t, N);
+      $.isValid || a.push({
+        message: $.error || "Scope error",
+        code: 403,
+        nodeId: t.id,
+        parameterIndex: s.indexOf(h),
+        severity: "error"
+      });
+    }
+  }
+  if (a.length > 0)
+    return {
+      isValid: !1,
+      returnType: "any",
+      diagnostics: a
+    };
+  const u = s.map((h) => q(h, e, (N, $) => z(N, $, n, r))), m = u.map(
+    (h) => h === "undefined" ? "({} as any)" : h
+  ).join(", ");
+  let g = c.signature;
+  const p = `
+        ${E(r)}
+        declare function testFunc${g};
+        const result = testFunc(${m});
+    `, i = "index.ts", l = I(i, p), F = l.getSourceFile(i), f = l.languageService.getProgram(), T = f.getTypeChecker(), d = f.getSemanticDiagnostics(F);
+  let S = "any";
+  const y = (h) => {
+    if (v.isVariableDeclaration(h) && h.name.getText() === "result") {
+      const N = T.getTypeAtLocation(h);
+      S = T.typeToString(
+        N,
+        h,
+        v.TypeFormatFlags.NoTruncation | v.TypeFormatFlags.UseFullyQualifiedType
+      );
+    }
+    v.forEachChild(h, y);
+  };
+  y(F);
+  const x = d.map((h) => {
+    const N = v.flattenDiagnosticMessageText(h.messageText, `
+`), $ = /\b([TRKV])\b/.test(N), C = N.includes("not assignable to parameter of type") && (N.includes("'{}'") || N.includes("undefined")) || N.includes("not assignable to type 'undefined'") || N.includes("not assignable to type 'void'") || N.includes("may be a mistake because neither type sufficiently overlaps");
+    return {
       message: N,
-      code: f.code,
-      severity: "error"
+      code: h.code,
+      nodeId: t.id,
+      parameterIndex: (() => {
+        if (h.start !== void 0) {
+          const P = s.findIndex((M, L) => {
+            const b = p.indexOf(u[L]);
+            return h.start >= b && h.start < b + u[L].length;
+          });
+          if (P !== -1) return P;
+        }
+      })(),
+      severity: $ || C ? "warning" : "error"
     };
-  }).filter((f) => f !== null);
+  });
   return {
-    isValid: h.length === 0,
-    inferredType: "void",
-    errors: h
+    isValid: !x.some((h) => h.severity === "error"),
+    returnType: S,
+    diagnostics: x
+  };
+}, pe = (e, t, n) => {
+  const o = new Map(t.map((y) => [y.identifier, y])).get(e.functionDefinition?.identifier);
+  if (!o)
+    return {
+      parameters: [],
+      returnType: "any"
+    };
+  const c = {
+    id: "gid://sagittarius/Flow/0",
+    nodes: { __typename: "NodeFunctionConnection", nodes: [e] }
+  }, u = (e.parameters?.nodes || []).map((y) => q(y, c, (x, h) => z(x, h, t, n))).map((y) => y === "undefined" ? "({} as any)" : y).join(", "), m = o.signature, g = `
+        ${E(n)}
+        declare function testFunc${m};
+        const result = testFunc(${u});
+    `, p = "index.ts", i = I(p, g), l = i.getSourceFile(p), f = i.languageService.getProgram().getTypeChecker();
+  let T = "any", d = [];
+  const S = (y) => {
+    if (v.isVariableDeclaration(y) && y.name.getText() === "result") {
+      const x = f.getTypeAtLocation(y);
+      if (T = f.typeToString(
+        x,
+        y,
+        v.TypeFormatFlags.NoTruncation
+      ), v.isCallExpression(y.initializer)) {
+        const h = y.initializer, N = f.getResolvedSignature(h);
+        N && (d = N.getParameters().map(($) => {
+          const C = f.getTypeOfSymbolAtLocation($, h);
+          return f.typeToString(
+            C,
+            h,
+            v.TypeFormatFlags.NoTruncation
+          );
+        }));
+      }
+    }
+    v.forEachChild(y, S);
+  };
+  return S(l), {
+    parameters: d,
+    returnType: T
   };
-}, G = [
-  { identifier: "LIST", type: "T[]", genericKeys: ["T"] },
-  { identifier: "NUMBER", type: "number" },
-  { identifier: "HTTP_METHOD", type: '"GET" | "POST" | "PUT" | "DELETE"' },
-  { identifier: "STRING", type: "string" },
-  { identifier: "CONSUMER", type: "(item:R) => void", genericKeys: ["R"] },
-  { identifier: "PREDICATE", type: "(item:R) => T", genericKeys: ["R", "T"] },
-  { identifier: "NUMBER_ARRAY", type: "LIST<NUMBER>", linkedDataTypeIdentifiers: ["LIST", "NUMBER"] }
-];
-function X(n, s) {
-  if (!n || !s || s.length === 0)
+};
+function me(e, t, n) {
+  if (!e || !t || t.length === 0)
     return [];
-  const r = "suggestions.ts", e = E(G);
-  function o(a) {
-    const i = a.match(/<([^>]+)>/);
-    return i ? i[1].split(",").map((g) => g.trim()).filter(Boolean).length : 0;
+  function r(i) {
+    const l = i.match(/<([^>]+)>/);
+    return l ? l[1].split(",").map((F) => F.trim()).filter(Boolean).length : 0;
   }
   const c = `
-        ${e}
-        type TargetType = ${n};
-        ${s.map((a, i) => `
-        declare function Fu${i}${a.signature};
-        type F${i} = ReturnType<typeof Fu${i}${o(a.signature) > 0 ? `<${Array(o(a.signature)).fill("any").join(", ")}>` : ""}>;
+        ${E(n)}
+        type TargetType = ${e};
+        ${t.map((i, l) => `
+        declare function Fu${l}${i.signature};
+        type F${l} = ReturnType<typeof Fu${l}${r(i.signature) > 0 ? `<${Array(r(i.signature)).fill("any").join(", ")}>` : ""}>;
         `).join(`
 `)}
-        ${s.map((a, i) => `const check${i}: TargetType = {} as F${i};`).join(`
+        ${t.map((i, l) => `const check${l}: TargetType = {} as F${l};`).join(`
 `)}
-    `;
-  console.log(c);
-  const u = t.createSourceFile(r, c, t.ScriptTarget.Latest), d = I(r, c, u), p = t.createProgram([r], {
-    ...x
-  }, d).getSemanticDiagnostics(), m = /* @__PURE__ */ new Set();
-  return p.forEach((a) => {
-    a.file === u && a.start !== void 0 && m.add(u.getLineAndCharacterOfPosition(a.start).line);
-  }), s.map((a, i) => {
-    const g = `const check${i}: TargetType = {} as F${i};`, T = c.split(`
-`).findIndex((h) => h.includes(g));
-    return T !== -1 && m.has(T) ? null : {
+    `, s = "index.ts", a = I(s, c), u = a.getSourceFile(s), g = a.languageService.getProgram().getSemanticDiagnostics(), p = /* @__PURE__ */ new Set();
+  return g.forEach((i) => {
+    i.file === u && i.start !== void 0 && p.add(u.getLineAndCharacterOfPosition(i.start).line);
+  }), t.map((i, l) => {
+    const F = `const check${l}: TargetType = {} as F${l};`, T = c.split(`
+`).findIndex((d) => d.includes(F));
+    return T !== -1 && p.has(T) ? null : {
       __typename: "NodeFunction",
       id: "gid://sagittarius/NodeFunction/1",
       functionDefinition: {
         __typename: "FunctionDefinition",
-        id: a.identifier,
-        identifier: a.identifier
+        id: i.identifier,
+        identifier: i.identifier
       },
       parameters: {
         __typename: "NodeParameterConnection",
-        nodes: (a.parameterDefinitions?.nodes || []).map((h) => ({
+        nodes: (i.parameterDefinitions?.nodes || []).map((d) => ({
           __typename: "NodeParameter",
           parameterDefinition: {
             __typename: "ParameterDefinition",
-            id: h?.identifier,
-            identifier: h?.identifier
+            id: d?.identifier,
+            identifier: d?.identifier
           },
           value: null
         }))
       }
     };
-  }).filter((a) => a !== null);
+  }).filter((i) => i !== null);
 }
-const W = (n, s, r, e) => {
-  const c = new Map(r.map((F) => [F.identifier, F])).get(s.functionDefinition?.identifier);
-  if (!c)
-    return {
-      isValid: !1,
-      inferredType: "any",
-      errors: [{ message: `Function ${s.id} not found`, code: 404, severity: "error" }]
-    };
-  const u = s.parameters?.nodes || [], d = [];
-  for (const F of u) {
-    const S = F.value;
-    if (S?.__typename === "ReferenceValue") {
-      const $ = z(n, s, S);
-      $.isValid || d.push({
-        message: $.error || "Scope error",
-        code: 403,
-        severity: "error"
-      });
-    }
-  }
-  if (d.length > 0)
-    return {
-      isValid: !1,
-      inferredType: "any",
-      errors: d
-    };
-  const p = u.map((F) => K(F, n, (S, $) => W(S, $, r, e))).map(
-    (F) => F === "undefined" ? "({} as any)" : F
-  ).join(", ");
-  let m = c.signature;
-  const a = `
-        ${E(e)}
-        declare function testFunc${m};
-        const result = testFunc(${p});
-    `, i = "node_virtual.ts", g = t.createSourceFile(i, a, t.ScriptTarget.Latest), _ = I(i, a, g), T = t.createProgram([i], x, _), h = T.getTypeChecker(), f = T.getSemanticDiagnostics(g);
-  let N = "any";
-  const l = (F) => {
-    if (t.isVariableDeclaration(F) && F.name.getText() === "result") {
-      const S = h.getTypeAtLocation(F);
-      N = h.typeToString(
-        S,
-        F,
-        t.TypeFormatFlags.NoTruncation | t.TypeFormatFlags.UseFullyQualifiedType
-      );
-    }
-    t.forEachChild(F, l);
-  };
-  l(g);
-  const v = f.map((F) => {
-    const S = t.flattenDiagnosticMessageText(F.messageText, `
-`), $ = /\b([TRKV])\b/.test(S), C = S.includes("not assignable to parameter of type") && (S.includes("'{}'") || S.includes("undefined")) || S.includes("not assignable to type 'undefined'") || S.includes("not assignable to type 'void'") || S.includes("may be a mistake because neither type sufficiently overlaps");
-    return {
-      message: S,
-      code: F.code,
-      severity: $ || C ? "warning" : "error"
-    };
-  });
-  return {
-    isValid: !v.some((F) => F.severity === "error"),
-    inferredType: N,
-    errors: v
-  };
-}, ee = (n, s, r, e, o) => {
-  const c = [], u = n.nodes?.nodes || [], d = u.find((i) => i?.id === s);
-  if (!d) return [];
-  const y = E(o), p = (i, g) => {
-    if (!r || r === "any" || i === "any") return !0;
-    const _ = `suggestion_check_${Math.random().toString(36).substring(7)}.ts`, T = `
-            ${y}
+const ye = (e, t, n, r, o) => {
+  const c = [], s = e.nodes?.nodes || [], a = s.find((i) => i?.id === t);
+  if (!a) return [];
+  const u = E(o), m = (i, l) => {
+    if (!n || n === "any" || i === "any") return !0;
+    const F = "index.ts", f = `
+            ${u}
             const val: ${i} = {} as any;
-            const test: ${r} = val${g ? `.${g}` : ""};
-        `, h = t.createSourceFile(_, T, t.ScriptTarget.Latest), f = I(_, T, h);
-    return !t.createProgram([_], x, f).getSemanticDiagnostics(h).some((v) => v.category === t.DiagnosticCategory.Error);
-  }, m = (i, g) => {
-    const _ = [], T = `probing_${Math.random().toString(36).substring(7)}.ts`, h = `
-            ${y}
+            const test: ${n} = val${l ? `.${l}` : ""};
+        `, T = I(F, f), d = T.getSourceFile(F);
+    return !T.languageService.getProgram().getSemanticDiagnostics(d).some((x) => x.category === v.DiagnosticCategory.Error);
+  }, g = (i, l) => {
+    const F = [], f = "index.ts", T = `
+            ${u}
             const val: ${i} = {} as any;
-        `, f = t.createSourceFile(T, h, t.ScriptTarget.Latest), N = I(T, h, f), l = t.createProgram([T], x, N), v = l.getTypeChecker();
-    p(i) && _.push({ ...g, referencePath: [] });
-    const F = ($, C = []) => {
+        `, d = I(f, T), S = d.getSourceFile(f), y = d.languageService.getProgram(), x = y.getTypeChecker();
+    m(i) && F.push({ ...l, referencePath: [] });
+    const h = ($, C = []) => {
       if (C.length > 3) return;
-      const A = $.getProperties();
-      for (const V of A) {
-        const R = V.getName();
-        let D;
-        if (v.getPropertyOfType) {
-          const b = v.getPropertyOfType($, R);
-          b && (D = v.getTypeOfSymbolAtLocation(b, f));
+      const P = $.getProperties();
+      for (const M of P) {
+        const L = M.getName();
+        let b;
+        if (x.getPropertyOfType) {
+          const _ = x.getPropertyOfType($, L);
+          _ && (b = x.getTypeOfSymbolAtLocation(_, S));
         } else {
-          const b = $.getProperty(R);
-          b && (D = v.getTypeOfSymbolAtLocation(b, f));
+          const _ = $.getProperty(L);
+          _ && (b = x.getTypeOfSymbolAtLocation(_, S));
         }
-        if (!D) continue;
-        const P = [...C, R], L = P.join(".");
-        p(i, L) && _.push({
-          ...g,
-          referencePath: P.map((b) => ({
+        if (!b) continue;
+        const D = [...C, L], V = D.join(".");
+        m(i, V) && F.push({
+          ...l,
+          referencePath: D.map((_) => ({
             __typename: "ReferencePath",
-            path: b
+            path: _
           }))
-        }), F(D, P);
+        }), h(b, D);
       }
     };
-    if (l.getSemanticDiagnostics(f).length === 0) {
+    if (y.getSemanticDiagnostics(S).length === 0) {
       let $;
-      const C = (A) => {
-        t.isVariableDeclaration(A) && A.name.getText() === "val" && ($ = v.getTypeAtLocation(A)), t.forEachChild(A, C);
+      const C = (P) => {
+        v.isVariableDeclaration(P) && P.name.getText() === "val" && ($ = x.getTypeAtLocation(P)), v.forEachChild(P, C);
       };
-      C(f), $ && F($);
+      C(S), $ && h($);
     }
-    return _;
+    return F;
   };
-  if (n.inputType) {
-    const i = n.inputType.identifier || "any";
-    c.push(...m(i, {
-      __typename: "ReferenceValue",
-      nodeFunctionId: null,
-      parameterIndex: 0,
-      referencePath: []
-    }));
+  if (e.inputType) {
+    const i = e.inputType || "any";
+    c.push(...g(i, {}));
   }
-  u.forEach((i) => {
-    if (!(!i || i.id === s) && H(n, i, d)) {
-      const g = W(n, i, e, o);
-      c.push(...m(g.inferredType, {
+  s.forEach((i) => {
+    if (!(!i || i.id === t) && ue(e, i, a)) {
+      const l = z(e, i, r, o);
+      c.push(...g(l.returnType, {
         __typename: "ReferenceValue",
         nodeFunctionId: i.id,
         referencePath: []
       }));
     }
   });
-  let a = k(n, s);
-  for (; a; ) {
-    if (e.find((g) => g.identifier === a.functionDefinition?.identifier)) {
-      const g = a.parameters?.nodes?.findIndex((_) => {
-        const T = _?.value;
-        if (T?.__typename === "NodeFunctionIdWrapper") {
-          const h = T;
-          return h.id === s || U(n, h.id || void 0, s);
+  let p = O(e, t);
+  for (; p; ) {
+    if (r.find((l) => l.identifier === p.functionDefinition?.identifier)) {
+      const l = p.parameters?.nodes?.findIndex((F) => {
+        const f = F?.value;
+        if (f?.__typename === "NodeFunctionIdWrapper") {
+          const T = f;
+          return T.id === t || U(e, T.id || void 0, t);
         }
         return !1;
       });
-      g !== void 0 && g !== -1 && c.push(...m("any", {
+      l !== void 0 && l !== -1 && c.push(...g("any", {
         __typename: "ReferenceValue",
-        nodeFunctionId: a.id,
-        parameterIndex: g,
+        nodeFunctionId: p.id,
+        parameterIndex: l,
         inputIndex: 0,
         referencePath: []
       }));
     }
-    a = k(n, a.id);
+    p = O(e, p.id);
   }
   return c;
 };
-function H(n, s, r) {
-  const e = n.nodes?.nodes || [];
-  let o = s.nextNodeId;
+function ue(e, t, n) {
+  const r = e.nodes?.nodes || [];
+  let o = t.nextNodeId;
   const c = /* @__PURE__ */ new Set();
   for (; o; ) {
-    if (o === r.id) return !0;
+    if (o === n.id) return !0;
     if (c.has(o)) break;
-    c.add(o), o = e.find((y) => y?.id === o)?.nextNodeId;
+    c.add(o), o = r.find((u) => u?.id === o)?.nextNodeId;
   }
-  let u = k(n, r.id);
-  for (; u; ) {
-    if (u.id === s.id) return !0;
-    u = k(n, u.id);
+  let s = O(e, n.id);
+  for (; s; ) {
+    if (s.id === t.id) return !0;
+    s = O(e, s.id);
   }
   return !1;
 }
-function k(n, s) {
-  return n.nodes?.nodes?.find(
-    (e) => e?.parameters?.nodes?.some(
-      (o) => o?.value?.__typename === "NodeFunctionIdWrapper" && o.value.id === s
+function O(e, t) {
+  return e.nodes?.nodes?.find(
+    (r) => r?.parameters?.nodes?.some(
+      (o) => o?.value?.__typename === "NodeFunctionIdWrapper" && o.value.id === t
     )
   ) || void 0;
 }
-function U(n, s, r) {
-  if (!s) return !1;
-  if (s === r) return !0;
-  const o = (n.nodes?.nodes || []).find((u) => u?.id === s);
-  return o ? o.nextNodeId && U(n, o.nextNodeId || void 0, r) ? !0 : !!o.parameters?.nodes?.some((u) => {
-    const d = u?.value;
-    return d?.__typename === "NodeFunctionIdWrapper" ? U(n, d.id || void 0, r) : !1;
+function U(e, t, n) {
+  if (!t) return !1;
+  if (t === n) return !0;
+  const o = (e.nodes?.nodes || []).find((s) => s?.id === t);
+  return o ? o.nextNodeId && U(e, o.nextNodeId || void 0, n) ? !0 : !!o.parameters?.nodes?.some((s) => {
+    const a = s?.value;
+    return a?.__typename === "NodeFunctionIdWrapper" ? U(e, a.id || void 0, n) : !1;
   }) : !1;
 }
-const te = (n) => {
-  const r = `const tempValue = ${JSON.stringify(n.value)};`, e = "temp_value.ts", o = t.createSourceFile(e, r, t.ScriptTarget.Latest), c = I(e, r, o), d = t.createProgram([e], { target: t.ScriptTarget.Latest, noEmit: !0 }, c).getTypeChecker();
-  let y = "any";
-  const p = (m) => {
-    if (t.isVariableDeclaration(m) && m.name.getText() === "tempValue") {
-      const a = d.getTypeAtLocation(m);
-      y = d.typeToString(
-        a,
-        m,
-        t.TypeFormatFlags.NoTruncation | t.TypeFormatFlags.UseFullyQualifiedType
-      );
-    }
-    t.forEachChild(m, p);
-  };
-  return p(o), y;
-};
-var q = /* @__PURE__ */ ((n) => (n[n.PRIMITIVE = 0] = "PRIMITIVE", n[n.TYPE = 1] = "TYPE", n[n.ARRAY = 2] = "ARRAY", n[n.OBJECT = 3] = "OBJECT", n))(q || {});
-const ne = (n, s) => {
-  const r = E(s), e = `type_probe_${Math.random().toString(36).substring(7)}.ts`, o = `
-        ${r}
-        type TargetType = ${n};
-        const val: TargetType = {} as any;
-    `, c = t.createSourceFile(e, o, t.ScriptTarget.Latest), u = I(e, o, c), y = t.createProgram([e], x, u).getTypeChecker();
-  let p = 1;
-  const m = (a) => {
-    if (t.isVariableDeclaration(a) && a.name.getText() === "val") {
-      const i = y.getTypeAtLocation(a);
-      y.isArrayType(i) ? p = 2 : i.isStringLiteral() || i.isNumberLiteral() || (i.getFlags() & (t.TypeFlags.String | t.TypeFlags.Number | t.TypeFlags.Boolean | t.TypeFlags.EnumLiteral | t.TypeFlags.BigInt | t.TypeFlags.ESSymbol)) !== 0 ? p = 0 : (i.isClassOrInterface() || (i.getFlags() & t.TypeFlags.Object) !== 0) && i.getProperties().length > 0 ? p = 3 : p = 1;
-    }
-    t.forEachChild(a, m);
-  };
-  return m(c), p;
-}, re = (n, s) => {
-  const r = `
-        ${E(s)}
-        type Target = ${n};
-    `, e = "temp_type_to_value.ts", o = t.createSourceFile(e, r, t.ScriptTarget.Latest, !0), c = I(e, r, o), d = t.createProgram([e], x, c).getTypeChecker(), y = o.statements.find(
-    (i) => t.isTypeAliasDeclaration(i) && i.name.text === "Target"
-  );
-  if (!y)
-    return { __typename: "LiteralValue", value: null };
-  const p = d.getTypeAtLocation(y.type), m = (i, g, _ = /* @__PURE__ */ new Set()) => {
-    if (_.has(i)) return null;
-    _.add(i);
-    const T = i.getFlags();
-    if (i.isUnion()) {
-      if (g.type, t.isTypeAliasDeclaration(g) && g.type && t.isUnionTypeNode(g.type)) {
-        const N = d.getTypeFromTypeNode(g.type.types[0]);
-        return m(N, g, _);
+const ve = (e) => {
+  if (!e) return [];
+  const t = `type T = ${e}; const val: T = {} as any;`, n = "index.ts", r = I(n, t), o = r.getSourceFile(n), s = r.languageService.getProgram().getTypeChecker(), a = o.statements.find(v.isTypeAliasDeclaration);
+  if (!a) return [];
+  const u = s.getTypeAtLocation(a), m = (p) => p.isUnion() ? p.types.flatMap(m) : p.isStringLiteral() ? [p.value] : p.isNumberLiteral() ? [p.value.toString()] : p.intrinsicName === "true" ? ["true"] : p.intrinsicName === "false" ? ["false"] : [];
+  return Array.from(new Set(m(u))).map((p) => ({
+    __typename: "LiteralValue",
+    value: p
+  }));
+}, k = (e) => e.replace(/[^a-zA-Z0-9]/g, "_"), Fe = (e, t, n) => {
+  const r = /* @__PURE__ */ new Set(), o = e.nodes?.nodes || [], c = new Map(t.map((d) => [d.identifier, d])), s = (d, S = "") => {
+    if (r.has(d)) return "";
+    const y = o.find((L) => L?.id === d);
+    if (!y || !y.functionDefinition) return "";
+    r.add(d);
+    const x = c.get(y.functionDefinition?.identifier);
+    if (!x) return `${S}// Error: Function ${y.functionDefinition.identifier} not found
+`;
+    const N = (y.parameters?.nodes || []).map((L, b) => {
+      const D = L.value;
+      if (!D) return "undefined";
+      if (D.__typename === "ReferenceValue") {
+        const V = D;
+        if (!V.nodeFunctionId) return "undefined";
+        let _ = V.parameterIndex !== void 0 ? `/* @pos ${d} ${b} */ p_${k(V.nodeFunctionId)}_${V.parameterIndex}` : `/* @pos ${d} ${b} */ node_${k(V.nodeFunctionId)}`;
+        return V.referencePath?.forEach((j) => {
+          _ += `?.${j.path}`;
+        }), _;
       }
-      const h = i.types.filter((N) => {
-        const l = N.getFlags();
-        return !(l & t.TypeFlags.Undefined) && !(l & t.TypeFlags.Null);
-      }), f = h.length > 0 ? h[0] : i.types[0];
-      return m(f, g, _);
-    }
-    if (T & t.TypeFlags.StringLiteral) return i.value;
-    if (T & t.TypeFlags.String) return "sample";
-    if (T & t.TypeFlags.NumberLiteral) return i.value;
-    if (T & t.TypeFlags.Number) return 1;
-    if (T & t.TypeFlags.BooleanLiteral) return i.intrinsicName === "true";
-    if (T & t.TypeFlags.Boolean) return !1;
-    if (d.isArrayType(i)) {
-      const f = i.typeArguments?.[0] || d.getAnyType();
-      return [m(f, g, _)];
-    }
-    if (i.isClassOrInterface() || T & t.TypeFlags.Object || i.getProperties().length > 0) {
-      const h = {};
-      return i.getProperties().forEach((N) => {
-        const l = d.getTypeOfSymbolAtLocation(N, g);
-        l && (h[N.getName()] = m(l, g, _));
-      }), h;
+      if (D.__typename === "LiteralValue")
+        return `/* @pos ${d} ${b} */ ${JSON.stringify(D.value)}`;
+      if (D.__typename === "NodeFunctionIdWrapper") {
+        const V = D, _ = `p_${k(y.id)}_${b}`, j = s(V.id, S + "  ");
+        return `/* @pos ${d} ${b} */ (${_}) => {
+${j}${S}}`;
+      }
+      return "undefined";
+    }).join(", "), $ = `node_${k(y.id)}`, C = `fn_${x.identifier?.replace(/::/g, "_")}`, P = N.includes("undefined");
+    let M = `${S}const ${$} = ${C}(${N})${P ? " as any" : ""} ;
+`;
+    return y.nextNodeId && (M += s(y.nextNodeId, S)), M;
+  }, a = E(n), u = t.map((d) => `declare function fn_${d.identifier?.replace(/::/g, "_")}${d.signature}`).join(`
+`), m = o.map((d) => d?.id ? s(d.id) : "").filter((d) => d !== "").join(`
+`), g = `${a}
+${u}
+
+// --- Flow ---
+${m}`, p = "index.ts", i = I(p, g), l = i.getSourceFile(p), T = i.languageService.getProgram().getSemanticDiagnostics(l).map((d) => {
+    const S = Z(d.messageText, `
+`);
+    if (S.includes("Argument of type 'undefined'") || S.includes("not assignable to type 'undefined'")) return null;
+    let x, h;
+    if (d.start !== void 0) {
+      const C = l.getFullText().substring(0, d.start).match(/\/\* @pos ([^ ]+) (\d+) \*\/\s*$/);
+      C && (x = C[1], h = parseInt(C[2], 10));
     }
-    return null;
-  };
+    return {
+      message: S,
+      code: d.code,
+      severity: "error",
+      nodeId: x,
+      parameterIndex: h
+    };
+  }).filter((d) => d !== null);
   return {
-    value: m(p, y)
+    isValid: !T.some((d) => d?.severity === "error"),
+    returnType: "void",
+    diagnostics: T
   };
-}, ie = (n) => {
-  if (!n) return [];
-  const s = `type T = ${n}; const val: T = {} as any;`, r = "suggestions_virtual.ts", e = t.createSourceFile(r, s, t.ScriptTarget.Latest), o = I(r, s, e), u = t.createProgram([r], { ...x, noLib: !0 }, o).getTypeChecker(), d = e.statements.find(t.isTypeAliasDeclaration);
-  if (!d) return [];
-  const y = u.getTypeAtLocation(d), p = (a) => a.isUnion() ? a.types.flatMap(p) : a.isStringLiteral() ? [a.value] : a.isNumberLiteral() ? [a.value.toString()] : a.intrinsicName === "true" ? ["true"] : a.intrinsicName === "false" ? ["false"] : [];
-  return Array.from(new Set(p(y))).map((a) => ({
-    __typename: "LiteralValue",
-    value: a
-  }));
-}, se = (n, s, r) => {
-  const e = JSON.stringify(s.value), o = `
-        ${E(r)}
-        const testValue: ${n} = ${e};
-    `, c = "value_check.ts", u = t.createSourceFile(c, o, t.ScriptTarget.Latest), d = I(c, o, u), p = t.createProgram([c], x, d).getSemanticDiagnostics(u);
-  return p.length > 0 ? {
-    isValid: !1,
-    error: t.flattenDiagnosticMessageText(p[0].messageText, `
-`)
-  } : { isValid: !0 };
-}, oe = (n, s, r) => {
-  const o = new Map(s.map((l) => [l.identifier, l])).get(n.functionDefinition?.identifier);
-  if (!o)
+}, he = (e, t, n) => {
+  const r = JSON.stringify(t.value), o = `
+        ${E(n)}
+        const testValue: ${e} = ${r};
+    `, c = "index.ts", u = I(c, o).languageService.getSemanticDiagnostics(c).map((m) => {
+    const g = v.flattenDiagnosticMessageText(m.messageText, `
+`), p = /\b([TRKV])\b/.test(g), i = g.includes("not assignable to parameter of type") && (g.includes("'{}'") || g.includes("undefined")) || g.includes("not assignable to type 'undefined'") || g.includes("not assignable to type 'void'") || g.includes("may be a mistake because neither type sufficiently overlaps");
     return {
-      parameters: [],
-      returnType: "any"
+      message: g,
+      code: m.code,
+      severity: p || i ? "warning" : "error"
     };
-  const c = {
-    id: "gid://sagittarius/Flow/0",
-    nodes: { __typename: "NodeFunctionConnection", nodes: [n] }
-  }, y = (n.parameters?.nodes || []).map((l) => K(l, c, (v, F) => W(v, F, s, r))).map((l) => l === "undefined" ? "({} as any)" : l).join(", "), p = o.signature, m = `
-        ${E(r)}
-        declare function testFunc${p};
-        const result = testFunc(${y});
-    `, a = "node_types_virtual.ts", i = t.createSourceFile(a, m, t.ScriptTarget.Latest), g = I(a, m, i), T = t.createProgram([a], x, g).getTypeChecker();
-  let h = "any", f = [];
-  const N = (l) => {
-    if (t.isVariableDeclaration(l) && l.name.getText() === "result") {
-      const v = T.getTypeAtLocation(l);
-      if (h = T.typeToString(
-        v,
-        l,
-        t.TypeFormatFlags.NoTruncation
-      ), t.isCallExpression(l.initializer)) {
-        const F = l.initializer, S = T.getResolvedSignature(F);
-        S && (f = S.getParameters().map(($) => {
-          const C = T.getTypeOfSymbolAtLocation($, F);
-          return T.typeToString(
-            C,
-            F,
-            t.TypeFormatFlags.NoTruncation
-          );
-        }));
-      }
-    }
-    t.forEachChild(l, N);
-  };
-  return N(i), {
-    parameters: f,
-    returnType: h
+  });
+  return {
+    isValid: !u.some((m) => m.severity === "error"),
+    returnType: "void",
+    diagnostics: u
   };
 };
 export {
-  q as DataTypeVariant,
-  Z as getFlowValidation,
-  X as getNodeSuggestions,
-  W as getNodeValidation,
-  ee as getReferenceSuggestions,
-  te as getTypeFromValue,
-  ne as getTypeVariant,
-  oe as getTypesFromNode,
-  re as getValueFromType,
-  ie as getValueSuggestions,
-  se as getValueValidation
+  ce as DataTypeVariant,
+  Fe as getFlowValidation,
+  me as getNodeSuggestions,
+  z as getNodeValidation,
+  ye as getReferenceSuggestions,
+  de as getTypeFromValue,
+  fe as getTypeVariant,
+  pe as getTypesFromNode,
+  ge as getValueFromType,
+  ve as getValueSuggestions,
+  he as getValueValidation
 };