@esengine/blueprint 4.3.0 → 4.4.0

package/dist/index.js

@@ -5407,15 +5407,1491 @@ var DivideExecutor = _DivideExecutor;
 DivideExecutor = _ts_decorate10([
   RegisterNode(DivideTemplate)
 ], DivideExecutor);
+var ModuloTemplate = {
+  type: "Modulo",
+  title: "Modulo",
+  category: "math",
+  color: "#4CAF50",
+  description: "Returns the remainder of A divided by B (\u8FD4\u56DE A \u9664\u4EE5 B \u7684\u4F59\u6570)",
+  keywords: [
+    "modulo",
+    "mod",
+    "remainder",
+    "%",
+    "math"
+  ],
+  isPure: true,
+  inputs: [
+    {
+      name: "a",
+      type: "float",
+      displayName: "A",
+      defaultValue: 0
+    },
+    {
+      name: "b",
+      type: "float",
+      displayName: "B",
+      defaultValue: 1
+    }
+  ],
+  outputs: [
+    {
+      name: "result",
+      type: "float",
+      displayName: "Result"
+    }
+  ]
+};
+var _ModuloExecutor = class _ModuloExecutor {
+  execute(node, context) {
+    const a = Number(context.evaluateInput(node.id, "a", 0));
+    const b = Number(context.evaluateInput(node.id, "b", 1));
+    if (b === 0) return {
+      outputs: {
+        result: 0
+      }
+    };
+    return {
+      outputs: {
+        result: a % b
+      }
+    };
+  }
+};
+__name(_ModuloExecutor, "ModuloExecutor");
+var ModuloExecutor = _ModuloExecutor;
+ModuloExecutor = _ts_decorate10([
+  RegisterNode(ModuloTemplate)
+], ModuloExecutor);
+var AbsTemplate = {
+  type: "Abs",
+  title: "Absolute",
+  category: "math",
+  color: "#4CAF50",
+  description: "Returns the absolute value (\u8FD4\u56DE\u7EDD\u5BF9\u503C)",
+  keywords: [
+    "abs",
+    "absolute",
+    "math"
+  ],
+  isPure: true,
+  inputs: [
+    {
+      name: "value",
+      type: "float",
+      displayName: "Value",
+      defaultValue: 0
+    }
+  ],
+  outputs: [
+    {
+      name: "result",
+      type: "float",
+      displayName: "Result"
+    }
+  ]
+};
+var _AbsExecutor = class _AbsExecutor {
+  execute(node, context) {
+    const value = Number(context.evaluateInput(node.id, "value", 0));
+    return {
+      outputs: {
+        result: Math.abs(value)
+      }
+    };
+  }
+};
+__name(_AbsExecutor, "AbsExecutor");
+var AbsExecutor = _AbsExecutor;
+AbsExecutor = _ts_decorate10([
+  RegisterNode(AbsTemplate)
+], AbsExecutor);
+var MinTemplate = {
+  type: "Min",
+  title: "Min",
+  category: "math",
+  color: "#4CAF50",
+  description: "Returns the smaller of two values (\u8FD4\u56DE\u4E24\u4E2A\u503C\u4E2D\u8F83\u5C0F\u7684\u4E00\u4E2A)",
+  keywords: [
+    "min",
+    "minimum",
+    "smaller",
+    "math"
+  ],
+  isPure: true,
+  inputs: [
+    {
+      name: "a",
+      type: "float",
+      displayName: "A",
+      defaultValue: 0
+    },
+    {
+      name: "b",
+      type: "float",
+      displayName: "B",
+      defaultValue: 0
+    }
+  ],
+  outputs: [
+    {
+      name: "result",
+      type: "float",
+      displayName: "Result"
+    }
+  ]
+};
+var _MinExecutor = class _MinExecutor {
+  execute(node, context) {
+    const a = Number(context.evaluateInput(node.id, "a", 0));
+    const b = Number(context.evaluateInput(node.id, "b", 0));
+    return {
+      outputs: {
+        result: Math.min(a, b)
+      }
+    };
+  }
+};
+__name(_MinExecutor, "MinExecutor");
+var MinExecutor = _MinExecutor;
+MinExecutor = _ts_decorate10([
+  RegisterNode(MinTemplate)
+], MinExecutor);
+var MaxTemplate = {
+  type: "Max",
+  title: "Max",
+  category: "math",
+  color: "#4CAF50",
+  description: "Returns the larger of two values (\u8FD4\u56DE\u4E24\u4E2A\u503C\u4E2D\u8F83\u5927\u7684\u4E00\u4E2A)",
+  keywords: [
+    "max",
+    "maximum",
+    "larger",
+    "math"
+  ],
+  isPure: true,
+  inputs: [
+    {
+      name: "a",
+      type: "float",
+      displayName: "A",
+      defaultValue: 0
+    },
+    {
+      name: "b",
+      type: "float",
+      displayName: "B",
+      defaultValue: 0
+    }
+  ],
+  outputs: [
+    {
+      name: "result",
+      type: "float",
+      displayName: "Result"
+    }
+  ]
+};
+var _MaxExecutor = class _MaxExecutor {
+  execute(node, context) {
+    const a = Number(context.evaluateInput(node.id, "a", 0));
+    const b = Number(context.evaluateInput(node.id, "b", 0));
+    return {
+      outputs: {
+        result: Math.max(a, b)
+      }
+    };
+  }
+};
+__name(_MaxExecutor, "MaxExecutor");
+var MaxExecutor = _MaxExecutor;
+MaxExecutor = _ts_decorate10([
+  RegisterNode(MaxTemplate)
+], MaxExecutor);
+var ClampTemplate = {
+  type: "Clamp",
+  title: "Clamp",
+  category: "math",
+  color: "#4CAF50",
+  description: "Clamps a value between min and max (\u5C06\u503C\u9650\u5236\u5728\u6700\u5C0F\u548C\u6700\u5927\u4E4B\u95F4)",
+  keywords: [
+    "clamp",
+    "limit",
+    "range",
+    "bound",
+    "math"
+  ],
+  isPure: true,
+  inputs: [
+    {
+      name: "value",
+      type: "float",
+      displayName: "Value",
+      defaultValue: 0
+    },
+    {
+      name: "min",
+      type: "float",
+      displayName: "Min",
+      defaultValue: 0
+    },
+    {
+      name: "max",
+      type: "float",
+      displayName: "Max",
+      defaultValue: 1
+    }
+  ],
+  outputs: [
+    {
+      name: "result",
+      type: "float",
+      displayName: "Result"
+    }
+  ]
+};
+var _ClampExecutor = class _ClampExecutor {
+  execute(node, context) {
+    const value = Number(context.evaluateInput(node.id, "value", 0));
+    const min = Number(context.evaluateInput(node.id, "min", 0));
+    const max = Number(context.evaluateInput(node.id, "max", 1));
+    return {
+      outputs: {
+        result: Math.max(min, Math.min(max, value))
+      }
+    };
+  }
+};
+__name(_ClampExecutor, "ClampExecutor");
+var ClampExecutor = _ClampExecutor;
+ClampExecutor = _ts_decorate10([
+  RegisterNode(ClampTemplate)
+], ClampExecutor);
+var LerpTemplate = {
+  type: "Lerp",
+  title: "Lerp",
+  category: "math",
+  color: "#4CAF50",
+  description: "Linear interpolation between A and B (A \u548C B \u4E4B\u95F4\u7684\u7EBF\u6027\u63D2\u503C)",
+  keywords: [
+    "lerp",
+    "interpolate",
+    "blend",
+    "mix",
+    "math"
+  ],
+  isPure: true,
+  inputs: [
+    {
+      name: "a",
+      type: "float",
+      displayName: "A",
+      defaultValue: 0
+    },
+    {
+      name: "b",
+      type: "float",
+      displayName: "B",
+      defaultValue: 1
+    },
+    {
+      name: "t",
+      type: "float",
+      displayName: "Alpha",
+      defaultValue: 0.5
+    }
+  ],
+  outputs: [
+    {
+      name: "result",
+      type: "float",
+      displayName: "Result"
+    }
+  ]
+};
+var _LerpExecutor = class _LerpExecutor {
+  execute(node, context) {
+    const a = Number(context.evaluateInput(node.id, "a", 0));
+    const b = Number(context.evaluateInput(node.id, "b", 1));
+    const t = Number(context.evaluateInput(node.id, "t", 0.5));
+    return {
+      outputs: {
+        result: a + (b - a) * t
+      }
+    };
+  }
+};
+__name(_LerpExecutor, "LerpExecutor");
+var LerpExecutor = _LerpExecutor;
+LerpExecutor = _ts_decorate10([
+  RegisterNode(LerpTemplate)
+], LerpExecutor);
+var RandomRangeTemplate = {
+  type: "RandomRange",
+  title: "Random Range",
+  category: "math",
+  color: "#4CAF50",
+  description: "Returns a random number between min and max (\u8FD4\u56DE min \u548C max \u4E4B\u95F4\u7684\u968F\u673A\u6570)",
+  keywords: [
+    "random",
+    "range",
+    "rand",
+    "math"
+  ],
+  isPure: true,
+  inputs: [
+    {
+      name: "min",
+      type: "float",
+      displayName: "Min",
+      defaultValue: 0
+    },
+    {
+      name: "max",
+      type: "float",
+      displayName: "Max",
+      defaultValue: 1
+    }
+  ],
+  outputs: [
+    {
+      name: "result",
+      type: "float",
+      displayName: "Result"
+    }
+  ]
+};
+var _RandomRangeExecutor = class _RandomRangeExecutor {
+  execute(node, context) {
+    const min = Number(context.evaluateInput(node.id, "min", 0));
+    const max = Number(context.evaluateInput(node.id, "max", 1));
+    return {
+      outputs: {
+        result: min + Math.random() * (max - min)
+      }
+    };
+  }
+};
+__name(_RandomRangeExecutor, "RandomRangeExecutor");
+var RandomRangeExecutor = _RandomRangeExecutor;
+RandomRangeExecutor = _ts_decorate10([
+  RegisterNode(RandomRangeTemplate)
+], RandomRangeExecutor);
+var RandomIntTemplate = {
+  type: "RandomInt",
+  title: "Random Integer",
+  category: "math",
+  color: "#4CAF50",
+  description: "Returns a random integer between min and max inclusive (\u8FD4\u56DE min \u548C max \u4E4B\u95F4\u7684\u968F\u673A\u6574\u6570\uFF0C\u5305\u542B\u8FB9\u754C)",
+  keywords: [
+    "random",
+    "int",
+    "integer",
+    "rand",
+    "math"
+  ],
+  isPure: true,
+  inputs: [
+    {
+      name: "min",
+      type: "int",
+      displayName: "Min",
+      defaultValue: 0
+    },
+    {
+      name: "max",
+      type: "int",
+      displayName: "Max",
+      defaultValue: 10
+    }
+  ],
+  outputs: [
+    {
+      name: "result",
+      type: "int",
+      displayName: "Result"
+    }
+  ]
+};
+var _RandomIntExecutor = class _RandomIntExecutor {
+  execute(node, context) {
+    const min = Math.floor(Number(context.evaluateInput(node.id, "min", 0)));
+    const max = Math.floor(Number(context.evaluateInput(node.id, "max", 10)));
+    return {
+      outputs: {
+        result: Math.floor(min + Math.random() * (max - min + 1))
+      }
+    };
+  }
+};
+__name(_RandomIntExecutor, "RandomIntExecutor");
+var RandomIntExecutor = _RandomIntExecutor;
+RandomIntExecutor = _ts_decorate10([
+  RegisterNode(RandomIntTemplate)
+], RandomIntExecutor);
+var PowerTemplate = {
+  type: "Power",
+  title: "Power",
+  category: "math",
+  color: "#4CAF50",
+  description: "Returns base raised to the power of exponent (\u8FD4\u56DE\u5E95\u6570\u7684\u6307\u6570\u6B21\u5E42)",
+  keywords: [
+    "power",
+    "pow",
+    "exponent",
+    "^",
+    "math"
+  ],
+  isPure: true,
+  inputs: [
+    {
+      name: "base",
+      type: "float",
+      displayName: "Base",
+      defaultValue: 2
+    },
+    {
+      name: "exponent",
+      type: "float",
+      displayName: "Exponent",
+      defaultValue: 2
+    }
+  ],
+  outputs: [
+    {
+      name: "result",
+      type: "float",
+      displayName: "Result"
+    }
+  ]
+};
+var _PowerExecutor = class _PowerExecutor {
+  execute(node, context) {
+    const base = Number(context.evaluateInput(node.id, "base", 2));
+    const exponent = Number(context.evaluateInput(node.id, "exponent", 2));
+    return {
+      outputs: {
+        result: Math.pow(base, exponent)
+      }
+    };
+  }
+};
+__name(_PowerExecutor, "PowerExecutor");
+var PowerExecutor = _PowerExecutor;
+PowerExecutor = _ts_decorate10([
+  RegisterNode(PowerTemplate)
+], PowerExecutor);
+var SqrtTemplate = {
+  type: "Sqrt",
+  title: "Square Root",
+  category: "math",
+  color: "#4CAF50",
+  description: "Returns the square root (\u8FD4\u56DE\u5E73\u65B9\u6839)",
+  keywords: [
+    "sqrt",
+    "square",
+    "root",
+    "math"
+  ],
+  isPure: true,
+  inputs: [
+    {
+      name: "value",
+      type: "float",
+      displayName: "Value",
+      defaultValue: 4
+    }
+  ],
+  outputs: [
+    {
+      name: "result",
+      type: "float",
+      displayName: "Result"
+    }
+  ]
+};
+var _SqrtExecutor = class _SqrtExecutor {
+  execute(node, context) {
+    const value = Number(context.evaluateInput(node.id, "value", 4));
+    return {
+      outputs: {
+        result: Math.sqrt(Math.abs(value))
+      }
+    };
+  }
+};
+__name(_SqrtExecutor, "SqrtExecutor");
+var SqrtExecutor = _SqrtExecutor;
+SqrtExecutor = _ts_decorate10([
+  RegisterNode(SqrtTemplate)
+], SqrtExecutor);
+var FloorTemplate = {
+  type: "Floor",
+  title: "Floor",
+  category: "math",
+  color: "#4CAF50",
+  description: "Rounds down to the nearest integer (\u5411\u4E0B\u53D6\u6574)",
+  keywords: [
+    "floor",
+    "round",
+    "down",
+    "int",
+    "math"
+  ],
+  isPure: true,
+  inputs: [
+    {
+      name: "value",
+      type: "float",
+      displayName: "Value",
+      defaultValue: 0
+    }
+  ],
+  outputs: [
+    {
+      name: "result",
+      type: "int",
+      displayName: "Result"
+    }
+  ]
+};
+var _FloorExecutor = class _FloorExecutor {
+  execute(node, context) {
+    const value = Number(context.evaluateInput(node.id, "value", 0));
+    return {
+      outputs: {
+        result: Math.floor(value)
+      }
+    };
+  }
+};
+__name(_FloorExecutor, "FloorExecutor");
+var FloorExecutor = _FloorExecutor;
+FloorExecutor = _ts_decorate10([
+  RegisterNode(FloorTemplate)
+], FloorExecutor);
+var CeilTemplate = {
+  type: "Ceil",
+  title: "Ceil",
+  category: "math",
+  color: "#4CAF50",
+  description: "Rounds up to the nearest integer (\u5411\u4E0A\u53D6\u6574)",
+  keywords: [
+    "ceil",
+    "ceiling",
+    "round",
+    "up",
+    "int",
+    "math"
+  ],
+  isPure: true,
+  inputs: [
+    {
+      name: "value",
+      type: "float",
+      displayName: "Value",
+      defaultValue: 0
+    }
+  ],
+  outputs: [
+    {
+      name: "result",
+      type: "int",
+      displayName: "Result"
+    }
+  ]
+};
+var _CeilExecutor = class _CeilExecutor {
+  execute(node, context) {
+    const value = Number(context.evaluateInput(node.id, "value", 0));
+    return {
+      outputs: {
+        result: Math.ceil(value)
+      }
+    };
+  }
+};
+__name(_CeilExecutor, "CeilExecutor");
+var CeilExecutor = _CeilExecutor;
+CeilExecutor = _ts_decorate10([
+  RegisterNode(CeilTemplate)
+], CeilExecutor);
+var RoundTemplate = {
+  type: "Round",
+  title: "Round",
+  category: "math",
+  color: "#4CAF50",
+  description: "Rounds to the nearest integer (\u56DB\u820D\u4E94\u5165\u5230\u6700\u8FD1\u7684\u6574\u6570)",
+  keywords: [
+    "round",
+    "int",
+    "math"
+  ],
+  isPure: true,
+  inputs: [
+    {
+      name: "value",
+      type: "float",
+      displayName: "Value",
+      defaultValue: 0
+    }
+  ],
+  outputs: [
+    {
+      name: "result",
+      type: "int",
+      displayName: "Result"
+    }
+  ]
+};
+var _RoundExecutor = class _RoundExecutor {
+  execute(node, context) {
+    const value = Number(context.evaluateInput(node.id, "value", 0));
+    return {
+      outputs: {
+        result: Math.round(value)
+      }
+    };
+  }
+};
+__name(_RoundExecutor, "RoundExecutor");
+var RoundExecutor = _RoundExecutor;
+RoundExecutor = _ts_decorate10([
+  RegisterNode(RoundTemplate)
+], RoundExecutor);
+var NegateTemplate = {
+  type: "Negate",
+  title: "Negate",
+  category: "math",
+  color: "#4CAF50",
+  description: "Returns the negative of a value (\u8FD4\u56DE\u503C\u7684\u8D1F\u6570)",
+  keywords: [
+    "negate",
+    "negative",
+    "minus",
+    "-",
+    "math"
+  ],
+  isPure: true,
+  inputs: [
+    {
+      name: "value",
+      type: "float",
+      displayName: "Value",
+      defaultValue: 0
+    }
+  ],
+  outputs: [
+    {
+      name: "result",
+      type: "float",
+      displayName: "Result"
+    }
+  ]
+};
+var _NegateExecutor = class _NegateExecutor {
+  execute(node, context) {
+    const value = Number(context.evaluateInput(node.id, "value", 0));
+    return {
+      outputs: {
+        result: -value
+      }
+    };
+  }
+};
+__name(_NegateExecutor, "NegateExecutor");
+var NegateExecutor = _NegateExecutor;
+NegateExecutor = _ts_decorate10([
+  RegisterNode(NegateTemplate)
+], NegateExecutor);
+var SignTemplate = {
+  type: "Sign",
+  title: "Sign",
+  category: "math",
+  color: "#4CAF50",
+  description: "Returns -1, 0, or 1 based on the sign of the value (\u6839\u636E\u503C\u7684\u7B26\u53F7\u8FD4\u56DE -1\u30010 \u6216 1)",
+  keywords: [
+    "sign",
+    "positive",
+    "negative",
+    "math"
+  ],
+  isPure: true,
+  inputs: [
+    {
+      name: "value",
+      type: "float",
+      displayName: "Value",
+      defaultValue: 0
+    }
+  ],
+  outputs: [
+    {
+      name: "result",
+      type: "int",
+      displayName: "Result"
+    }
+  ]
+};
+var _SignExecutor = class _SignExecutor {
+  execute(node, context) {
+    const value = Number(context.evaluateInput(node.id, "value", 0));
+    return {
+      outputs: {
+        result: Math.sign(value)
+      }
+    };
+  }
+};
+__name(_SignExecutor, "SignExecutor");
+var SignExecutor = _SignExecutor;
+SignExecutor = _ts_decorate10([
+  RegisterNode(SignTemplate)
+], SignExecutor);
+
+// src/nodes/logic/ComparisonNodes.ts
+function _ts_decorate11(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+__name(_ts_decorate11, "_ts_decorate");
+var EqualTemplate = {
+  type: "Equal",
+  title: "Equal",
+  category: "logic",
+  color: "#9C27B0",
+  description: "Returns true if A equals B (\u5982\u679C A \u7B49\u4E8E B \u5219\u8FD4\u56DE true)",
+  keywords: [
+    "equal",
+    "==",
+    "same",
+    "compare",
+    "logic"
+  ],
+  isPure: true,
+  inputs: [
+    {
+      name: "a",
+      type: "any",
+      displayName: "A"
+    },
+    {
+      name: "b",
+      type: "any",
+      displayName: "B"
+    }
+  ],
+  outputs: [
+    {
+      name: "result",
+      type: "bool",
+      displayName: "Result"
+    }
+  ]
+};
+var _EqualExecutor = class _EqualExecutor {
+  execute(node, context) {
+    const a = context.evaluateInput(node.id, "a", null);
+    const b = context.evaluateInput(node.id, "b", null);
+    return {
+      outputs: {
+        result: a === b
+      }
+    };
+  }
+};
+__name(_EqualExecutor, "EqualExecutor");
+var EqualExecutor = _EqualExecutor;
+EqualExecutor = _ts_decorate11([
+  RegisterNode(EqualTemplate)
+], EqualExecutor);
+var NotEqualTemplate = {
+  type: "NotEqual",
+  title: "Not Equal",
+  category: "logic",
+  color: "#9C27B0",
+  description: "Returns true if A does not equal B (\u5982\u679C A \u4E0D\u7B49\u4E8E B \u5219\u8FD4\u56DE true)",
+  keywords: [
+    "not",
+    "equal",
+    "!=",
+    "different",
+    "compare",
+    "logic"
+  ],
+  isPure: true,
+  inputs: [
+    {
+      name: "a",
+      type: "any",
+      displayName: "A"
+    },
+    {
+      name: "b",
+      type: "any",
+      displayName: "B"
+    }
+  ],
+  outputs: [
+    {
+      name: "result",
+      type: "bool",
+      displayName: "Result"
+    }
+  ]
+};
+var _NotEqualExecutor = class _NotEqualExecutor {
+  execute(node, context) {
+    const a = context.evaluateInput(node.id, "a", null);
+    const b = context.evaluateInput(node.id, "b", null);
+    return {
+      outputs: {
+        result: a !== b
+      }
+    };
+  }
+};
+__name(_NotEqualExecutor, "NotEqualExecutor");
+var NotEqualExecutor = _NotEqualExecutor;
+NotEqualExecutor = _ts_decorate11([
+  RegisterNode(NotEqualTemplate)
+], NotEqualExecutor);
+var GreaterThanTemplate = {
+  type: "GreaterThan",
+  title: "Greater Than",
+  category: "logic",
+  color: "#9C27B0",
+  description: "Returns true if A is greater than B (\u5982\u679C A \u5927\u4E8E B \u5219\u8FD4\u56DE true)",
+  keywords: [
+    "greater",
+    "than",
+    ">",
+    "compare",
+    "logic"
+  ],
+  isPure: true,
+  inputs: [
+    {
+      name: "a",
+      type: "float",
+      displayName: "A",
+      defaultValue: 0
+    },
+    {
+      name: "b",
+      type: "float",
+      displayName: "B",
+      defaultValue: 0
+    }
+  ],
+  outputs: [
+    {
+      name: "result",
+      type: "bool",
+      displayName: "Result"
+    }
+  ]
+};
+var _GreaterThanExecutor = class _GreaterThanExecutor {
+  execute(node, context) {
+    const a = Number(context.evaluateInput(node.id, "a", 0));
+    const b = Number(context.evaluateInput(node.id, "b", 0));
+    return {
+      outputs: {
+        result: a > b
+      }
+    };
+  }
+};
+__name(_GreaterThanExecutor, "GreaterThanExecutor");
+var GreaterThanExecutor = _GreaterThanExecutor;
+GreaterThanExecutor = _ts_decorate11([
+  RegisterNode(GreaterThanTemplate)
+], GreaterThanExecutor);
+var GreaterThanOrEqualTemplate = {
+  type: "GreaterThanOrEqual",
+  title: "Greater Or Equal",
+  category: "logic",
+  color: "#9C27B0",
+  description: "Returns true if A is greater than or equal to B (\u5982\u679C A \u5927\u4E8E\u7B49\u4E8E B \u5219\u8FD4\u56DE true)",
+  keywords: [
+    "greater",
+    "equal",
+    ">=",
+    "compare",
+    "logic"
+  ],
+  isPure: true,
+  inputs: [
+    {
+      name: "a",
+      type: "float",
+      displayName: "A",
+      defaultValue: 0
+    },
+    {
+      name: "b",
+      type: "float",
+      displayName: "B",
+      defaultValue: 0
+    }
+  ],
+  outputs: [
+    {
+      name: "result",
+      type: "bool",
+      displayName: "Result"
+    }
+  ]
+};
+var _GreaterThanOrEqualExecutor = class _GreaterThanOrEqualExecutor {
+  execute(node, context) {
+    const a = Number(context.evaluateInput(node.id, "a", 0));
+    const b = Number(context.evaluateInput(node.id, "b", 0));
+    return {
+      outputs: {
+        result: a >= b
+      }
+    };
+  }
+};
+__name(_GreaterThanOrEqualExecutor, "GreaterThanOrEqualExecutor");
+var GreaterThanOrEqualExecutor = _GreaterThanOrEqualExecutor;
+GreaterThanOrEqualExecutor = _ts_decorate11([
+  RegisterNode(GreaterThanOrEqualTemplate)
+], GreaterThanOrEqualExecutor);
+var LessThanTemplate = {
+  type: "LessThan",
+  title: "Less Than",
+  category: "logic",
+  color: "#9C27B0",
+  description: "Returns true if A is less than B (\u5982\u679C A \u5C0F\u4E8E B \u5219\u8FD4\u56DE true)",
+  keywords: [
+    "less",
+    "than",
+    "<",
+    "compare",
+    "logic"
+  ],
+  isPure: true,
+  inputs: [
+    {
+      name: "a",
+      type: "float",
+      displayName: "A",
+      defaultValue: 0
+    },
+    {
+      name: "b",
+      type: "float",
+      displayName: "B",
+      defaultValue: 0
+    }
+  ],
+  outputs: [
+    {
+      name: "result",
+      type: "bool",
+      displayName: "Result"
+    }
+  ]
+};
+var _LessThanExecutor = class _LessThanExecutor {
+  execute(node, context) {
+    const a = Number(context.evaluateInput(node.id, "a", 0));
+    const b = Number(context.evaluateInput(node.id, "b", 0));
+    return {
+      outputs: {
+        result: a < b
+      }
+    };
+  }
+};
+__name(_LessThanExecutor, "LessThanExecutor");
+var LessThanExecutor = _LessThanExecutor;
+LessThanExecutor = _ts_decorate11([
+  RegisterNode(LessThanTemplate)
+], LessThanExecutor);
+var LessThanOrEqualTemplate = {
+  type: "LessThanOrEqual",
+  title: "Less Or Equal",
+  category: "logic",
+  color: "#9C27B0",
+  description: "Returns true if A is less than or equal to B (\u5982\u679C A \u5C0F\u4E8E\u7B49\u4E8E B \u5219\u8FD4\u56DE true)",
+  keywords: [
+    "less",
+    "equal",
+    "<=",
+    "compare",
+    "logic"
+  ],
+  isPure: true,
+  inputs: [
+    {
+      name: "a",
+      type: "float",
+      displayName: "A",
+      defaultValue: 0
+    },
+    {
+      name: "b",
+      type: "float",
+      displayName: "B",
+      defaultValue: 0
+    }
+  ],
+  outputs: [
+    {
+      name: "result",
+      type: "bool",
+      displayName: "Result"
+    }
+  ]
+};
+var _LessThanOrEqualExecutor = class _LessThanOrEqualExecutor {
+  execute(node, context) {
+    const a = Number(context.evaluateInput(node.id, "a", 0));
+    const b = Number(context.evaluateInput(node.id, "b", 0));
+    return {
+      outputs: {
+        result: a <= b
+      }
+    };
+  }
+};
+__name(_LessThanOrEqualExecutor, "LessThanOrEqualExecutor");
+var LessThanOrEqualExecutor = _LessThanOrEqualExecutor;
+LessThanOrEqualExecutor = _ts_decorate11([
+  RegisterNode(LessThanOrEqualTemplate)
+], LessThanOrEqualExecutor);
+var AndTemplate = {
+  type: "And",
+  title: "AND",
+  category: "logic",
+  color: "#9C27B0",
+  description: "Returns true if both A and B are true (\u5982\u679C A \u548C B \u90FD\u4E3A true \u5219\u8FD4\u56DE true)",
+  keywords: [
+    "and",
+    "&&",
+    "both",
+    "logic"
+  ],
+  isPure: true,
+  inputs: [
+    {
+      name: "a",
+      type: "bool",
+      displayName: "A",
+      defaultValue: false
+    },
+    {
+      name: "b",
+      type: "bool",
+      displayName: "B",
+      defaultValue: false
+    }
+  ],
+  outputs: [
+    {
+      name: "result",
+      type: "bool",
+      displayName: "Result"
+    }
+  ]
+};
+var _AndExecutor = class _AndExecutor {
+  execute(node, context) {
+    const a = Boolean(context.evaluateInput(node.id, "a", false));
+    const b = Boolean(context.evaluateInput(node.id, "b", false));
+    return {
+      outputs: {
+        result: a && b
+      }
+    };
+  }
+};
+__name(_AndExecutor, "AndExecutor");
+var AndExecutor = _AndExecutor;
+AndExecutor = _ts_decorate11([
+  RegisterNode(AndTemplate)
+], AndExecutor);
+var OrTemplate = {
+  type: "Or",
+  title: "OR",
+  category: "logic",
+  color: "#9C27B0",
+  description: "Returns true if either A or B is true (\u5982\u679C A \u6216 B \u4E3A true \u5219\u8FD4\u56DE true)",
+  keywords: [
+    "or",
+    "||",
+    "either",
+    "logic"
+  ],
+  isPure: true,
+  inputs: [
+    {
+      name: "a",
+      type: "bool",
+      displayName: "A",
+      defaultValue: false
+    },
+    {
+      name: "b",
+      type: "bool",
+      displayName: "B",
+      defaultValue: false
+    }
+  ],
+  outputs: [
+    {
+      name: "result",
+      type: "bool",
+      displayName: "Result"
+    }
+  ]
+};
+var _OrExecutor = class _OrExecutor {
+  execute(node, context) {
+    const a = Boolean(context.evaluateInput(node.id, "a", false));
+    const b = Boolean(context.evaluateInput(node.id, "b", false));
+    return {
+      outputs: {
+        result: a || b
+      }
+    };
+  }
+};
+__name(_OrExecutor, "OrExecutor");
+var OrExecutor = _OrExecutor;
+OrExecutor = _ts_decorate11([
+  RegisterNode(OrTemplate)
+], OrExecutor);
+var NotTemplate = {
+  type: "Not",
+  title: "NOT",
+  category: "logic",
+  color: "#9C27B0",
+  description: "Returns the opposite boolean value (\u8FD4\u56DE\u76F8\u53CD\u7684\u5E03\u5C14\u503C)",
+  keywords: [
+    "not",
+    "!",
+    "negate",
+    "invert",
+    "logic"
+  ],
+  isPure: true,
+  inputs: [
+    {
+      name: "value",
+      type: "bool",
+      displayName: "Value",
+      defaultValue: false
+    }
+  ],
+  outputs: [
+    {
+      name: "result",
+      type: "bool",
+      displayName: "Result"
+    }
+  ]
+};
+var _NotExecutor = class _NotExecutor {
+  execute(node, context) {
+    const value = Boolean(context.evaluateInput(node.id, "value", false));
+    return {
+      outputs: {
+        result: !value
+      }
+    };
+  }
+};
+__name(_NotExecutor, "NotExecutor");
+var NotExecutor = _NotExecutor;
+NotExecutor = _ts_decorate11([
+  RegisterNode(NotTemplate)
+], NotExecutor);
+var XorTemplate = {
+  type: "Xor",
+  title: "XOR",
+  category: "logic",
+  color: "#9C27B0",
+  description: "Returns true if exactly one of A or B is true (\u5982\u679C A \u548C B \u4E2D\u6070\u597D\u6709\u4E00\u4E2A\u4E3A true \u5219\u8FD4\u56DE true)",
+  keywords: [
+    "xor",
+    "exclusive",
+    "or",
+    "logic"
+  ],
+  isPure: true,
+  inputs: [
+    {
+      name: "a",
+      type: "bool",
+      displayName: "A",
+      defaultValue: false
+    },
+    {
+      name: "b",
+      type: "bool",
+      displayName: "B",
+      defaultValue: false
+    }
+  ],
+  outputs: [
+    {
+      name: "result",
+      type: "bool",
+      displayName: "Result"
+    }
+  ]
+};
+var _XorExecutor = class _XorExecutor {
+  execute(node, context) {
+    const a = Boolean(context.evaluateInput(node.id, "a", false));
+    const b = Boolean(context.evaluateInput(node.id, "b", false));
+    return {
+      outputs: {
+        result: (a || b) && !(a && b)
+      }
+    };
+  }
+};
+__name(_XorExecutor, "XorExecutor");
+var XorExecutor = _XorExecutor;
+XorExecutor = _ts_decorate11([
+  RegisterNode(XorTemplate)
+], XorExecutor);
+var NandTemplate = {
+  type: "Nand",
+  title: "NAND",
+  category: "logic",
+  color: "#9C27B0",
+  description: "Returns true if not both A and B are true (\u5982\u679C A \u548C B \u4E0D\u90FD\u4E3A true \u5219\u8FD4\u56DE true)",
+  keywords: [
+    "nand",
+    "not",
+    "and",
+    "logic"
+  ],
+  isPure: true,
+  inputs: [
+    {
+      name: "a",
+      type: "bool",
+      displayName: "A",
+      defaultValue: false
+    },
+    {
+      name: "b",
+      type: "bool",
+      displayName: "B",
+      defaultValue: false
+    }
+  ],
+  outputs: [
+    {
+      name: "result",
+      type: "bool",
+      displayName: "Result"
+    }
+  ]
+};
+var _NandExecutor = class _NandExecutor {
+  execute(node, context) {
+    const a = Boolean(context.evaluateInput(node.id, "a", false));
+    const b = Boolean(context.evaluateInput(node.id, "b", false));
+    return {
+      outputs: {
+        result: !(a && b)
+      }
+    };
+  }
+};
+__name(_NandExecutor, "NandExecutor");
+var NandExecutor = _NandExecutor;
+NandExecutor = _ts_decorate11([
+  RegisterNode(NandTemplate)
+], NandExecutor);
+var InRangeTemplate = {
+  type: "InRange",
+  title: "In Range",
+  category: "logic",
+  color: "#9C27B0",
+  description: "Returns true if value is between min and max (\u5982\u679C\u503C\u5728 min \u548C max \u4E4B\u95F4\u5219\u8FD4\u56DE true)",
+  keywords: [
+    "range",
+    "between",
+    "check",
+    "logic"
+  ],
+  isPure: true,
+  inputs: [
+    {
+      name: "value",
+      type: "float",
+      displayName: "Value",
+      defaultValue: 0
+    },
+    {
+      name: "min",
+      type: "float",
+      displayName: "Min",
+      defaultValue: 0
+    },
+    {
+      name: "max",
+      type: "float",
+      displayName: "Max",
+      defaultValue: 1
+    },
+    {
+      name: "inclusive",
+      type: "bool",
+      displayName: "Inclusive",
+      defaultValue: true
+    }
+  ],
+  outputs: [
+    {
+      name: "result",
+      type: "bool",
+      displayName: "Result"
+    }
+  ]
+};
+var _InRangeExecutor = class _InRangeExecutor {
+  execute(node, context) {
+    const value = Number(context.evaluateInput(node.id, "value", 0));
+    const min = Number(context.evaluateInput(node.id, "min", 0));
+    const max = Number(context.evaluateInput(node.id, "max", 1));
+    const inclusive = Boolean(context.evaluateInput(node.id, "inclusive", true));
+    const result = inclusive ? value >= min && value <= max : value > min && value < max;
+    return {
+      outputs: {
+        result
+      }
+    };
+  }
+};
+__name(_InRangeExecutor, "InRangeExecutor");
+var InRangeExecutor = _InRangeExecutor;
+InRangeExecutor = _ts_decorate11([
+  RegisterNode(InRangeTemplate)
+], InRangeExecutor);
+var IsNullTemplate = {
+  type: "IsNull",
+  title: "Is Null",
+  category: "logic",
+  color: "#9C27B0",
+  description: "Returns true if the value is null or undefined (\u5982\u679C\u503C\u4E3A null \u6216 undefined \u5219\u8FD4\u56DE true)",
+  keywords: [
+    "null",
+    "undefined",
+    "empty",
+    "check",
+    "logic"
+  ],
+  isPure: true,
+  inputs: [
+    {
+      name: "value",
+      type: "any",
+      displayName: "Value"
+    }
+  ],
+  outputs: [
+    {
+      name: "result",
+      type: "bool",
+      displayName: "Is Null"
+    }
+  ]
+};
+var _IsNullExecutor = class _IsNullExecutor {
+  execute(node, context) {
+    const value = context.evaluateInput(node.id, "value", null);
+    return {
+      outputs: {
+        result: value == null
+      }
+    };
+  }
+};
+__name(_IsNullExecutor, "IsNullExecutor");
+var IsNullExecutor = _IsNullExecutor;
+IsNullExecutor = _ts_decorate11([
+  RegisterNode(IsNullTemplate)
+], IsNullExecutor);
+var SelectTemplate = {
+  type: "Select",
+  title: "Select",
+  category: "logic",
+  color: "#9C27B0",
+  description: "Returns A if condition is true, otherwise returns B (\u5982\u679C\u6761\u4EF6\u4E3A true \u8FD4\u56DE A\uFF0C\u5426\u5219\u8FD4\u56DE B)",
+  keywords: [
+    "select",
+    "choose",
+    "ternary",
+    "?:",
+    "logic"
+  ],
+  isPure: true,
+  inputs: [
+    {
+      name: "condition",
+      type: "bool",
+      displayName: "Condition",
+      defaultValue: false
+    },
+    {
+      name: "a",
+      type: "any",
+      displayName: "A (True)"
+    },
+    {
+      name: "b",
+      type: "any",
+      displayName: "B (False)"
+    }
+  ],
+  outputs: [
+    {
+      name: "result",
+      type: "any",
+      displayName: "Result"
+    }
+  ]
+};
+var _SelectExecutor = class _SelectExecutor {
+  execute(node, context) {
+    const condition2 = Boolean(context.evaluateInput(node.id, "condition", false));
+    const a = context.evaluateInput(node.id, "a", null);
+    const b = context.evaluateInput(node.id, "b", null);
+    return {
+      outputs: {
+        result: condition2 ? a : b
+      }
+    };
+  }
+};
+__name(_SelectExecutor, "SelectExecutor");
+var SelectExecutor = _SelectExecutor;
+SelectExecutor = _ts_decorate11([
+  RegisterNode(SelectTemplate)
+], SelectExecutor);
 
 // src/nodes/time/GetDeltaTime.ts
-function _ts_decorate11(decorators, target, key, desc) {
+function _ts_decorate12(decorators, target, key, desc) {
   var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
   if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
   else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
   return c > 3 && r && Object.defineProperty(target, key, r), r;
 }
-__name(_ts_decorate11, "_ts_decorate");
+__name(_ts_decorate12, "_ts_decorate");
 var GetDeltaTimeTemplate = {
   type: "GetDeltaTime",
   title: "Get Delta Time",
@@ -5449,18 +6925,18 @@ var _GetDeltaTimeExecutor = class _GetDeltaTimeExecutor {
 };
 __name(_GetDeltaTimeExecutor, "GetDeltaTimeExecutor");
 var GetDeltaTimeExecutor = _GetDeltaTimeExecutor;
-GetDeltaTimeExecutor = _ts_decorate11([
+GetDeltaTimeExecutor = _ts_decorate12([
   RegisterNode(GetDeltaTimeTemplate)
 ], GetDeltaTimeExecutor);
 
 // src/nodes/time/GetTime.ts
-function _ts_decorate12(decorators, target, key, desc) {
+function _ts_decorate13(decorators, target, key, desc) {
   var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
   if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
   else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
   return c > 3 && r && Object.defineProperty(target, key, r), r;
 }
-__name(_ts_decorate12, "_ts_decorate");
+__name(_ts_decorate13, "_ts_decorate");
 var GetTimeTemplate = {
   type: "GetTime",
   title: "Get Game Time",
@@ -5494,18 +6970,18 @@ var _GetTimeExecutor = class _GetTimeExecutor {
 };
 __name(_GetTimeExecutor, "GetTimeExecutor");
 var GetTimeExecutor = _GetTimeExecutor;
-GetTimeExecutor = _ts_decorate12([
+GetTimeExecutor = _ts_decorate13([
   RegisterNode(GetTimeTemplate)
 ], GetTimeExecutor);
 
 // src/nodes/time/Delay.ts
-function _ts_decorate13(decorators, target, key, desc) {
+function _ts_decorate14(decorators, target, key, desc) {
   var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
   if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
   else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
   return c > 3 && r && Object.defineProperty(target, key, r), r;
 }
-__name(_ts_decorate13, "_ts_decorate");
+__name(_ts_decorate14, "_ts_decorate");
 var DelayTemplate = {
   type: "Delay",
   title: "Delay",
@@ -5551,18 +7027,18 @@ var _DelayExecutor = class _DelayExecutor {
 };
 __name(_DelayExecutor, "DelayExecutor");
 var DelayExecutor = _DelayExecutor;
-DelayExecutor = _ts_decorate13([
+DelayExecutor = _ts_decorate14([
   RegisterNode(DelayTemplate)
 ], DelayExecutor);
 
 // src/nodes/debug/Print.ts
-function _ts_decorate14(decorators, target, key, desc) {
+function _ts_decorate15(decorators, target, key, desc) {
   var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
   if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
   else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
   return c > 3 && r && Object.defineProperty(target, key, r), r;
 }
-__name(_ts_decorate14, "_ts_decorate");
+__name(_ts_decorate15, "_ts_decorate");
 var PrintTemplate = {
   type: "Print",
   title: "Print String",
@@ -5635,7 +7111,7 @@ var _PrintExecutor = class _PrintExecutor {
 };
 __name(_PrintExecutor, "PrintExecutor");
 var PrintExecutor = _PrintExecutor;
-PrintExecutor = _ts_decorate14([
+PrintExecutor = _ts_decorate15([
   RegisterNode(PrintTemplate)
 ], PrintExecutor);