@rkmodules/rules 0.0.93 → 0.0.95

package/dist/index.esm.css

@@ -195,7 +195,6 @@
 .Ports_fVs5I {
     display: grid;
     grid-template-columns: auto 1fr;
-    grid-auto-rows: 26px;
 }
 
 .Body_ptEZP {

package/dist/index.esm.js

@@ -140,18 +140,19 @@ var DISCARD = Symbol("DISCARD");
  */
 function simplifyTree$1(tree) {
     var keys = Object.keys(tree);
-    if (keys.length <= 1)
-        return tree; // ✅ Don't simplify if only one path
     // Parse all paths into number arrays
     var parsedPaths = keys.map(function (path) { return path.split(";").map(Number); });
     // Find common prefix
-    var prefixLength = parsedPaths[0].length;
-    for (var i = 1; i < parsedPaths.length; i++) {
-        var path = parsedPaths[i];
-        for (var j = 0; j < prefixLength; j++) {
-            if (path[j] !== parsedPaths[0][j]) {
-                prefixLength = j;
-                break;
+    var prefixLength = 1;
+    if (keys.length > 1) {
+        prefixLength = parsedPaths[0].length;
+        for (var i = 1; i < parsedPaths.length; i++) {
+            var path = parsedPaths[i];
+            for (var j = 0; j < prefixLength; j++) {
+                if (path[j] !== parsedPaths[0][j]) {
+                    prefixLength = j;
+                    break;
+                }
             }
         }
     }
@@ -271,10 +272,10 @@ function mapTree(tree, fn) {
     });
 }
 function mapTreeBranch(tree, fn) {
-    return nAryOnTreeBranch([tree], function mapTreeBranchCallback(_a, _b) {
+    return nAryOnTreeBranch([tree], function mapTreeBranchCallback(_a, _b, index) {
         var _c = __read(_a, 1), branch = _c[0];
         var _d = __read(_b, 1), path = _d[0];
-        return fn(branch || [], path);
+        return fn(branch || [], path, index);
     });
 }
 /**
@@ -298,7 +299,7 @@ function nAryOnTreeBranch(trees, fn) {
         // get all the paths of which the trees are the longest, use the first
         var maxPaths = paths.filter(function (_, i) { return allKeys[i].length === maxBranches; });
         var path = maxPaths[0];
-        var newBranch = fn(branches, paths);
+        var newBranch = fn(branches, paths, i);
         if (newBranch !== DISCARD) {
             result[path] = newBranch;
         }
@@ -364,10 +365,10 @@ function nAryOnTree(trees, fn, fill) {
  * @returns
  */
 function binaryOnTreeBranch(treeA, treeB, fn) {
-    return nAryOnTreeBranch([treeA, treeB], function binaryOnTreeBranchCallback(_a, _b) {
+    return nAryOnTreeBranch([treeA, treeB], function binaryOnTreeBranchCallback(_a, _b, index) {
         var _c = __read(_a, 2), branchA = _c[0], branchB = _c[1];
         var _d = __read(_b, 2), pathA = _d[0], pathB = _d[1];
-        return fn(branchA || [], branchB || [], pathA, pathB);
+        return fn(branchA || [], branchB || [], pathA, pathB, index);
     });
 }
 /**
@@ -633,17 +634,17 @@ var value = {
     }); },
 };
 
-var _a$7;
-var primitives$7 = (_a$7 = {},
-    _a$7[getValue.name] = getValue,
-    _a$7[log.name] = log,
-    _a$7[value.name] = value,
-    _a$7);
+var _a$8;
+var primitives$8 = (_a$8 = {},
+    _a$8[getValue.name] = getValue,
+    _a$8[log.name] = log,
+    _a$8[value.name] = value,
+    _a$8);
 
 var add$1 = {
     name: "add",
     label: "Add",
-    description: "Add two numbers",
+    description: "Add two numbers or strings",
     inputs: {
         a: { type: "number", default: 0 },
         b: { type: "number", default: 0 },
@@ -1136,16 +1137,21 @@ var ceil = {
     inputs: {
         x: { type: "number", default: 0 },
     },
+    params: {
+        decimals: { type: "number", default: 0 },
+    },
     outputs: {
         ceil: "number",
     },
-    impl: function (inputs) { return __awaiter(void 0, void 0, void 0, function () {
+    impl: function (inputs, params) { return __awaiter(void 0, void 0, void 0, function () {
+        var f;
         return __generator(this, function (_a) {
+            f = Math.pow(10, params.decimals || 0);
             return [2 /*return*/, {
                     ceil: mapTree(inputs.x, function (x) {
                         if (x === undefined)
                             return DISCARD;
-                        return Math.ceil(x);
+                        return Math.ceil(f * x) / f;
                     }),
                 }];
         });
@@ -1159,16 +1165,21 @@ var floor = {
     inputs: {
         x: { type: "number", default: 0 },
     },
+    params: {
+        decimals: { type: "number", default: 0 },
+    },
     outputs: {
         floor: "number",
     },
-    impl: function (inputs) { return __awaiter(void 0, void 0, void 0, function () {
+    impl: function (inputs, params) { return __awaiter(void 0, void 0, void 0, function () {
+        var f;
         return __generator(this, function (_a) {
+            f = Math.pow(10, params.decimals || 0);
             return [2 /*return*/, {
                     floor: mapTree(inputs.x, function (x) {
                         if (x === undefined)
                             return DISCARD;
-                        return Math.floor(x);
+                        return Math.floor(f * x) / f;
                     }),
                 }];
         });
@@ -1182,16 +1193,122 @@ var round = {
     inputs: {
         x: { type: "number", default: 0 },
     },
+    params: {
+        decimals: { type: "number", default: 0 },
+    },
     outputs: {
         round: "number",
     },
-    impl: function (inputs) { return __awaiter(void 0, void 0, void 0, function () {
+    impl: function (inputs, params) { return __awaiter(void 0, void 0, void 0, function () {
+        var f;
         return __generator(this, function (_a) {
+            f = Math.pow(10, params.decimals || 0);
             return [2 /*return*/, {
                     round: mapTree(inputs.x, function (x) {
                         if (x === undefined)
                             return DISCARD;
-                        return Math.round(x);
+                        return Math.round(f * x) / f;
+                    }),
+                }];
+        });
+    }); },
+};
+
+var sum = {
+    name: "sum",
+    label: "Sum",
+    description: "Sum of all items in a group",
+    inputs: {
+        tree: { type: "number", default: 0 },
+    },
+    outputs: {
+        sum: "number",
+    },
+    impl: function (inputs) { return __awaiter(void 0, void 0, void 0, function () {
+        return __generator(this, function (_a) {
+            return [2 /*return*/, {
+                    sum: mapTreeBranch(inputs.tree, function (branch) {
+                        if (!branch || branch.length === 0)
+                            return DISCARD;
+                        var total = branch.reduce(function (acc, item) {
+                            if (item === undefined)
+                                return acc;
+                            return acc + item;
+                        });
+                        return [total];
+                    }),
+                }];
+        });
+    }); },
+};
+
+var _a$7;
+var primitives$7 = (_a$7 = {},
+    _a$7[calc.name] = calc,
+    _a$7[equalTo.name] = equalTo,
+    _a$7[lessThan.name] = lessThan,
+    _a$7[greaterThan.name] = greaterThan,
+    _a$7[add$1.name] = add$1,
+    _a$7[subtract$1.name] = subtract$1,
+    _a$7[multiply.name] = multiply,
+    _a$7[divide.name] = divide,
+    _a$7[modulo.name] = modulo,
+    _a$7[sinDeg.name] = sinDeg,
+    _a$7[cosDeg.name] = cosDeg,
+    _a$7[tanDeg.name] = tanDeg,
+    _a$7[sqrt.name] = sqrt,
+    _a$7[pow.name] = pow,
+    _a$7[round.name] = round,
+    _a$7[ceil.name] = ceil,
+    _a$7[floor.name] = floor,
+    _a$7[sum.name] = sum,
+    _a$7);
+
+var joinStrings = {
+    name: "joinStrings",
+    label: "Join Strings",
+    description: "Join all strings in a group",
+    inputs: {
+        tree: { type: "string", default: "" },
+    },
+    params: {
+        separator: { type: "string", default: "" },
+    },
+    outputs: {
+        joined: "string",
+    },
+    impl: function (inputs, params) { return __awaiter(void 0, void 0, void 0, function () {
+        var sep;
+        return __generator(this, function (_a) {
+            sep = params.separator || "";
+            return [2 /*return*/, {
+                    joined: mapTreeBranch(inputs.tree, function (branch) {
+                        if (!branch || branch.length === 0)
+                            return DISCARD;
+                        return [branch.join(sep)];
+                    }),
+                }];
+        });
+    }); },
+};
+
+var toString = {
+    name: "toString",
+    label: "To String",
+    description: "convert to string",
+    inputs: {
+        tree: { type: "any", default: 0 },
+    },
+    outputs: {
+        string: "string",
+    },
+    impl: function (inputs) { return __awaiter(void 0, void 0, void 0, function () {
+        return __generator(this, function (_a) {
+            return [2 /*return*/, {
+                    string: mapTree(inputs.tree || {}, function (item) {
+                        if (item === undefined)
+                            return DISCARD;
+                        return String(item);
                     }),
                 }];
         });
@@ -1200,23 +1317,8 @@ var round = {
 
 var _a$6;
 var primitives$6 = (_a$6 = {},
-    _a$6[calc.name] = calc,
-    _a$6[equalTo.name] = equalTo,
-    _a$6[lessThan.name] = lessThan,
-    _a$6[greaterThan.name] = greaterThan,
-    _a$6[add$1.name] = add$1,
-    _a$6[subtract$1.name] = subtract$1,
-    _a$6[multiply.name] = multiply,
-    _a$6[divide.name] = divide,
-    _a$6[modulo.name] = modulo,
-    _a$6[sinDeg.name] = sinDeg,
-    _a$6[cosDeg.name] = cosDeg,
-    _a$6[tanDeg.name] = tanDeg,
-    _a$6[sqrt.name] = sqrt,
-    _a$6[pow.name] = pow,
-    _a$6[round.name] = round,
-    _a$6[ceil.name] = ceil,
-    _a$6[floor.name] = floor,
+    _a$6[toString.name] = toString,
+    _a$6[joinStrings.name] = joinStrings,
     _a$6);
 
 var filterList = {
@@ -1262,25 +1364,6 @@ var filterList = {
     }); },
 };
 
-var splitGroup = {
-    name: "splitGroup",
-    label: "Split Group",
-    description: "Splits every item of a group into its own group",
-    inputs: {
-        tree: "any",
-    },
-    outputs: {
-        tree: "any", // Return the grafted nodes
-    },
-    impl: function (inputs) { return __awaiter(void 0, void 0, void 0, function () {
-        return __generator(this, function (_a) {
-            return [2 /*return*/, {
-                    tree: graftTree(inputs.tree || {}),
-                }];
-        });
-    }); },
-};
-
 var listItem = {
     name: "listItem",
     label: "List Item",
@@ -1350,73 +1433,9 @@ var listLength = {
     }); },
 };
 
-var mergeGroup = {
-    name: "mergeGroup",
-    label: "Merge Group",
-    description: "Merge the deepest groups into their parent.",
-    inputs: {
-        tree: "any",
-    },
-    params: {
-        depth: { type: "number", default: 1 }, // Optional depth to trim the tree
-    },
-    outputs: {
-        tree: "any", // Return the trimed nodes
-    },
-    impl: function (inputs, params) { return __awaiter(void 0, void 0, void 0, function () {
-        var depth;
-        var _a;
-        return __generator(this, function (_b) {
-            depth = (_a = params.depth) !== null && _a !== void 0 ? _a : 1;
-            return [2 /*return*/, {
-                    tree: trimTree(inputs.tree, depth),
-                }];
-        });
-    }); },
-};
-
-var cartesianGroups = {
-    name: "cartesianGroups",
-    label: "Cartesian Groups",
-    description: "Duplicate groups such that all pairings are created.",
-    inputs: {
-        treeA: "any",
-        treeB: "any",
-    },
-    params: {},
-    outputs: {
-        treeA: "any",
-        treeB: "any",
-    },
-    impl: function (inputs, params) { return __awaiter(void 0, void 0, void 0, function () {
-        var pathsA, pathsB, treeA, treeB;
-        return __generator(this, function (_a) {
-            if (!inputs.treeA || !inputs.treeB) {
-                return [2 /*return*/, {}];
-            }
-            pathsA = getPaths(inputs.treeA);
-            pathsB = getPaths(inputs.treeB);
-            treeA = {};
-            treeB = {};
-            pathsB.forEach(function (pathB, ib) {
-                pathsA.forEach(function (pathA, ia) {
-                    var pa = "".concat(ib, ";").concat(pathA);
-                    treeA[pa] = inputs.treeA[pathA];
-                    var pb = "".concat(pathB, ";").concat(ia);
-                    treeB[pb] = inputs.treeB[pathB];
-                });
-            });
-            return [2 /*return*/, {
-                    treeA: treeA,
-                    treeB: treeB,
-                }];
-        });
-    }); },
-};
-
 var concat = {
     name: "concat",
-    label: "Concat",
+    label: "Concat Lists",
     description: "Concatenates two lists back to back",
     inputs: {
         treeA: "any",
@@ -1517,59 +1536,135 @@ var relativeItems = {
     }); },
 };
 
+function isBoolStr(str) {
+    return str.toLowerCase() === "true" || str.toLowerCase() === "false";
+}
+function isNumStr(str) {
+    return !isNaN(Number(str));
+}
+var listInput = {
+    name: "listInput",
+    label: "List Input",
+    description: "Input a list",
+    inputs: {
+        list: { type: "text", default: "" },
+    },
+    outputs: {
+        tree: "string",
+    },
+    impl: function (inputs) { return __awaiter(void 0, void 0, void 0, function () {
+        return __generator(this, function (_a) {
+            return [2 /*return*/, {
+                    tree: mapTreeBranch(inputs.list || {}, function (branch) {
+                        if (!branch || branch.length === 0)
+                            return DISCARD;
+                        var allLines = branch.flatMap(function (text) { return text.split("\n"); });
+                        if (allLines.every(function (line) { return isBoolStr(line); })) {
+                            allLines = allLines.map(function (line) { return line.toLowerCase() === "true"; });
+                        }
+                        else if (allLines.every(function (line) { return isNumStr(line); })) {
+                            allLines = allLines.map(function (line) { return Number(line); });
+                        }
+                        return allLines;
+                    }),
+                }];
+        });
+    }); },
+};
+
 var _a$5;
 var primitives$5 = (_a$5 = {},
-    _a$5[splitGroup.name] = splitGroup,
-    _a$5[mergeGroup.name] = mergeGroup,
     _a$5[listItem.name] = listItem,
     _a$5[listLength.name] = listLength,
     _a$5[filterList.name] = filterList,
-    // [shiftList.name]: shiftList,
     _a$5[relativeItem.name] = relativeItem,
     _a$5[relativeItems.name] = relativeItems,
-    _a$5[cartesianGroups.name] = cartesianGroups,
     _a$5[concat.name] = concat,
+    _a$5[listInput.name] = listInput,
     _a$5);
 
-var series = {
-    name: "series",
-    label: "Series",
-    description: "Create a series of numbers.",
+var splitGroup = {
+    name: "splitGroup",
+    label: "Split Group",
+    description: "Splits every item of a group into its own group",
     inputs: {
-        start: { type: "number", default: 0 },
-        step: { type: "number", default: 1 },
-        count: { type: "number", default: 10 },
+        tree: "any",
     },
     outputs: {
-        series: "number",
+        tree: "any", // Return the grafted nodes
     },
     impl: function (inputs) { return __awaiter(void 0, void 0, void 0, function () {
         return __generator(this, function (_a) {
             return [2 /*return*/, {
-                    series: nAryOnTreeBranch([
-                        graftTree(inputs.start),
-                        graftTree(inputs.step),
-                        graftTree(inputs.count),
-                    ], function (_a) {
-                        var _b = __read(_a, 3), _c = _b[0], starts = _c === void 0 ? [] : _c, _d = _b[1], steps = _d === void 0 ? [] : _d, _e = _b[2], counts = _e === void 0 ? [] : _e;
-                        var start = starts[0];
-                        var step = steps[0];
-                        var count = counts[0];
-                        var series = [];
-                        for (var i = 0; i < count; i++) {
-                            series.push(start + i * step);
-                        }
-                        return series;
-                    }),
+                    tree: graftTree(inputs.tree || {}),
                 }];
         });
     }); },
 };
 
-var _a$4;
-var primitives$4 = (_a$4 = {},
-    _a$4[series.name] = series,
-    _a$4);
+var mergeGroup = {
+    name: "mergeGroup",
+    label: "Merge Group",
+    description: "Merge the deepest groups into their parent.",
+    inputs: {
+        tree: "any",
+    },
+    params: {
+        depth: { type: "number", default: 1 }, // Optional depth to trim the tree
+    },
+    outputs: {
+        tree: "any", // Return the trimed nodes
+    },
+    impl: function (inputs, params) { return __awaiter(void 0, void 0, void 0, function () {
+        var depth;
+        var _a;
+        return __generator(this, function (_b) {
+            depth = (_a = params.depth) !== null && _a !== void 0 ? _a : 1;
+            return [2 /*return*/, {
+                    tree: trimTree(inputs.tree, depth),
+                }];
+        });
+    }); },
+};
+
+var cartesianGroups = {
+    name: "cartesianGroups",
+    label: "Cartesian Groups",
+    description: "Duplicate groups such that all pairings are created.",
+    inputs: {
+        treeA: "any",
+        treeB: "any",
+    },
+    params: {},
+    outputs: {
+        treeA: "any",
+        treeB: "any",
+    },
+    impl: function (inputs, params) { return __awaiter(void 0, void 0, void 0, function () {
+        var pathsA, pathsB, treeA, treeB;
+        return __generator(this, function (_a) {
+            if (!inputs.treeA || !inputs.treeB) {
+                return [2 /*return*/, {}];
+            }
+            pathsA = getPaths(inputs.treeA);
+            pathsB = getPaths(inputs.treeB);
+            treeA = {};
+            treeB = {};
+            pathsB.forEach(function (pathB, ib) {
+                pathsA.forEach(function (pathA, ia) {
+                    var pa = "".concat(ib, ";").concat(pathA);
+                    treeA[pa] = inputs.treeA[pathA];
+                    var pb = "".concat(pathB, ";").concat(ia);
+                    treeB[pb] = inputs.treeB[pathB];
+                });
+            });
+            return [2 /*return*/, {
+                    treeA: treeA,
+                    treeB: treeB,
+                }];
+        });
+    }); },
+};
 
 var mergeTree = {
     name: "mergeTree",
@@ -1602,7 +1697,7 @@ var mergeTree = {
 
 var simplifyTree = {
     name: "simplifyTree",
-    label: "Simplify Tree",
+    label: "Simplify Groups",
     description: "Simplify a tree by removing redundant groups.",
     inputs: {
         tree: "any",
@@ -1622,10 +1717,78 @@ var simplifyTree = {
     }); },
 };
 
+var groupAll = {
+    name: "groupAll",
+    label: "Group All",
+    description: "Adds a group around all groups in the input tree",
+    inputs: {
+        tree: "any",
+    },
+    outputs: {
+        tree: "any",
+    },
+    impl: function (_a) { return __awaiter(void 0, [_a], void 0, function (_b) {
+        var paths, newPaths, newTree;
+        var _c = _b.tree, tree = _c === void 0 ? {} : _c;
+        return __generator(this, function (_d) {
+            paths = getPaths(tree);
+            newPaths = paths.map(function (p) { return "0;".concat(p); });
+            newTree = Object.fromEntries(newPaths.map(function (p, i) { return [p, tree[paths[i]]]; }));
+            return [2 /*return*/, {
+                    tree: newTree,
+                }];
+        });
+    }); },
+};
+
+var _a$4;
+var primitives$4 = (_a$4 = {},
+    _a$4[splitGroup.name] = splitGroup,
+    _a$4[mergeGroup.name] = mergeGroup,
+    _a$4[groupAll.name] = groupAll,
+    _a$4[simplifyTree.name] = simplifyTree,
+    _a$4[cartesianGroups.name] = cartesianGroups,
+    _a$4[mergeTree.name] = mergeTree,
+    _a$4);
+
+var series = {
+    name: "series",
+    label: "Series",
+    description: "Create a series of numbers.",
+    inputs: {
+        start: { type: "number", default: 0 },
+        step: { type: "number", default: 1 },
+        count: { type: "number", default: 10 },
+    },
+    outputs: {
+        series: "number",
+    },
+    impl: function (inputs) { return __awaiter(void 0, void 0, void 0, function () {
+        return __generator(this, function (_a) {
+            return [2 /*return*/, {
+                    series: nAryOnTreeBranch([
+                        graftTree(inputs.start),
+                        graftTree(inputs.step),
+                        graftTree(inputs.count),
+                    ], function (_a) {
+                        var _b = __read(_a, 3), _c = _b[0], starts = _c === void 0 ? [] : _c, _d = _b[1], steps = _d === void 0 ? [] : _d, _e = _b[2], counts = _e === void 0 ? [] : _e;
+                        var start = starts[0];
+                        var step = steps[0];
+                        var count = counts[0];
+                        var series = [];
+                        for (var i = 0; i < count; i++) {
+                            series.push(start + i * step);
+                        }
+                        return series;
+                    }),
+                }];
+        });
+    }); },
+};
+
 var _a$3;
 var primitives$3 = (_a$3 = {},
-    _a$3[mergeTree.name] = mergeTree,
-    _a$3[simplifyTree.name] = simplifyTree,
+    _a$3[series.name] = series,
     _a$3);
 
 var groupAnd = {
@@ -1710,8 +1873,8 @@ var primitives$1 = (_a$1 = {},
     _a$1[output.name] = output,
     _a$1);
 
-var Lib = { Util: primitives$7, Math: primitives$6, List: primitives$5, Sequence: primitives$4, Tree: primitives$3, Logic: primitives$2, IO: primitives$1 };
-var primitives = __assign(__assign(__assign(__assign(__assign(__assign(__assign({}, primitives$1), primitives$7), primitives$6), primitives$5), primitives$4), primitives$3), primitives$2);
+var Lib = { Util: primitives$8, Math: primitives$7, String: primitives$6, List: primitives$5, Group: primitives$4, Sequence: primitives$3, Logic: primitives$2, IO: primitives$1 };
+var primitives = __assign(__assign(__assign(__assign(__assign(__assign(__assign(__assign({}, primitives$1), primitives$8), primitives$7), primitives$6), primitives$5), primitives$4), primitives$3), primitives$2);
 
 function isPrimitive(node) {
     return node.impl !== undefined;
@@ -4994,7 +5157,25 @@ var InputString = React.memo(function (_a) {
             setInner(value);
         }
     }, [inner, value, onChange]);
-    return (React.createElement("input", { type: "text", value: inner, onChange: function (e) { return setInner(e.target.value); }, onBlur: handleBlur, onKeyDown: handleKey }));
+    return (React.createElement("input", { type: "text", value: inner, onChange: function (e) { return setInner(e.target.value); }, onBlur: handleBlur, onKeyDown: handleKey, onMouseDown: function (e) { return e.stopPropagation(); } }));
+});
+var InputText = React.memo(function (_a) {
+    var value = _a.value, onChange = _a.onChange;
+    var _b = __read(useInner(value), 2), inner = _b[0], setInner = _b[1];
+    var handleBlur = React.useCallback(function () {
+        if (inner !== value) {
+            onChange === null || onChange === void 0 ? void 0 : onChange(inner);
+        }
+    }, [inner, value, onChange]);
+    var handleKey = React.useCallback(function (e) {
+        if (e.key === "Enter" && inner !== value) {
+            onChange === null || onChange === void 0 ? void 0 : onChange(inner);
+        }
+        if (e.key === "Escape") {
+            setInner(value);
+        }
+    }, [inner, value, onChange]);
+    return (React.createElement("textarea", { value: inner, onChange: function (e) { return setInner(e.target.value); }, onBlur: handleBlur, onKeyDown: handleKey, onMouseDown: function (e) { return e.stopPropagation(); }, rows: 4 }));
 });
 function Control(_a) {
     var value = _a.value, vardef = _a.vardef, onChange = _a.onChange;
@@ -5009,8 +5190,10 @@ function Control(_a) {
     switch (vardef.type) {
         case "string":
             return React.createElement(InputString, { value: value !== null && value !== void 0 ? value : "", onChange: onChange });
+        case "text":
+            return React.createElement(InputText, { value: value !== null && value !== void 0 ? value : "", onChange: onChange });
         case "number":
-            return (React.createElement(InputNumber, { value: Number(value) || 0, onChange: onChange, step: vardef.step, min: vardef.min, max: vardef.max, inputMode: "numeric" }));
+            return (React.createElement(InputNumber, { value: Number(value) || 0, onChange: onChange, step: vardef.step, min: vardef.min, max: vardef.max, inputMode: "numeric", onMouseDown: function (e) { return e.stopPropagation(); } }));
         case "boolean":
             return (React.createElement("input", { type: "checkbox", checked: Boolean(value), onChange: function (e) { return onChange === null || onChange === void 0 ? void 0 : onChange(e.target.checked); } }));
         default: