@code0-tech/triangulum 0.3.0 → 0.4.0

package/dist/triangulum.es.js

@@ -1,101 +1,101 @@
-import y, { 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]);
+import d, { flattenDiagnosticMessageText as Z } from "typescript";
+function R() {
+  return R = Object.assign ? Object.assign.bind() : function(t) {
+    for (var n = 1; n < arguments.length; n++) {
+      var i = arguments[n];
+      for (var r in i) ({}).hasOwnProperty.call(i, r) && (t[r] = i[r]);
     }
-    return e;
-  }, A.apply(null, arguments);
+    return t;
+  }, R.apply(null, arguments);
 }
-var W = !1;
+var K = !1;
 try {
-  W = typeof localStorage < "u";
+  K = 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) {
+var X = typeof process < "u", ee = K && typeof localStorage.getItem == "function" && /* @__PURE__ */ localStorage.getItem("DEBUG") || X && process.env.DEBUG, W = ee ? console.log : function(t) {
   return "";
 };
-function te(e, t, n, r, o) {
+function te(t, n, i, r, g) {
   r === void 0 && (r = {});
-  var s = A({}, G(n), r), c = re(e, t, s, n, o), a = c.languageServiceHost, u = c.updateFile, p = c.deleteFile, l = n.createLanguageService(a), h = l.getCompilerOptionsDiagnostics();
-  if (h.length) {
-    var i = Y(e, r, n);
-    throw new Error(n.formatDiagnostics(h, i.compilerHost));
+  var l = R({}, Y(i), r), p = re(t, n, l, i, g), u = p.languageServiceHost, c = p.updateFile, f = p.deleteFile, a = i.createLanguageService(u), F = a.getCompilerOptionsDiagnostics();
+  if (F.length) {
+    var s = G(t, r, i);
+    throw new Error(i.formatDiagnostics(F, s.compilerHost));
   }
   return {
     // @ts-ignore
     name: "vfs",
-    sys: e,
-    languageService: l,
-    getSourceFile: function(v) {
-      var d;
-      return (d = l.getProgram()) == null ? void 0 : d.getSourceFile(v);
+    sys: t,
+    languageService: a,
+    getSourceFile: function(e) {
+      var o;
+      return (o = a.getProgram()) == null ? void 0 : o.getSourceFile(e);
     },
-    createFile: function(v, d) {
-      u(n.createSourceFile(v, d, s.target, !1));
+    createFile: function(e, o) {
+      c(i.createSourceFile(e, o, l.target, !1));
     },
-    updateFile: function(v, d, T) {
-      var g = l.getProgram().getSourceFile(v);
-      if (!g)
-        throw new Error("Did not find a source file for " + v);
-      var S = g.text, m = T ?? n.createTextSpan(0, S.length), $ = S.slice(0, m.start) + d + S.slice(m.start + m.length), F = n.updateSourceFile(g, $, {
-        span: m,
-        newLength: d.length
+    updateFile: function(e, o, m) {
+      var v = a.getProgram().getSourceFile(e);
+      if (!v)
+        throw new Error("Did not find a source file for " + e);
+      var T = v.text, S = m ?? i.createTextSpan(0, T.length), C = T.slice(0, S.start) + o + T.slice(S.start + S.length), w = i.updateSourceFile(v, C, {
+        span: S,
+        newLength: o.length
       });
-      u(F);
+      c(w);
     },
-    deleteFile: function(v) {
-      var d = l.getProgram().getSourceFile(v);
-      d && p(d);
+    deleteFile: function(e) {
+      var o = a.getProgram().getSourceFile(e);
+      o && f(o);
     }
   };
 }
-function R(e) {
-  throw new Error("Method '" + e + "' is not implemented.");
+function I(t) {
+  throw new Error("Method '" + t + "' is not implemented.");
 }
-function w(e, t) {
+function k(t, n) {
   return function() {
-    for (var n = arguments.length, r = new Array(n), o = 0; o < n; o++)
-      r[o] = arguments[o];
-    var s = t.apply(void 0, r), c = typeof s == "string" ? s.slice(0, 80) + "..." : s;
-    return J.apply(void 0, ["> " + e].concat(r)), J("< " + c), s;
+    for (var i = arguments.length, r = new Array(i), g = 0; g < i; g++)
+      r[g] = arguments[g];
+    var l = n.apply(void 0, r), p = typeof l == "string" ? l.slice(0, 80) + "..." : l;
+    return W.apply(void 0, ["> " + t].concat(r)), W("< " + p), l;
   };
 }
-var G = function(t) {
-  return A({}, t.getDefaultCompilerOptions(), {
-    jsx: t.JsxEmit.React,
+var Y = function(n) {
+  return R({}, n.getDefaultCompilerOptions(), {
+    jsx: n.JsxEmit.React,
     strict: !0,
     esModuleInterop: !0,
-    module: t.ModuleKind.ESNext,
+    module: n.ModuleKind.ESNext,
     suppressOutputPathCheck: !0,
     skipLibCheck: !0,
     skipDefaultLibCheck: !0
-  }, t.versionMajorMinor && Number(t.versionMajorMinor.split(".")[0]) >= 6 ? {
+  }, n.versionMajorMinor && Number(n.versionMajorMinor.split(".")[0]) >= 6 ? {
     ignoreDeprecations: "6.0"
   } : {
-    moduleResolution: t.ModuleResolutionKind.NodeJs
+    moduleResolution: n.ModuleResolutionKind.NodeJs
   });
-}, K = function(t) {
-  return t.replace("/", "/lib.").toLowerCase();
+}, J = function(n) {
+  return n.replace("/", "/lib.").toLowerCase();
 };
-function ne(e) {
+function ne(t) {
   return {
     args: [],
     createDirectory: function() {
-      return R("createDirectory");
+      return I("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);
+    directoryExists: k("directoryExists", function(n) {
+      return Array.from(t.keys()).some(function(i) {
+        return i.startsWith(n);
       });
     }),
     exit: function() {
-      return R("exit");
+      return I("exit");
     },
-    fileExists: w("fileExists", function(t) {
-      return e.has(t) || e.has(K(t));
+    fileExists: k("fileExists", function(n) {
+      return t.has(n) || t.has(J(n));
     }),
     getCurrentDirectory: function() {
       return "/";
@@ -104,77 +104,77 @@ function ne(e) {
       return [];
     },
     getExecutingFilePath: function() {
-      return R("getExecutingFilePath");
+      return I("getExecutingFilePath");
     },
-    readDirectory: w("readDirectory", function(t) {
-      return t === "/" ? Array.from(e.keys()) : [];
+    readDirectory: k("readDirectory", function(n) {
+      return n === "/" ? Array.from(t.keys()) : [];
     }),
-    readFile: w("readFile", function(t) {
-      var n;
-      return (n = e.get(t)) != null ? n : e.get(K(t));
+    readFile: k("readFile", function(n) {
+      var i;
+      return (i = t.get(n)) != null ? i : t.get(J(n));
     }),
-    resolvePath: function(n) {
-      return n;
+    resolvePath: function(i) {
+      return i;
     },
     newLine: `
 `,
     useCaseSensitiveFileNames: !0,
     write: function() {
-      return R("write");
+      return I("write");
     },
-    writeFile: function(n, r) {
-      e.set(n, r);
+    writeFile: function(i, r) {
+      t.set(i, r);
     },
-    deleteFile: function(n) {
-      e.delete(n);
+    deleteFile: function(i) {
+      t.delete(i);
     }
   };
 }
-function Y(e, t, n) {
-  var r = /* @__PURE__ */ new Map(), o = function(a) {
-    return r.set(a.fileName, a), a;
-  }, s = {
-    compilerHost: A({}, e, {
-      getCanonicalFileName: function(a) {
-        return a;
+function G(t, n, i) {
+  var r = /* @__PURE__ */ new Map(), g = function(u) {
+    return r.set(u.fileName, u), u;
+  }, l = {
+    compilerHost: R({}, t, {
+      getCanonicalFileName: function(u) {
+        return u;
       },
       getDefaultLibFileName: function() {
-        return "/" + n.getDefaultLibFileName(t);
+        return "/" + i.getDefaultLibFileName(n);
       },
       // '/lib.d.ts',
       // getDefaultLibLocation: () => '/',
       getNewLine: function() {
-        return e.newLine;
+        return t.newLine;
       },
-      getSourceFile: function(a, u) {
-        var p;
-        return r.get(a) || o(n.createSourceFile(a, e.readFile(a), (p = u ?? t.target) != null ? p : G(n).target, !1));
+      getSourceFile: function(u, c) {
+        var f;
+        return r.get(u) || g(i.createSourceFile(u, t.readFile(u), (f = c ?? n.target) != null ? f : Y(i).target, !1));
       },
       useCaseSensitiveFileNames: function() {
-        return e.useCaseSensitiveFileNames;
+        return t.useCaseSensitiveFileNames;
       }
     }),
-    updateFile: function(a) {
-      var u = r.has(a.fileName);
-      return e.writeFile(a.fileName, a.text), r.set(a.fileName, a), u;
+    updateFile: function(u) {
+      var c = r.has(u.fileName);
+      return t.writeFile(u.fileName, u.text), r.set(u.fileName, u), c;
     },
-    deleteFile: function(a) {
-      var u = r.has(a.fileName);
-      return r.delete(a.fileName), e.deleteFile(a.fileName), u;
+    deleteFile: function(u) {
+      var c = r.has(u.fileName);
+      return r.delete(u.fileName), t.deleteFile(u.fileName), c;
     }
   };
-  return s;
+  return l;
 }
-function re(e, t, n, r, o) {
-  var s = [].concat(t), c = Y(e, n, r), a = c.compilerHost, u = c.updateFile, p = c.deleteFile, l = /* @__PURE__ */ new Map(), h = 0, i = A({}, a, {
+function re(t, n, i, r, g) {
+  var l = [].concat(n), p = G(t, i, r), u = p.compilerHost, c = p.updateFile, f = p.deleteFile, a = /* @__PURE__ */ new Map(), F = 0, s = R({}, u, {
     getProjectVersion: function() {
-      return h.toString();
+      return F.toString();
     },
     getCompilationSettings: function() {
-      return n;
+      return i;
     },
     getCustomTransformers: function() {
-      return o;
+      return g;
     },
     // 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,
@@ -185,31 +185,74 @@ function re(e, t, n, r, o) {
     // 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 s.slice();
+      return l.slice();
     },
-    getScriptSnapshot: function(d) {
-      var T = e.readFile(d);
-      if (T && typeof T == "string")
-        return r.ScriptSnapshot.fromString(T);
+    getScriptSnapshot: function(o) {
+      var m = t.readFile(o);
+      if (m && typeof m == "string")
+        return r.ScriptSnapshot.fromString(m);
     },
-    getScriptVersion: function(d) {
-      return l.get(d) || "0";
+    getScriptVersion: function(o) {
+      return a.get(o) || "0";
     },
-    writeFile: e.writeFile
-  }), f = {
-    languageServiceHost: i,
-    updateFile: function(d) {
-      h++, l.set(d.fileName, h.toString()), s.includes(d.fileName) || s.push(d.fileName), u(d);
+    writeFile: t.writeFile
+  }), y = {
+    languageServiceHost: s,
+    updateFile: function(o) {
+      F++, a.set(o.fileName, F.toString()), l.includes(o.fileName) || l.push(o.fileName), c(o);
     },
-    deleteFile: function(d) {
-      h++, l.set(d.fileName, h.toString());
-      var T = s.indexOf(d.fileName);
-      T !== -1 && s.splice(T, 1), p(d);
+    deleteFile: function(o) {
+      F++, a.set(o.fileName, F.toString());
+      var m = l.indexOf(o.fileName);
+      m !== -1 && l.splice(m, 1), f(o);
     }
   };
-  return f;
+  return y;
 }
-const ie = `
+const ie = (t, n, i) => {
+  if (!t) return { parameters: [], returnType: "any" };
+  const r = t.id || "temp_node_id", g = {
+    ...t,
+    id: r,
+    parameters: {
+      ...t.parameters,
+      nodes: t.parameters?.nodes?.map((e) => e?.value ? e : { ...e, value: null }) || []
+    }
+  }, l = r + "_params", p = {
+    ...g,
+    id: l,
+    parameters: {
+      ...g.parameters,
+      nodes: g.parameters.nodes.map((e) => e.value?.__typename === "LiteralValue" && e.value.value !== null && typeof e.value.value != "object" ? { ...e, value: null } : e)
+    }
+  }, c = se({
+    nodes: { __typename: "NodeFunctionConnection", nodes: [g, p] }
+  }, n, i), f = L(r), a = L(l), F = c.parameters.get(f) || [], s = c.parameters.get(a) || [];
+  return {
+    parameters: F.map((e, o) => {
+      const m = s[o];
+      return m && m !== "any" && m !== "unknown" ? m : e;
+    }),
+    returnType: c.nodes.get(f) || "any"
+  };
+};
+var H = /* @__PURE__ */ ((t) => (t[t.PRIMITIVE = 0] = "PRIMITIVE", t[t.TYPE = 1] = "TYPE", t[t.ARRAY = 2] = "ARRAY", t[t.OBJECT = 3] = "OBJECT", t[t.NODE = 4] = "NODE", t))(H || {});
+const q = (t, n) => {
+  const r = `
+        ${O(n)}
+        type TargetType = ${t};
+        const val: TargetType = {} as any;
+    `, g = "index.ts", l = A(g, r), p = l.getSourceFile(g), c = l.languageService.getProgram().getTypeChecker();
+  let f = 1;
+  const a = (F) => {
+    if (d.isVariableDeclaration(F) && F.name.getText() === "val") {
+      const s = c.getTypeAtLocation(F);
+      s.getCallSignatures().length > 0 ? f = 4 : c.isArrayType(s) ? f = 2 : s.isStringLiteral() || s.isNumberLiteral() || (s.getFlags() & (d.TypeFlags.String | d.TypeFlags.Number | d.TypeFlags.Boolean | d.TypeFlags.EnumLiteral | d.TypeFlags.BigInt | d.TypeFlags.ESSymbol)) !== 0 ? f = 0 : (s.isClassOrInterface() || (s.getFlags() & d.TypeFlags.Object) !== 0) && s.getProperties().length > 0 ? f = 3 : f = 1;
+    }
+    d.forEachChild(F, a);
+  };
+  return a(p), f;
+}, ae = `
     interface Array<T> { 
         [n: number]: T; 
         length: number; 
@@ -223,573 +266,358 @@ const ie = `
     interface NewableFunction extends Function {}
     interface IArguments { }
     interface RegExp { }
+    type Record<K extends keyof any, T> = { [P in K]: T; };
     type ReturnType<T extends (...args: any) => any> = T extends (...args: any) => infer R ? R : any;
 `;
-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"], y, oe);
+function A(t, n) {
+  const i = /* @__PURE__ */ new Map();
+  i.set(t, n), i.set("lib.codezero.d.ts", ae);
+  const r = ne(i);
+  return te(r, [t, "lib.codezero.d.ts"], d, oe);
 }
 const oe = {
-  target: y.ScriptTarget.Latest,
+  target: d.ScriptTarget.Latest,
   lib: ["lib.codezero.d.ts"],
   noEmit: !0,
   strictNullChecks: !0
 };
-function V(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};`
+function O(t) {
+  const n = Array.from(new Set(t?.flatMap((r) => r.genericKeys || []))).map((r) => `type ${r} = any;`).join(`
+`), i = t?.map(
+    (r) => `type ${r.identifier}${(r.genericKeys?.length ?? 0) > 0 ? `<${r.genericKeys?.join(",")}>` : ""} = ${r.type};`
   ).join(`
 `);
-  return `${t}
-${n}`;
+  return `${n}
+${i}`;
 }
-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 n;
-}
-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);
+const L = (t) => t.replace(/[^a-zA-Z0-9]/g, "_");
+function U(t, n, i, r = !1) {
+  const g = t?.nodes?.nodes || [], l = new Map(n?.map((e) => [e.identifier, e])), p = /* @__PURE__ */ new Set(), u = (e, o, m) => {
+    const v = g.find((P) => P?.id === e);
+    if (!v || !v.functionDefinition?.identifier) return "undefined";
+    const S = (v.parameters?.nodes || []).map((P, x) => {
+      const E = P.value;
+      if (!E) return r ? `/* @pos ${e} ${x} */ {}` : `/* @pos ${e} ${x} */ undefined`;
+      if (E.__typename === "ReferenceValue") {
+        const $ = E;
+        if (!$.nodeFunctionId) return `/* @pos ${e} ${x} */ undefined`;
+        let N = $.inputIndex !== void 0 ? `p_${L($.nodeFunctionId)}_${$.parameterIndex}[${$.inputIndex}]` : `node_${L($.nodeFunctionId)}`;
+        return $.referencePath?.forEach((h) => {
+          N += `?.${h.path}`;
+        }), `/* @pos ${e} ${x} */ ${N}`;
+      }
+      return E.__typename === "LiteralValue" ? `/* @pos ${e} ${x} */ ${JSON.stringify(E.value)}` : E.__typename === "NodeFunctionIdWrapper" ? u(E.id, e, x) : r ? `/* @pos ${e} ${x} */ ({} as any)` : `/* @pos ${e} ${x} */ undefined`;
+    }).join(", "), w = `${`fn_${v.functionDefinition.identifier.replace(/::/g, "_")}`}(${S})`;
+    return o !== void 0 && m !== void 0 ? `${w}` : w;
+  }, c = (e, o = "") => {
+    if (p.has(e)) return "";
+    const m = g.find((N) => N?.id === e);
+    if (!m || !m.functionDefinition) return "";
+    if (p.add(e), !l.get(m.functionDefinition.identifier)) return `${o}// Error: Function ${m.functionDefinition.identifier} not found
+`;
+    let T = { parameters: [] };
+    r || (T = ie(m, n, i));
+    const C = (m.parameters?.nodes || []).map((N, h) => {
+      const b = N.value;
+      if (!b) return r ? `/* @pos ${e} ${h} */ {}` : `/* @pos ${e} ${h} */ undefined`;
+      if (b.__typename === "ReferenceValue") {
+        const _ = b;
+        if (!_.nodeFunctionId) return `/* @pos ${e} ${h} */ undefined`;
+        let D = _.inputIndex !== void 0 ? `p_${L(_.nodeFunctionId)}_${_.parameterIndex}[${_.inputIndex}]` : `node_${L(_.nodeFunctionId)}`;
+        return _.referencePath?.forEach((V) => {
+          D += `?.${V.path}`;
+        }), `/* @pos ${e} ${h} */ ${D}`;
+      }
+      if (b.__typename === "LiteralValue") return `/* @pos ${e} ${h} */ ${JSON.stringify(b.value)}`;
+      if (b.__typename === "NodeFunctionIdWrapper") {
+        const _ = b;
+        if (r) {
+          const D = `p_${L(e)}_${h}`, V = c(_.id, o + "    ");
+          return `/* @pos ${e} ${h} */ (...${D}) => {
+${V}${o}}`;
+        } else {
+          const D = T.parameters[h];
+          if (D ? q(D, i) === H.NODE : !1) {
+            const M = `p_${L(e)}_${h}`, j = c(_.id, o + "    ");
+            return `/* @pos ${e} ${h} */ (...${M}) => {
+${j}${o}}`;
+          } else {
+            const M = u(_.id, e, h);
+            return `/* @pos ${e} ${h} */ ${M}`;
+          }
+        }
+      }
+      return r ? `/* @pos ${e} ${h} */ {}` : `/* @pos ${e} ${h} */ undefined`;
+    }).join(", "), w = `node_${L(m.id)}`, P = `fn_${m?.functionDefinition?.identifier?.replace(/::/g, "_")}`, x = C.includes("undefined"), E = m.functionDefinition.identifier === "std::control::return";
+    let $ = `${o}${E ? "return " : `const ${w} = `}${P}(${C}) ;
+`;
+    return m.nextNodeId && ($ += c(m.nextNodeId, o)), $;
+  }, f = O(i), a = n?.map((e) => `declare function fn_${e.identifier?.replace(/::/g, "_")}${e.signature}`).join(`
+`), F = new Set(g.map((e) => e?.nextNodeId).filter((e) => !!e)), s = /* @__PURE__ */ new Set();
+  g.forEach((e) => e?.parameters?.nodes?.forEach((o) => {
+    o?.value?.__typename === "NodeFunctionIdWrapper" && o.value.id && s.add(o.value.id);
+  }));
+  const y = g.filter((e) => e?.id && !F.has(e.id) && !s.has(e.id)).map((e) => c(e.id)).join(`
+`);
+  return `${f}
+${a}
+
+// --- Flow ---
+${y}`;
 }
-function q(e, t, n) {
-  const r = e?.value;
-  if (!r) return "undefined";
-  if (r.__typename === "ReferenceValue") {
-    const o = r, s = B(t, o.nodeFunctionId);
-    if (!s) return "undefined";
-    let c = n?.(t, s).returnType;
-    if (o.referencePath && o.referencePath.length > 0) {
-      let a;
-      const u = s.parameters?.nodes;
-      if (u && u.length > 0) {
-        const p = u[0];
-        p?.value?.__typename === "LiteralValue" && (a = p.value.value);
+function se(t, n, i) {
+  const r = U(t, n, i, !0), g = "index.ts", l = A(g, r), p = l.getSourceFile(g), c = l.languageService.getProgram().getTypeChecker(), f = /* @__PURE__ */ new Map(), a = /* @__PURE__ */ new Map(), F = /* @__PURE__ */ new Map();
+  (t?.nodes?.nodes || []).forEach((e) => {
+    e?.id && F.set(L(e.id), e);
+  });
+  const y = (e) => {
+    if (d.isVariableDeclaration(e) && e.name.getText().startsWith("node_")) {
+      const o = e.name.getText().replace("node_", ""), m = c.getTypeAtLocation(e);
+      if (f.set(o, c.typeToString(m, e, d.TypeFormatFlags.NoTruncation)), e.initializer && d.isCallExpression(e.initializer)) {
+        const v = c.getResolvedSignature(e.initializer);
+        if (v) {
+          const T = v.getParameters().map((S) => {
+            const C = c.getTypeOfSymbolAtLocation(S, e.initializer);
+            return c.typeToString(C, e.initializer, d.TypeFormatFlags.NoTruncation);
+          });
+          a.set(o, T);
+        }
       }
-      c = ae(a, o.referencePath);
     }
-    return `({} as ${c})`;
-  }
-  if (r.__typename === "NodeFunctionIdWrapper") {
-    const o = r.id, s = B(t, o);
-    if (!s) return "(() => undefined)";
-    const c = (p) => {
-      if (p.functionDefinition?.identifier === "std::control::return")
-        return p;
-      const l = p.nextNodeId ? B(t, p.nextNodeId) : void 0;
-      return l ? c(l) : void 0;
-    }, a = c(s);
-    return a ? `(() => ({} as ${n?.(t, a)?.returnType}))` : "(() => undefined)";
-  }
-  return r.__typename === "LiteralValue" ? JSON.stringify(r.value) : "undefined";
-}
-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
-      )
-    );
-}, Q = (e, t, n, r = /* @__PURE__ */ new Set()) => {
-  const o = t?.id;
-  if (!o || r.has(o)) return !1;
-  r.add(o);
-  const s = (a) => {
-    const u = e?.nodes?.nodes?.find((p) => p?.nextNodeId === a);
-    return u ? u.id === n ? !0 : s(u.id) : !1;
-  };
-  if (s(o)) return !0;
-  const c = H(e, o);
-  return c ? c.id === n ? !0 : Q(e, c, n, r) : !1;
-}, se = (e, t, n) => {
-  if (!n?.nodeFunctionId)
-    return { isValid: !0 };
-  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);
+    if (d.isReturnStatement(e) && e.expression && d.isCallExpression(e.expression)) {
+      const o = e.expression;
+      c.getResolvedSignature(o);
     }
-    return {
-      isValid: !1,
-      error: `Invalid input reference: Node ${t?.id} is not in the scope of Node ${n.nodeFunctionId}.`
-    };
-  }
-  return Q(e, t, n.nodeFunctionId) ? { isValid: !0 } : {
-    isValid: !1,
-    error: `Node ${n.nodeFunctionId} has not been executed yet or is not visible in this scope.`
+    d.forEachChild(e, y);
   };
-}, fe = (e) => {
-  const n = `const tempValue = ${JSON.stringify(e?.value) ?? "any"};`, r = "index.ts", o = I(r, n), s = o.getSourceFile(r), a = o.languageService.getProgram().getTypeChecker();
-  let u = "any";
-  const p = (l) => {
-    if (y.isVariableDeclaration(l) && l.name.getText() === "tempValue") {
-      const h = a.getTypeAtLocation(l);
-      u = a.typeToString(
-        h,
-        l,
-        y.TypeFormatFlags.NoTruncation | y.TypeFormatFlags.UseFullyQualifiedType
+  return y(p), { nodes: f, parameters: a };
+}
+const ue = (t) => {
+  const i = `const tempValue = ${JSON.stringify(t?.value) ?? "any"};`, r = "index.ts", g = A(r, i), l = g.getSourceFile(r), u = g.languageService.getProgram().getTypeChecker();
+  let c = "any";
+  const f = (a) => {
+    if (d.isVariableDeclaration(a) && a.name.getText() === "tempValue") {
+      const F = u.getTypeAtLocation(a);
+      c = u.typeToString(
+        F,
+        a,
+        d.TypeFormatFlags.NoTruncation | d.TypeFormatFlags.UseFullyQualifiedType
       );
     }
-    y.forEachChild(l, p);
-  };
-  return p(s), 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[e.NODE = 4] = "NODE", e))(ce || {});
-const de = (e, t) => {
-  const r = `
-        ${V(t)}
-        type TargetType = ${e};
-        const val: TargetType = {} as any;
-    `, o = "index.ts", s = I(o, r), c = s.getSourceFile(o), u = s.languageService.getProgram().getTypeChecker();
-  let p = 1;
-  const l = (h) => {
-    if (y.isVariableDeclaration(h) && h.name.getText() === "val") {
-      const i = u.getTypeAtLocation(h);
-      i.getCallSignatures().length > 0 ? p = 4 : u.isArrayType(i) ? p = 2 : i.isStringLiteral() || i.isNumberLiteral() || (i.getFlags() & (y.TypeFlags.String | y.TypeFlags.Number | y.TypeFlags.Boolean | y.TypeFlags.EnumLiteral | y.TypeFlags.BigInt | y.TypeFlags.ESSymbol)) !== 0 ? p = 0 : (i.isClassOrInterface() || (i.getFlags() & y.TypeFlags.Object) !== 0) && i.getProperties().length > 0 ? p = 3 : p = 1;
-    }
-    y.forEachChild(h, l);
+    d.forEachChild(a, f);
   };
-  return l(c), p;
-}, ge = (e, t) => {
-  const n = `
-        ${V(t)}
-        type Target = ${e};
-    `, r = "index.ts", o = I(r, n), s = o.getSourceFile(r), a = o.languageService.getProgram().getTypeChecker(), u = s.statements.find(
-    (i) => y.isTypeAliasDeclaration(i) && i.name.text === "Target"
+  return f(l), c;
+}, ge = (t, n) => {
+  const i = `
+        ${O(n)}
+        type Target = ${t};
+    `, r = "index.ts", g = A(r, i), l = g.getSourceFile(r), u = g.languageService.getProgram().getTypeChecker(), c = l.statements.find(
+    (s) => d.isTypeAliasDeclaration(s) && s.name.text === "Target"
   );
-  if (!u)
+  if (!c)
     return { __typename: "LiteralValue", value: null };
-  const p = a.getTypeAtLocation(u.type), l = (i, f, v = /* @__PURE__ */ new Set()) => {
-    if (v.has(i)) return null;
-    v.add(i);
-    const d = i.getFlags();
-    if (i.isUnion()) {
-      if (f.type, y.isTypeAliasDeclaration(f) && f.type && y.isUnionTypeNode(f.type)) {
-        const S = a.getTypeFromTypeNode(f.type.types[0]);
-        return l(S, f, v);
+  const f = u.getTypeAtLocation(c.type), a = (s, y, e = /* @__PURE__ */ new Set()) => {
+    if (e.has(s)) return null;
+    e.add(s);
+    const o = s.getFlags();
+    if (s.isUnion()) {
+      if (y.type, d.isTypeAliasDeclaration(y) && y.type && d.isUnionTypeNode(y.type)) {
+        const T = u.getTypeFromTypeNode(y.type.types[0]);
+        return a(T, y, e);
       }
-      const T = i.types.filter((S) => {
-        const m = S.getFlags();
-        return !(m & y.TypeFlags.Undefined) && !(m & y.TypeFlags.Null);
-      }), g = T.length > 0 ? T[0] : i.types[0];
-      return l(g, f, v);
+      const m = s.types.filter((T) => {
+        const S = T.getFlags();
+        return !(S & d.TypeFlags.Undefined) && !(S & d.TypeFlags.Null);
+      }), v = m.length > 0 ? m[0] : s.types[0];
+      return a(v, y, e);
     }
-    if (d & y.TypeFlags.StringLiteral) return i.value;
-    if (d & y.TypeFlags.String) return "sample";
-    if (d & y.TypeFlags.NumberLiteral) return i.value;
-    if (d & y.TypeFlags.Number) return 1;
-    if (d & y.TypeFlags.BooleanLiteral) return i.intrinsicName === "true";
-    if (d & y.TypeFlags.Boolean) return !1;
-    if (a.isArrayType(i)) {
-      const g = i.typeArguments?.[0] || a.getAnyType();
-      return [l(g, f, v)];
+    if (o & d.TypeFlags.StringLiteral) return s.value;
+    if (o & d.TypeFlags.String) return "";
+    if (o & d.TypeFlags.NumberLiteral) return s.value;
+    if (o & d.TypeFlags.Number) return 0;
+    if (o & d.TypeFlags.BooleanLiteral) return s.intrinsicName === "true";
+    if (o & d.TypeFlags.Boolean) return !1;
+    if (u.isArrayType(s)) {
+      const v = s.typeArguments?.[0] || u.getAnyType();
+      return [a(v, y, e)];
     }
-    if (i.isClassOrInterface() || d & y.TypeFlags.Object || i.getProperties().length > 0) {
-      const T = {};
-      return i.getProperties().forEach((S) => {
-        const m = a.getTypeOfSymbolAtLocation(S, f);
-        m && (T[S.getName()] = l(m, f, v));
-      }), T;
+    if (s.isClassOrInterface() || o & d.TypeFlags.Object || s.getProperties().length > 0) {
+      const m = {};
+      return s.getProperties().forEach((T) => {
+        const S = u.getTypeOfSymbolAtLocation(T, y);
+        S && (m[T.getName()] = a(S, y, e));
+      }), m;
     }
     return null;
   };
   return {
-    value: l(p, u)
-  };
-}, z = (e, t, n, r) => {
-  const s = new Map(n?.map((F) => [F.identifier, F])).get(t?.functionDefinition?.identifier);
-  if (!s)
-    return {
-      isValid: !1,
-      returnType: "any",
-      diagnostics: [{ message: `Function ${t?.id} not found`, nodeId: t?.id, code: 404, severity: "error" }]
-    };
-  const c = t?.parameters?.nodes || [], a = [];
-  for (const F of c) {
-    const N = F.value;
-    if (N?.__typename === "ReferenceValue") {
-      const x = se(e, t, N);
-      x.isValid || a.push({
-        message: x.error || "Scope error",
-        code: 403,
-        nodeId: t?.id,
-        parameterIndex: c.indexOf(F),
-        severity: "error"
-      });
-    }
-  }
-  if (a.length > 0)
-    return {
-      isValid: !1,
-      returnType: "any",
-      diagnostics: a
-    };
-  const u = c.map((F) => q(F, e, (N, x) => z(N, x, n, r))), p = u.map(
-    (F) => F === "undefined" ? "({} as any)" : F
-  ).join(", ");
-  let l = s.signature;
-  const h = `
-        ${V(r)}
-        declare function testFunc${l};
-        const result = testFunc(${p});
-    `, i = "index.ts", f = I(i, h), v = f.getSourceFile(i), d = f.languageService.getProgram(), T = d.getTypeChecker(), g = d.getSemanticDiagnostics(v);
-  let S = "any";
-  const m = (F) => {
-    if (y.isVariableDeclaration(F) && F.name.getText() === "result") {
-      const N = T.getTypeAtLocation(F);
-      S = T.typeToString(
-        N,
-        F,
-        y.TypeFormatFlags.NoTruncation | y.TypeFormatFlags.UseFullyQualifiedType
-      );
-    }
-    y.forEachChild(F, m);
-  };
-  m(v);
-  const $ = g.map((F) => {
-    const N = y.flattenDiagnosticMessageText(F.messageText, `
-`), x = /\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,
-      nodeId: t?.id,
-      parameterIndex: (() => {
-        if (F.start !== void 0) {
-          const P = c.findIndex((M, L) => {
-            const b = h.indexOf(u[L]);
-            return F.start >= b && F.start < b + u[L].length;
-          });
-          if (P !== -1) return P;
-        }
-      })(),
-      severity: x || C ? "warning" : "error"
-    };
-  });
-  return {
-    isValid: !$.some((F) => F.severity === "error"),
-    returnType: S,
-    diagnostics: $
+    value: a(f, c)
   };
-}, pe = (e, t, n) => {
-  const o = new Map(t?.map((m) => [m.identifier, m])).get(e?.functionDefinition?.identifier);
-  if (!o)
-    return {
-      parameters: [],
-      returnType: "any"
+}, pe = (t, n, i) => {
+  let r = n;
+  const g = t ? q(t, i) : null;
+  if (t && n && g !== H.NODE) {
+    let l = function(y) {
+      const e = y.trim().match(/^<([^>]+)>/);
+      return e ? e[1].split(",").map((o) => o.trim()).filter(Boolean).length : 0;
     };
-  const s = {
-    id: "gid://sagittarius/Flow/0",
-    nodes: { __typename: "NodeFunctionConnection", nodes: [e] }
-  }, u = (e?.parameters?.nodes || []).map((m) => q(m, s, ($, F) => z($, F, t, n))).map((m) => m === "undefined" ? "({} as any)" : m).join(", "), p = o.signature, l = `
-        ${V(n)}
-        declare function testFunc${p};
-        const result = testFunc(${u});
-    `, h = "index.ts", i = I(h, l), f = i.getSourceFile(h), d = i.languageService.getProgram().getTypeChecker();
-  let T = "any", g = [];
-  const S = (m) => {
-    if (y.isVariableDeclaration(m) && m.name.getText() === "result") {
-      const $ = d.getTypeAtLocation(m);
-      if (T = d.typeToString(
-        $,
-        m,
-        y.TypeFormatFlags.NoTruncation
-      ), y.isCallExpression(m.initializer)) {
-        const F = m.initializer, N = d.getResolvedSignature(F);
-        N && (g = N.getParameters().map((x) => {
-          const C = d.getTypeOfSymbolAtLocation(x, F);
-          return d.typeToString(
-            C,
-            F,
-            y.TypeFormatFlags.NoTruncation
-          );
-        }));
-      }
-    }
-    y.forEachChild(m, S);
-  };
-  return S(f), {
-    parameters: g,
-    returnType: T
-  };
-}, me = (e, t, n) => {
-  let r = t;
-  if (e && t) {
-    let o = function(i) {
-      const f = i.match(/<([^>]+)>/);
-      return f ? f[1].split(",").map((v) => v.trim()).filter(Boolean).length : 0;
-    };
-    const s = `
-        ${V(n)}
-        type TargetType = ${e};
-        ${t?.map((i, f) => `
-                declare function Fu${f}${i.signature};
-                type F${f} = ReturnType<typeof Fu${f}${o(i.signature) > 0 ? `<${Array(o(i.signature)).fill("any").join(", ")}>` : ""}>;
+    const p = `
+        ${O(i)}
+        type TargetType = ${t};
+        ${n?.map((y, e) => `
+                declare function Fu${e}${y.signature};
+                type F${e} = ReturnType<typeof Fu${e}${l(y.signature) > 0 ? `<${Array(l(y.signature)).fill("any").join(", ")}>` : ""}>;
             `).join(`
 `)}
-        ${t?.map((i, f) => `const check${f}: TargetType = {} as F${f};`).join(`
+        ${n?.map((y, e) => `const check${e}: TargetType = {} as F${e};`).join(`
 `)}
-    `, c = "index.ts", a = I(c, s), u = a.getSourceFile(c), l = a.languageService.getProgram().getSemanticDiagnostics(), h = /* @__PURE__ */ new Set();
-    l.forEach((i) => {
-      i.file === u && i.start !== void 0 && h.add(u.getLineAndCharacterOfPosition(i.start).line);
-    }), r = t.filter((i, f) => {
-      const v = `const check${f}: TargetType = {} as F${f};`, T = s.split(`
-`).findIndex((g) => g.includes(v));
-      return T !== -1 && !h.has(T);
+        `, u = "index.ts", c = A(u, p), f = c.getSourceFile(u), F = c.languageService.getProgram().getSemanticDiagnostics(), s = /* @__PURE__ */ new Set();
+    F.forEach((y) => {
+      y.file === f && y.start !== void 0 && s.add(f.getLineAndCharacterOfPosition(y.start).line);
+    }), r = n.filter((y, e) => {
+      const o = `const check${e}: TargetType = {} as F${e};`, v = p.split(`
+`).findIndex((T) => T.includes(o));
+      return v !== -1 && !s.has(v);
     });
   }
-  return r?.map((o) => ({
+  return r?.map((l) => ({
     __typename: "NodeFunction",
     id: "gid://sagittarius/NodeFunction/1",
     functionDefinition: {
       __typename: "FunctionDefinition",
-      id: o.identifier,
-      identifier: o.identifier
+      id: l.id,
+      identifier: l.identifier
     },
     parameters: {
       __typename: "NodeParameterConnection",
-      nodes: (o.parameterDefinitions?.nodes || []).map((s) => ({
+      nodes: (l.parameterDefinitions?.nodes || []).map((p) => ({
         __typename: "NodeParameter",
         parameterDefinition: {
           __typename: "ParameterDefinition",
-          id: s?.identifier,
-          identifier: s?.identifier
+          id: p?.id,
+          identifier: p?.identifier
         },
         value: null
       }))
     }
-  })).filter((o) => o !== null) ?? [];
-}, ye = (e, t, n = "any", r, o) => {
-  if (!e) return [];
-  if (!t) return [];
-  const s = [], c = e?.nodes?.nodes || [], a = c.find((i) => i?.id === t);
-  if (!a) return [];
-  const u = V(o), p = (i, f) => {
-    if (!n || n === "any" || i === "any") return !0;
-    const v = "index.ts", d = `
-            ${u}
-            const val: ${i} = {} as any;
-            const test: ${n} = val${f ? `.${f}` : ""};
-        `, T = I(v, d), g = T.getSourceFile(v);
-    return !T.languageService.getProgram().getSemanticDiagnostics(g).some(($) => $.category === y.DiagnosticCategory.Error);
-  }, l = (i, f) => {
-    const v = [], d = "index.ts", T = `
-            ${u}
-            const val: ${i} = {} as any;
-        `, g = I(d, T), S = g.getSourceFile(d), m = g.languageService.getProgram(), $ = m.getTypeChecker();
-    p(i) && v.push({ ...f, referencePath: [] });
-    const F = (x, C = []) => {
-      if (C.length > 3) return;
-      const P = x.getProperties();
-      for (const M of P) {
-        const L = M.getName();
-        let b;
-        if ($.getPropertyOfType) {
-          const _ = $.getPropertyOfType(x, L);
-          _ && (b = $.getTypeOfSymbolAtLocation(_, S));
-        } else {
-          const _ = x.getProperty(L);
-          _ && (b = $.getTypeOfSymbolAtLocation(_, S));
-        }
-        if (!b) continue;
-        const D = [...C, L], E = D.join(".");
-        p(i, E) && v.push({
-          ...f,
-          referencePath: D.map((_) => ({
-            __typename: "ReferencePath",
-            path: _
-          }))
-        }), F(b, D);
-      }
-    };
-    if (m.getSemanticDiagnostics(S).length === 0) {
-      let x;
-      const C = (P) => {
-        y.isVariableDeclaration(P) && P.name.getText() === "val" && (x = $.getTypeAtLocation(P)), y.forEachChild(P, C);
-      };
-      C(S), x && F(x);
-    }
-    return v;
-  };
-  if (e.inputType) {
-    const i = e.inputType || "any";
-    s.push(...l(i, {}));
+  })).filter((l) => l !== null) ?? [];
+}, fe = (t, n, i, r, g) => {
+  const l = U(t, r, g, !0), p = "index.ts", u = A(p, l), c = u.getSourceFile(p), a = u.languageService.getProgram().getTypeChecker(), F = c.getFullText(), s = `/* @pos ${n} ${i} */`, e = F.indexOf(s) + s.length;
+  function o($, N) {
+    let h = $;
+    return d.forEachChild($, (b) => {
+      b.getStart(c, !0) <= N && b.getEnd() >= N && (h = o(b, N));
+    }), h;
   }
-  c.forEach((i) => {
-    if (!(!i || i.id === t) && ue(e, i, a)) {
-      const f = z(e, i, r, o);
-      s.push(...l(f.returnType, {
-        __typename: "ReferenceValue",
-        nodeFunctionId: i.id,
-        referencePath: []
-      }));
-    }
-  });
-  let h = O(e, t);
-  for (; h; ) {
-    if (r?.find((f) => f.identifier === h.functionDefinition?.identifier)) {
-      const f = h.parameters?.nodes?.findIndex((v) => {
-        const d = v?.value;
-        if (d?.__typename === "NodeFunctionIdWrapper") {
-          const T = d;
-          return T.id === t || U(e, T.id || void 0, t);
-        }
-        return !1;
-      });
-      f !== void 0 && f !== -1 && s.push(...l("any", {
-        __typename: "ReferenceValue",
-        nodeFunctionId: h.id,
-        parameterIndex: f,
-        inputIndex: 0,
-        referencePath: []
-      }));
+  const v = o(c, e);
+  let T;
+  if (d.isCallExpression(v) && (T = v), !T)
+    return [];
+  const S = a.getResolvedSignature(T);
+  if (!S) return [];
+  const C = S.getParameters(), w = C[i] || C[C.length - 1], P = a.getTypeOfSymbolAtLocation(w, v), x = a.getSymbolsInScope(v, d.SymbolFlags.Variable), E = [];
+  return x.forEach(($) => {
+    const N = $.getName();
+    if (!N.startsWith("node_") && !N.startsWith("p_")) return;
+    const h = $.valueDeclaration || $.declarations?.[0];
+    if (!h || h.getEnd() >= e)
+      return;
+    const b = a.getTypeOfSymbolAtLocation($, v);
+    if (N.startsWith("node_")) {
+      if ((b.flags & d.TypeFlags.Void) === 0 && a.isTypeAssignableTo(b, P)) {
+        const _ = N.replace("node_", "").replace(/___/g, "://").replace(/__/g, "/").replace(/_/g, "/");
+        E.push({
+          __typename: "ReferenceValue",
+          nodeFunctionId: _
+          // Bei node_ keine Indizes laut Vorgabe
+        });
+      }
+    } else if (N.startsWith("p_")) {
+      const _ = N.replace("p_", ""), D = _.lastIndexOf("_"), V = _.substring(0, D), M = parseInt(_.substring(D + 1), 10), j = V.replace("p_", "").replace(/___/g, "://").replace(/__/g, "/").replace(/_/g, "/");
+      if (a.isTupleType(b)) {
+        const z = b;
+        a.getTypeArguments(z).forEach((Q, B) => {
+          a.isTypeAssignableTo(Q, P) && E.push({
+            __typename: "ReferenceValue",
+            nodeFunctionId: j,
+            parameterIndex: isNaN(M) ? 0 : M,
+            inputIndex: B,
+            //@ts-ignore
+            inputTypeIdentifier: z.target.labeledElementDeclarations?.[B].name.getText()
+          });
+        });
+      }
     }
-    h = O(e, h.id);
-  }
-  return s;
-};
-function ue(e, t, n) {
-  const r = e.nodes?.nodes || [];
-  let o = t.nextNodeId;
-  const s = /* @__PURE__ */ new Set();
-  for (; o; ) {
-    if (o === n.id) return !0;
-    if (s.has(o)) break;
-    s.add(o), o = r.find((u) => u?.id === o)?.nextNodeId;
-  }
-  let c = O(e, n.id);
-  for (; c; ) {
-    if (c.id === t.id) return !0;
-    c = O(e, c.id);
-  }
-  return !1;
-}
-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(e, t, n) {
-  if (!t) return !1;
-  if (t === n) return !0;
-  const o = (e.nodes?.nodes || []).find((c) => c?.id === t);
-  return o ? o.nextNodeId && U(e, o.nextNodeId || void 0, n) ? !0 : !!o.parameters?.nodes?.some((c) => {
-    const a = c?.value;
-    return a?.__typename === "NodeFunctionIdWrapper" ? U(e, a.id || void 0, n) : !1;
-  }) : !1;
-}
-const ve = (e, t) => {
-  if (!e) return [];
-  const n = `
-        ${V(t)}
-        type T = ${e}; const val: T = {} as any;
-    `, r = "index.ts", o = I(r, n), s = o.getSourceFile(r), a = o.languageService.getProgram().getTypeChecker(), u = s.statements.find(y.isTypeAliasDeclaration);
-  if (!u) return [];
-  const p = a.getTypeAtLocation(u), l = (i) => i.isUnion() ? i.types.flatMap(l) : i.isStringLiteral() ? [i.value] : i.isNumberLiteral() ? [i.value.toString()] : i.intrinsicName === "true" ? ["true"] : i.intrinsicName === "false" ? ["false"] : [];
-  return Array.from(new Set(l(p))).map((i) => ({
+  }), E;
+}, me = (t, n) => {
+  if (!t) return [];
+  const i = `
+        ${O(n)}
+        type VALUE = ${t}; const val: VALUE = {} as any;
+    `, r = "index.ts", g = A(r, i), l = g.getSourceFile(r), u = g.languageService.getProgram().getTypeChecker(), c = l.statements.find(
+    (s) => d.isTypeAliasDeclaration(s) && s.name.text === "VALUE"
+  );
+  if (!c || !d.isTypeAliasDeclaration(c)) return [];
+  const f = u.getTypeAtLocation(c), a = (s) => s.isUnion() ? s.types.flatMap(a) : s.isStringLiteral() ? [s.value] : s.isNumberLiteral() ? [s.value.toString()] : s.intrinsicName === "true" ? ["true"] : s.intrinsicName === "false" ? ["false"] : [];
+  return Array.from(new Set(a(f))).map((s) => ({
     __typename: "LiteralValue",
-    value: i
+    value: s
   }));
-}, k = (e) => e.replace(/[^a-zA-Z0-9]/g, "_"), Fe = (e, t, n) => {
-  const r = /* @__PURE__ */ new Set(), o = e?.nodes?.nodes || [], s = new Map(t?.map((g) => [g.identifier, g])), c = (g, S = "") => {
-    if (r.has(g)) return "";
-    const m = o.find((L) => L?.id === g);
-    if (!m || !m.functionDefinition) return "";
-    r.add(g);
-    const $ = s.get(m.functionDefinition?.identifier);
-    if (!$) return `${S}// Error: Function ${m.functionDefinition.identifier} not found
-`;
-    const N = (m.parameters?.nodes || []).map((L, b) => {
-      const D = L.value;
-      if (!D) return "undefined";
-      if (D.__typename === "ReferenceValue") {
-        const E = D;
-        if (!E.nodeFunctionId) return "undefined";
-        let _ = E.parameterIndex !== void 0 ? `/* @pos ${g} ${b} */ p_${k(E.nodeFunctionId)}_${E.parameterIndex}` : `/* @pos ${g} ${b} */ node_${k(E.nodeFunctionId)}`;
-        return E.referencePath?.forEach((j) => {
-          _ += `?.${j.path}`;
-        }), _;
-      }
-      if (D.__typename === "LiteralValue")
-        return `/* @pos ${g} ${b} */ ${JSON.stringify(D.value)}`;
-      if (D.__typename === "NodeFunctionIdWrapper") {
-        const E = D, _ = `p_${k(m.id)}_${b}`, j = c(E.id, S + "  ");
-        return `/* @pos ${g} ${b} */ (${_}) => {
-${j}${S}}`;
-      }
-      return "undefined";
-    }).join(", "), x = `node_${k(m.id)}`, C = `fn_${$.identifier?.replace(/::/g, "_")}`, P = N.includes("undefined");
-    let M = `${S}const ${x} = ${C}(${N})${P ? " as any" : ""} ;
-`;
-    return m.nextNodeId && (M += c(m.nextNodeId, S)), M;
-  }, a = V(n), u = t?.map((g) => `declare function fn_${g.identifier?.replace(/::/g, "_")}${g.signature}`).join(`
-`), p = o.map((g) => g?.id ? c(g.id) : "").filter((g) => g !== "").join(`
-`), l = `${a}
-${u}
-
-// --- Flow ---
-${p}`, h = "index.ts", i = I(h, l), f = i.getSourceFile(h), T = i.languageService.getProgram().getSemanticDiagnostics(f).map((g) => {
-    const S = Z(g.messageText, `
+}, de = (t, n, i) => {
+  const r = U(t, n, i), g = "index.ts", l = A(g, r), p = l.getSourceFile(g), f = l.languageService.getProgram().getSemanticDiagnostics(p).map((a) => {
+    const F = Z(a.messageText, `
 `);
-    if (S.includes("Argument of type 'undefined'") || S.includes("not assignable to type 'undefined'")) return null;
-    let $, F;
-    if (g.start !== void 0) {
-      const C = f.getFullText().substring(0, g.start).match(/\/\* @pos ([^ ]+) (\d+) \*\/\s*$/);
-      C && ($ = C[1], F = parseInt(C[2], 10));
+    let s, y;
+    if (a.start !== void 0) {
+      const e = p.getFullText(), o = Math.max(0, a.start - 300), m = Math.min(e.length, a.start), v = e.substring(o, m), T = /\/\* @pos ([^ ]+) (\d+) \*\//g;
+      let S, C = null, w = -1;
+      for (; (S = T.exec(v)) !== null; ) {
+        const x = o + S.index + S[0].length;
+        x <= a.start && x > w && (w = x, C = S);
+      }
+      C && (s = C[1], y = parseInt(C[2], 10));
     }
     return {
-      message: S,
-      code: g.code,
+      message: F,
+      code: a.code,
       severity: "error",
-      nodeId: $,
-      parameterIndex: F
+      nodeId: s,
+      parameterIndex: y
     };
-  }).filter((g) => g !== null);
+  }).filter((a) => a !== null);
   return {
-    isValid: !T.some((g) => g?.severity === "error"),
+    isValid: !f.some((a) => a?.severity === "error"),
     returnType: "void",
-    diagnostics: T
+    diagnostics: f
   };
-}, he = (e, t, n) => {
-  const r = JSON.stringify(t?.value), o = `
-        ${V(n)}
-        const testValue: ${e} = ${r};
-    `, s = "index.ts", u = I(s, o).languageService.getSemanticDiagnostics(s).map((p) => {
-    const l = y.flattenDiagnosticMessageText(p.messageText, `
-`), h = /\b([TRKV])\b/.test(l), i = l.includes("not assignable to parameter of type") && (l.includes("'{}'") || l.includes("undefined")) || l.includes("not assignable to type 'undefined'") || l.includes("not assignable to type 'void'") || l.includes("may be a mistake because neither type sufficiently overlaps");
+}, ye = (t, n, i) => {
+  const r = JSON.stringify(n?.value), g = `
+        ${O(i)}
+        const testValue: ${t} = ${r};
+    `, l = "index.ts", c = A(l, g).languageService.getSemanticDiagnostics(l).map((f) => {
+    const a = d.flattenDiagnosticMessageText(f.messageText, `
+`), F = a.includes("not assignable to parameter of type") && (a.includes("'{}'") || a.includes("undefined")) || a.includes("not assignable to type 'undefined'") || a.includes("not assignable to type 'void'") || a.includes("may be a mistake because neither type sufficiently overlaps");
     return {
-      message: l,
-      code: p.code,
-      severity: h || i ? "warning" : "error"
+      message: a,
+      code: f.code,
+      severity: F ? "warning" : "error"
     };
   });
   return {
-    isValid: !u.some((p) => p.severity === "error"),
+    isValid: !c.some((f) => f.severity === "error"),
     returnType: "void",
-    diagnostics: u
+    diagnostics: c
   };
 };
 export {
-  ce as DataTypeVariant,
-  Fe as getFlowValidation,
-  me as getNodeSuggestions,
-  z as getNodeValidation,
-  ye as getReferenceSuggestions,
-  fe as getTypeFromValue,
-  de as getTypeVariant,
-  pe as getTypesFromNode,
+  H as DataTypeVariant,
+  de as getFlowValidation,
+  pe as getNodeSuggestions,
+  fe as getReferenceSuggestions,
+  ue as getTypeFromValue,
+  q as getTypeVariant,
+  ie as getTypesFromNode,
   ge as getValueFromType,
-  ve as getValueSuggestions,
-  he as getValueValidation
+  me as getValueSuggestions,
+  ye as getValueValidation
 };