@code0-tech/triangulum 0.2.0 → 0.4.0

package/dist/triangulum.es.js

@@ -1,101 +1,101 @@
-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]);
+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 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));
+  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: g,
-    getSourceFile: function(F) {
-      var f;
-      return (f = g.getProgram()) == null ? void 0 : f.getSourceFile(F);
+    sys: t,
+    languageService: a,
+    getSourceFile: function(e) {
+      var o;
+      return (o = a.getProgram()) == null ? void 0 : o.getSourceFile(e);
     },
-    createFile: function(F, f) {
-      u(n.createSourceFile(F, f, c.target, !1));
+    createFile: function(e, o) {
+      c(i.createSourceFile(e, o, l.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
+    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(h);
+      c(w);
     },
-    deleteFile: function(F) {
-      var f = g.getProgram().getSourceFile(F);
-      f && m(f);
+    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 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;
+    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;
-  }, c = {
-    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 m;
-        return r.get(a) || o(n.createSourceFile(a, e.readFile(a), (m = u ?? t.target) != null ? m : 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 c;
+  return l;
 }
-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, {
+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 p.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 c.slice();
+      return l.slice();
     },
-    getScriptSnapshot: function(f) {
-      var T = e.readFile(f);
-      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(f) {
-      return g.get(f) || "0";
+    getScriptVersion: function(o) {
+      return a.get(o) || "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);
+    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(f) {
-      p++, g.set(f.fileName, p.toString());
-      var T = c.indexOf(f.fileName);
-      T !== -1 && c.splice(T, 1), m(f);
+    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 l;
+  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,568 +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"], v, 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: v.ScriptTarget.Latest,
+  target: d.ScriptTarget.Latest,
   lib: ["lib.codezero.d.ts"],
   noEmit: !0,
   strictNullChecks: !0
 };
-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};`
+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, c = B(t, o.nodeFunctionId);
-    if (!c) return "undefined";
-    let s = n(t, c).returnType;
-    if (o.referencePath && o.referencePath.length > 0) {
-      let a;
-      const u = c.parameters?.nodes;
-      if (u && u.length > 0) {
-        const m = u[0];
-        m?.value?.__typename === "LiteralValue" && (a = m.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);
+        }
       }
-      s = ae(a, o.referencePath);
     }
-    return `({} as ${s})`;
-  }
-  if (r.__typename === "NodeFunctionIdWrapper") {
-    const o = r.id, c = B(t, o);
-    if (!c) return "(() => 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 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 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 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 (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);
   };
-}, 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
+  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
       );
     }
-    v.forEachChild(g, m);
+    d.forEachChild(a, f);
   };
-  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"
+  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 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);
+  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 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);
+      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 (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 (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() || 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;
+    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: g(m, u)
+    value: a(f, c)
   };
-}, 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" }]
+}, 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 = 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"
-      });
-    }
+    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(`
+`)}
+        ${n?.map((y, e) => `const check${e}: TargetType = {} as F${e};`).join(`
+`)}
+        `, 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);
+    });
   }
-  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: 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"
-    };
-  });
-  return {
-    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
-          );
-        }));
-      }
+  return r?.map((l) => ({
+    __typename: "NodeFunction",
+    id: "gid://sagittarius/NodeFunction/1",
+    functionDefinition: {
+      __typename: "FunctionDefinition",
+      id: l.id,
+      identifier: l.identifier
+    },
+    parameters: {
+      __typename: "NodeParameterConnection",
+      nodes: (l.parameterDefinitions?.nodes || []).map((p) => ({
+        __typename: "NodeParameter",
+        parameterDefinition: {
+          __typename: "ParameterDefinition",
+          id: p?.id,
+          identifier: p?.identifier
+        },
+        value: null
+      }))
     }
-    v.forEachChild(y, S);
-  };
-  return S(l), {
-    parameters: d,
-    returnType: T
-  };
-};
-function me(e, t, n) {
-  if (!e || !t || t.length === 0)
-    return [];
-  function r(i) {
-    const l = i.match(/<([^>]+)>/);
-    return l ? l[1].split(",").map((F) => F.trim()).filter(Boolean).length : 0;
+  })).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;
   }
-  const c = `
-        ${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(`
-`)}
-        ${t.map((i, l) => `const check${l}: TargetType = {} as F${l};`).join(`
-`)}
-    `, 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: i.identifier,
-        identifier: i.identifier
-      },
-      parameters: {
-        __typename: "NodeParameterConnection",
-        nodes: (i.parameterDefinitions?.nodes || []).map((d) => ({
-          __typename: "NodeParameter",
-          parameterDefinition: {
-            __typename: "ParameterDefinition",
-            id: d?.identifier,
-            identifier: d?.identifier
-          },
-          value: null
-        }))
+  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
+        });
       }
-    };
-  }).filter((i) => i !== null);
-}
-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: ${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;
-        `, 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 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 _ = $.getProperty(L);
-          _ && (b = x.getTypeOfSymbolAtLocation(_, S));
-        }
-        if (!b) continue;
-        const D = [...C, L], V = D.join(".");
-        m(i, V) && F.push({
-          ...l,
-          referencePath: D.map((_) => ({
-            __typename: "ReferencePath",
-            path: _
-          }))
-        }), h(b, D);
+    } 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()
+          });
+        });
       }
-    };
-    if (y.getSemanticDiagnostics(S).length === 0) {
-      let $;
-      const C = (P) => {
-        v.isVariableDeclaration(P) && P.name.getText() === "val" && ($ = x.getTypeAtLocation(P)), v.forEachChild(P, C);
-      };
-      C(S), $ && h($);
     }
-    return F;
-  };
-  if (e.inputType) {
-    const i = e.inputType || "any";
-    c.push(...g(i, {}));
-  }
-  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 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;
-      });
-      l !== void 0 && l !== -1 && c.push(...g("any", {
-        __typename: "ReferenceValue",
-        nodeFunctionId: p.id,
-        parameterIndex: l,
-        inputIndex: 0,
-        referencePath: []
-      }));
-    }
-    p = O(e, p.id);
-  }
-  return c;
-};
-function ue(e, t, n) {
-  const r = e.nodes?.nodes || [];
-  let o = t.nextNodeId;
-  const c = /* @__PURE__ */ new Set();
-  for (; o; ) {
-    if (o === n.id) return !0;
-    if (c.has(o)) break;
-    c.add(o), o = r.find((u) => u?.id === o)?.nextNodeId;
-  }
-  let s = O(e, n.id);
-  for (; s; ) {
-    if (s.id === t.id) return !0;
-    s = O(e, s.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((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 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) => ({
+  }), 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: p
+    value: s
   }));
-}, 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}`;
-        }), _;
-      }
-      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, `
+}, 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 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));
+    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: d.code,
+      message: F,
+      code: a.code,
       severity: "error",
-      nodeId: x,
-      parameterIndex: h
+      nodeId: s,
+      parameterIndex: y
     };
-  }).filter((d) => d !== null);
+  }).filter((a) => a !== null);
   return {
-    isValid: !T.some((d) => d?.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 = `
-        ${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");
+}, 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: g,
-      code: m.code,
-      severity: p || i ? "warning" : "error"
+      message: a,
+      code: f.code,
+      severity: F ? "warning" : "error"
     };
   });
   return {
-    isValid: !u.some((m) => m.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,
-  de as getTypeFromValue,
-  fe 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
 };