@bldgblocks/node-red-contrib-control 0.1.4

package/nodes/delay-block.html

@@ -0,0 +1,104 @@
+<!-- UI Template Section: Defines the edit dialog -->
+<script type="text/html" data-template-name="delay-block">
+    <div class="form-row">
+        <label for="node-input-name"><i class="fa fa-tag"></i> Name</label>
+        <input type="text" id="node-input-name" placeholder="Name">
+    </div>
+    <div class="form-row">
+        <label for="node-input-delayOn"><i class="fa fa-clock-o"></i> On Delay</label>
+        <input type="number" id="node-input-delayOn" placeholder="1000" min="0" step="1">
+        <select id="node-input-delayOnUnits">
+            <option value="milliseconds">Milliseconds</option>
+            <option value="seconds">Seconds</option>
+            <option value="minutes">Minutes</option>
+        </select>
+        <input type="hidden" id="node-input-delayOnType">
+
+    </div>
+    <div class="form-row">
+        <label for="node-input-delayOff"><i class="fa fa-clock-o"></i> Off Delay</label>
+        <input type="number" id="node-input-delayOff" placeholder="1000" min="0" step="1">
+        <select id="node-input-delayOffUnits">
+            <option value="milliseconds">Milliseconds</option>
+            <option value="seconds">Seconds</option>
+            <option value="minutes">Minutes</option>
+        </select>
+        <input type="hidden" id="node-input-delayOffType">
+
+    </div>
+</script>
+
+<!-- JavaScript Section: Registers the node and handles editor logic -->
+<script type="text/javascript">
+    RED.nodes.registerType("delay-block", {
+        category: "control",
+        color: "#301934",
+        defaults: {
+            name: { value: "" },
+            delayOn: { value: 1000, required: true, validate: function(v) { return !isNaN(parseFloat(v)) && parseFloat(v) >= 0; } },
+            delayOnUnits: { value: "milliseconds" },
+            delayOnType: { value: "num" },
+            delayOff: { value: 1000, required: true, validate: function(v) { return !isNaN(parseFloat(v)) && parseFloat(v) >= 0; } },
+            delayOffUnits: { value: "milliseconds" },
+            delayOffType: { value: "num" }
+        },
+        inputs: 1,
+        outputs: 1,
+        inputLabels: ["input"],
+        outputLabels: ["output"],
+        icon: "font-awesome/fa-clock-o",
+        paletteLabel: "delay",
+        label: function() {
+            return this.name || "delay";
+        },
+        oneditprepare: function() {
+            try {
+                // Initialize typed inputs
+                $("#node-input-delayOn").typedInput({
+                    default: "num",
+                    types: ["num", "msg", "flow", "global"],
+                    typeField: "#node-input-delayOnType"
+                }).typedInput("type", node.delayOnType || "num").typedInput("value", node.delayOn);
+
+                $("#node-input-delayOff").typedInput({
+                    default: "num",
+                    types: ["num", "msg", "flow", "global"],
+                    typeField: "#node-input-delayOffType"
+                }).typedInput("type", node.delayOffType || "num").typedInput("value", node.delayOff);
+
+            } catch (err) {
+                console.error("Error in hysteresis-block oneditprepare:", err);
+            }
+        }
+    });
+</script>
+
+<!-- Help Section: -->
+<script type="text/markdown" data-help-name="delay-block">
+Delays boolean state transitions with configurable on/off delays.
+
+### Inputs
+: context (string) : Configures node (`"reset"`, `"delayOn"`, `"delayOff"`). Unmatched values ignored silently.
+: payload (boolean | number) : Boolean for state change; number for delay config with `msg.context`.
+: *units* (string) : Units for delay context config (`"milliseconds"`, `"seconds"`, `"minutes"`).
+
+### Outputs
+: payload (boolean) : `true` after `delayOn` ms or `false` after `delayOff` ms if state persists. `msg.context` is consumed.
+: *other* (any) : Other input properties preserved, except `msg.context`.
+
+### Details
+Delays `msg.payload` boolean transitions, outputting `true` after `delayOn` ms for false-to-true or `false` after `delayOff` ms for true-to-false, 
+if the input state persists. Forwards the input message with updated `msg.payload`, removing `msg.context`. 
+Non-transition inputs (e.g., `true` when `state=true`) or state reversions cancel pending delays without output. 
+
+### Status
+- Green (dot): Configuration
+- Blue (dot): Output, no alarm
+- Red (dot): Output with alarm
+- Red (ring): Errors
+- Yellow (ring): Unknown context
+
+### References
+- [Node-RED Documentation](https://nodered.org/docs/)
+- [GitHub Repository](https://github.com/BldgBlocks/node-red-contrib-buildingblocks-control.git)
+</script>

package/nodes/delay-block.js

@@ -0,0 +1,180 @@
+module.exports = function(RED) {
+    function DelayBlockNode(config) {
+        RED.nodes.createNode(this, config);
+        const node = this;
+
+        node.runtime = {
+            name: config.name || "",
+            state: false
+        };
+
+        if (isNaN(node.runtime.delayOn) || node.runtime.delayOn < 0) {
+            node.runtime.delayOn = 1000;
+            node.status({ fill: "red", shape: "ring", text: "invalid delayOn" });
+        }
+        if (isNaN(node.runtime.delayOff) || node.runtime.delayOff < 0) {
+            node.runtime.delayOff = 1000;
+            node.status({ fill: "red", shape: "ring", text: "invalid delayOff" });
+        }
+
+        // Set initial status
+        node.status({ 
+            fill: "green", 
+            shape: "dot", 
+            text: `On: ${node.runtime.delayOn}ms, Off: ${node.runtime.delayOff}ms` 
+        });
+
+        let timeoutId = null;
+
+        node.on("input", function(msg, send, done) {
+            send = send || function() { node.send.apply(node, arguments); };
+            if (!msg) {
+                if (done) done();
+                return;
+            }
+
+            // Evaluate typed-inputs
+            try {
+                node.runtime.delayOn = RED.util.evaluateNodeProperty(
+                    config.delayOn, config.delayOnType, node, msg
+                );
+                node.runtime.delayOn = (parseFloat(node.runtime.delayOn)) * (config.delayOnUnits === "seconds" ? 1000 : config.delayOnUnits === "minutes" ? 60000 : 1);
+
+                node.runtime.delayOff = RED.util.evaluateNodeProperty(
+                    config.delayOff, config.delayOffType, node, msg
+                );
+                node.runtime.delayOff = (parseFloat(node.runtime.delayOff)) * (config.delayOffUnits === "seconds" ? 1000 : config.delayOffUnits === "minutes" ? 60000 : 1);
+
+                node.period = parseFloat(node.period);
+                if (isNaN(node.period) || node.period <= 0 || !isFinite(node.period)) {
+                    node.period = 1000;
+                    node.status({ fill: "yellow", shape: "ring", text: "invalid period, using 1000ms" });
+                }
+            } catch(err) {
+                node.status({ fill: "red", shape: "ring", text: "error evaluating properties" });
+                if (done) done(err);
+                return;
+            }
+
+            if (msg.hasOwnProperty("context")) {
+                if (msg.context === "reset") {
+                    if (!msg.hasOwnProperty("payload") || typeof msg.payload !== "boolean") {
+                        node.status({ fill: "red", shape: "ring", text: "invalid reset" });
+                        if (done) done();
+                        return;
+                    }
+                    if (msg.payload === true) {
+                        if (timeoutId) {
+                            clearTimeout(timeoutId);
+                            timeoutId = null;
+                        }
+                        node.runtime.state = false;
+                        node.status({ fill: "green", shape: "dot", text: "reset" });
+                    }
+                    if (done) done();
+                    return;
+                } else if (msg.context === "delayOn") {
+                    if (!msg.hasOwnProperty("payload")) {
+                        node.status({ fill: "red", shape: "ring", text: "missing payload for delayOn" });
+                        if (done) done();
+                        return;
+                    }
+                    let newDelayOn = parseFloat(msg.payload);
+                    const newDelayOnMultiplier = msg.units === "seconds" ? 1000 : msg.units === "minutes" ? 60000 : 1;
+                    newDelayOn *= newDelayOnMultiplier;
+                    if (isNaN(newDelayOn) || newDelayOn < 0) {
+                        node.status({ fill: "red", shape: "ring", text: "invalid delayOn" });
+                        if (done) done();
+                        return;
+                    }
+                    node.runtime.delayOn = newDelayOn;
+                    node.status({ fill: "green", shape: "dot", text: `delayOn: ${newDelayOn.toFixed(0)} ms` });
+                    if (done) done();
+                    return;
+                } else if (msg.context === "delayOff") {
+                    if (!msg.hasOwnProperty("payload")) {
+                        node.status({ fill: "red", shape: "ring", text: "missing payload for delayOff" });
+                        if (done) done();
+                        return;
+                    }
+                    let newDelayOff = parseFloat(msg.payload);
+                    const newDelayOffMultiplier = msg.units === "seconds" ? 1000 : msg.units === "minutes" ? 60000 : 1;
+                    newDelayOff *= newDelayOffMultiplier;
+                    if (isNaN(newDelayOff) || newDelayOff < 0) {
+                        node.status({ fill: "red", shape: "ring", text: "invalid delayOff" });
+                        if (done) done();
+                        return;
+                    }
+                    node.runtime.delayOff = newDelayOff;
+                    node.status({ fill: "green", shape: "dot", text: `delayOff: ${newDelayOff.toFixed(0)} ms` });
+                    if (done) done();
+                    return;
+                }
+                node.status({ fill: "yellow", shape: "ring", text: "unknown context" });
+                if (done) done();
+                return;
+            }
+
+            if (!msg.hasOwnProperty("payload")) {
+                node.status({ fill: "red", shape: "ring", text: "missing payload" });
+                if (done) done();
+                return;
+            }
+
+            const inputValue = msg.payload;
+            if (typeof inputValue !== "boolean") {
+                node.status({ fill: "red", shape: "ring", text: "invalid payload" });
+                if (done) done();
+                return;
+            }
+
+            if (!node.runtime.state && inputValue === true) {
+                if (timeoutId) {
+                    clearTimeout(timeoutId);
+                }
+                node.status({ fill: "blue", shape: "ring", text: `awaiting true` });
+                timeoutId = setTimeout(() => {
+                    node.runtime.state = true;
+                    msg.payload = true;
+                    delete msg.context;
+                    node.status({ fill: "blue", shape: "dot", text: `in: true, out: true` });
+                    send(msg);
+                    timeoutId = null;
+                }, node.runtime.delayOn);
+            } else if (node.runtime.state && inputValue === false) {
+                if (timeoutId) {
+                    clearTimeout(timeoutId);
+                }
+                node.status({ fill: "blue", shape: "ring", text: `awaiting false` });
+                timeoutId = setTimeout(() => {
+                    node.runtime.state = false;
+                    msg.payload = false;
+                    delete msg.context;
+                    node.status({ fill: "blue", shape: "dot", text: `in: false, out: false` });
+                    send(msg);
+                    timeoutId = null;
+                }, node.runtime.delayOff);
+            } else {
+                if (timeoutId) {
+                    clearTimeout(timeoutId);
+                    timeoutId = null;
+                    node.status({ fill: "blue", shape: "ring", text: `canceled awaiting ${node.runtime.state}` });
+                } else {
+                    node.status({ fill: "blue", shape: "ring", text: `awaiting ${inputValue}` });
+                }
+            }
+
+            if (done) done();
+        });
+
+        node.on("close", function(done) {
+            if (timeoutId) {
+                clearTimeout(timeoutId);
+                timeoutId = null;
+            }
+            done();
+        });
+    }
+
+    RED.nodes.registerType("delay-block", DelayBlockNode);
+};

package/nodes/divide-block.html

@@ -0,0 +1,65 @@
+<script type="text/html" data-template-name="divide-block">
+    <div class="form-row">
+        <label for="node-input-name" title="Display name shown on the canvas"><i class="fa fa-tag"></i> Name</label>
+        <input type="text" id="node-input-name" placeholder="Name">
+    </div>
+    <div class="form-row">
+        <label for="node-input-slots" title="Number of input slots (positive integer, e.g., 2)"><i class="fa fa-list-ol"></i> Slots</label>
+        <input type="number" id="node-input-slots" placeholder="2" min="1" step="1">
+    </div>
+</script>
+
+<script type="text/javascript">
+    RED.nodes.registerType("divide-block", {
+        category: "control",
+        color: "#301934",
+        defaults: {
+            name: { value: "" },
+            slots: {
+                value: 2,
+                required: true,
+                validate: function(v) { return !isNaN(parseInt(v)) && parseInt(v) > 1; }
+            }
+        },
+        inputs: 1,
+        outputs: 1,
+        inputLabels: ["input"],
+        outputLabels: ["quotient"],
+        icon: "split.svg",
+        paletteLabel: "divide",
+        label: function() {
+            return this.name ? `${this.name} (${this.slots})` : `divide (${this.slots})`;
+        }
+    });
+</script>
+
+<script type="text/markdown" data-help-name="divide-block">
+Divides numeric inputs from multiple slots in sequence.
+
+### Inputs
+: context (string) : Configuration commands - `"reset"`, `"slots"`, or identifies input slot (e.g., `"in1"`, `"in2"`).
+: payload (number | boolean) : Number for slot input, boolean for reset, integer for slots configuration.
+
+### Outputs
+: payload (number) : Result of dividing slots in sequence (in1 / in2 / ...).
+
+### Details
+Divides numeric `msg.payload` values from slots identified by `msg.context` (e.g., `"in1"`, `"in2"`) in sequence. 
+
+Slots are set via editor or `msg.context = "slots"` with positive integer.
+
+Inputs for `in2` onward must be non-zero to avoid division by zero. Resets inputs to 1 via `msg.context = "reset"` with `msg.payload = true`. 
+
+Outputs a number only when the result changes. 
+
+### Status
+- Green (dot): Configuration
+- Blue (dot): Output, no alarm
+- Red (dot): Output with alarm
+- Red (ring): Errors
+- Yellow (ring): Unknown context
+
+### References
+- [Node-RED Documentation](https://nodered.org/docs/)
+- [GitHub Repository](https://github.com/BldgBlocks/node-red-contrib-buildingblocks-control.git)
+</script>

package/nodes/divide-block.js

@@ -0,0 +1,123 @@
+module.exports = function(RED) {
+    function DivideBlockNode(config) {
+        RED.nodes.createNode(this, config);
+        
+        const node = this;
+        
+        // Initialize runtime state
+        node.runtime = {
+            name: config.name,
+            slots: parseInt(config.slots),
+            inputs: Array(node.runtime.slots).fill(1).map(x => parseFloat(x)),
+            lastResult: null
+        };
+
+        node.status({
+            fill: "green",
+            shape: "dot",
+            text: `name: ${node.runtime.name}, slots: ${node.runtime.slots}`
+        });
+
+        node.on("input", function(msg, send, done) {
+            send = send || function() { node.send.apply(node, arguments); };
+
+            // Guard against invalid msg
+            if (!msg) {
+                node.status({ fill: "red", shape: "ring", text: "invalid message" });
+                if (done) done();
+                return;
+            }
+
+            // Check for missing context or payload
+            if (!msg.hasOwnProperty("context")) {
+                node.status({ fill: "red", shape: "ring", text: "missing context" });
+                if (done) done();
+                return;
+            }
+
+            if (!msg.hasOwnProperty("payload")) {
+                node.status({ fill: "red", shape: "ring", text: "missing payload" });
+                if (done) done();
+                return;
+            }
+
+            // Handle configuration messages
+            if (msg.context === "reset") {
+                if (typeof msg.payload !== "boolean") {
+                    node.status({ fill: "red", shape: "ring", text: "invalid reset" });
+                    if (done) done();
+                    return;
+                }
+                if (msg.payload === true) {
+                    node.runtime.inputs = Array(node.runtime.slots).fill(1);
+                    node.runtime.lastResult = null;
+                    node.status({ fill: "green", shape: "dot", text: "state reset" });
+                    if (done) done();
+                    return;
+                }
+            } else if (msg.context === "slots") {
+                let newSlots = parseInt(msg.payload);
+                if (isNaN(newSlots) || newSlots < 1) {
+                    node.status({ fill: "red", shape: "ring", text: "invalid slots" });
+                    if (done) done();
+                    return;
+                }
+                node.runtime.slots = newSlots;
+                node.runtime.inputs = Array(newSlots).fill(1);
+                node.runtime.lastResult = null;
+                node.status({ fill: "green", shape: "dot", text: `slots: ${node.runtime.slots}` });
+                if (done) done();
+                return;
+            } else if (msg.context.startsWith("in")) {
+                let slotIndex = parseInt(msg.context.slice(2)) - 1;
+                if (isNaN(slotIndex) || slotIndex < 0 || slotIndex >= node.runtime.slots) {
+                    node.status({ fill: "red", shape: "ring", text: `invalid input slot ${msg.context}` });
+                    if (done) done();
+                    return;
+                }
+                let newValue = parseFloat(msg.payload);
+                if (isNaN(newValue)) {
+                    node.status({ fill: "red", shape: "ring", text: "invalid input" });
+                    if (done) done();
+                    return;
+                }
+                if (slotIndex > 0 && newValue === 0) {
+                    node.status({ fill: "red", shape: "ring", text: "divide by zero" });
+                    if (done) done();
+                    return;
+                }
+                // Handle division by very small numbers approaching zero
+                if (slotIndex > 0 && Math.abs(newValue) < 1e-10) {  // Near-zero check
+                    node.status({ fill: "red", shape: "ring", text: "divide by near-zero" });
+                    if (done) done();
+                    return;
+                }
+                node.runtime.inputs[slotIndex] = newValue;
+                // Calculate division
+                const result = node.runtime.inputs.reduce((acc, val, idx) => idx === 0 ? val : acc / val, 1);
+                const isUnchanged = result === node.runtime.lastResult;
+                node.status({
+                    fill: "blue",
+                    shape: isUnchanged ? "ring" : "dot",
+                    text: `in: ${msg.context}=${newValue.toFixed(2)}, out: ${result.toFixed(2)}`
+                });
+                if (!isUnchanged) {
+                    node.runtime.lastResult = result;
+                    send({ payload: result });
+                }
+                if (done) done();
+                return;
+            } else {
+                node.status({ fill: "yellow", shape: "ring", text: "unknown context" });
+                if (done) done();
+                return;
+            }
+        });
+
+        node.on("close", function(done) {
+            done();
+        });
+    }
+
+    RED.nodes.registerType("divide-block", DivideBlockNode);
+};

package/nodes/edge-block.html

@@ -0,0 +1,71 @@
+<!-- UI Template Section -->
+<script type="text/html" data-template-name="edge-block">
+    <div class="form-row">
+        <label for="node-input-name" title="Display name shown on the canvas"><i class="fa fa-tag"></i> Name</label>
+        <input type="text" id="node-input-name" placeholder="Name">
+    </div>
+    <div class="form-row">
+        <label for="node-input-algorithm" title="Transition to detect (true-to-false or false-to-true)"><i class="fa fa-exchange"></i> Algorithm</label>
+        <select id="node-input-algorithm">
+            <option value="true-to-false">True to False</option>
+            <option value="false-to-true">False to True</option>
+        </select>
+    </div>
+</script>
+
+<!-- JavaScript Section -->
+<script type="text/javascript">
+    RED.nodes.registerType("edge-block", {
+        category: "control",
+        color: "#301934",
+        defaults: {
+            name: { value: "" },
+            algorithm: { value: "true-to-false", required: true }
+        },
+        inputs: 1,
+        outputs: 1,
+        inputLabels: ["input"],
+        outputLabels: ["transition"],
+        icon: "font-awesome/fa-exchange",
+        paletteLabel: "edge",
+        label: function() {
+            return this.name || "edge";
+        }
+    });
+</script>
+
+<!-- Help Section -->
+<script type="text/markdown" data-help-name="edge-block">
+Detects configured boolean transitions (true-to-false or false-to-true) in `msg.payload`.
+
+### Inputs
+: payload (boolean) : Boolean to monitor for transitions.
+: context (string) : Action (`"algorithm"` to set transition type, `"reset"` to clear state). Unknown `msg.context` is ignored.
+: payload (string | boolean) : Transition type (`"true-to-false"`, `"false-to-true"`) for `"algorithm"`, true for `"reset"`.
+
+### Outputs
+: payload (boolean) : `true` when the specified transition occurs (true-to-false or false-to-true).
+
+### Properties
+: name (string) : Display name in editor.
+: algorithm (string) : Transition to detect (`"true-to-false"`, `"false-to-true"`).
+
+### Details
+Detects transitions in boolean payloads based on the configured `algorithm`. 
+Outputs `msg.payload` as true only when the specified transition occurs (true-to-false or false-to-true). 
+No output on first input after reset, if no transition occurs, or for non-boolean inputs. 
+Configuration via `msg.context`
+- `"algorithm"` Sets transition type, no output.
+- `"reset"` Clears state, no output.
+
+### Status
+- Green (dot): Configuration
+- Blue (dot): Output, no alarm
+- Red (dot): Output with alarm
+- Red (ring): Errors
+- Yellow (ring): Unknown context
+
+### References
+- [Node-RED Documentation](https://nodered.org/docs/)
+- [GitHub Repository](https://github.com/BldgBlocks/node-red-contrib-buildingblocks-control.git)
+</script>

package/nodes/edge-block.js

@@ -0,0 +1,120 @@
+module.exports = function(RED) {
+    function EdgeBlockNode(config) {
+        RED.nodes.createNode(this, config);
+        const node = this;
+
+        // Initialize runtime state
+        node.runtime = {
+            name: config.name,
+            algorithm: config.algorithm,
+            lastValue: null
+        };
+
+        node.status({
+            fill: "green",
+            shape: "dot",
+            text: `name: ${node.runtime.name || "edge"}, algorithm: ${node.runtime.algorithm}`
+        });
+
+        node.on("input", function(msg, send, done) {
+            send = send || function() { node.send.apply(node, arguments); };
+
+            const validAlgorithms = ["true-to-false", "false-to-true"];
+
+            // Guard against invalid message
+            if (!msg) {
+                node.status({ fill: "red", shape: "ring", text: "invalid message" });
+                if (done) done();
+                return;
+            }
+
+            // Handle configuration messages
+            if (msg.hasOwnProperty("context") && typeof msg.context === "string") {
+                if (msg.context === "algorithm") {
+                    if (!msg.hasOwnProperty("payload")) {
+                        node.status({ fill: "red", shape: "ring", text: "missing payload" });
+                        if (done) done();
+                        return;
+                    }
+                    const newAlgorithm = String(msg.payload);
+                    if (!validAlgorithms.includes(newAlgorithm)) {
+                        node.status({ fill: "red", shape: "ring", text: "invalid algorithm" });
+                        if (done) done();
+                        return;
+                    }
+                    node.runtime.algorithm = newAlgorithm;
+                    node.status({ fill: "green", shape: "dot", text: `algorithm: ${newAlgorithm}` });
+                    if (done) done();
+                    return;
+                }
+
+                if (msg.context === "reset") {
+                    if (!msg.hasOwnProperty("payload") || typeof msg.payload !== "boolean") {
+                        node.status({ fill: "red", shape: "ring", text: "invalid reset" });
+                        if (done) done();
+                        return;
+                    }
+                    if (msg.payload === true) {
+                        node.runtime.lastValue = null;
+                        node.status({ fill: "green", shape: "dot", text: "state reset" });
+                        if (done) done();
+                        return;
+                    }
+                    if (done) done();
+                    return;
+                }
+                // Ignore unknown context, process payload
+            }
+
+            // Validate payload
+            if (!msg.hasOwnProperty("payload")) {
+                node.status({ fill: "red", shape: "ring", text: "missing payload" });
+                if (done) done();
+                return;
+            }
+
+            if (typeof msg.payload !== "boolean") {
+                node.status({ fill: "red", shape: "ring", text: "invalid input" });
+                if (done) done();
+                return;
+            }
+
+            const currentValue = msg.payload;
+            const lastValue = node.runtime.lastValue;
+
+            // Check for transition
+            let isTransition = false;
+            if (lastValue !== null && lastValue !== undefined) {
+                if (node.runtime.algorithm === "true-to-false" && lastValue === true && currentValue === false) {
+                    isTransition = true;
+                } else if (node.runtime.algorithm === "false-to-true" && lastValue === false && currentValue === true) {
+                    isTransition = true;
+                }
+            }
+
+            if (isTransition) {
+                node.status({
+                    fill: "blue",
+                    shape: "dot",
+                    text: `in: ${currentValue}, out: true`
+                });
+                send({ payload: true });
+            } else {
+                node.status({
+                    fill: "blue",
+                    shape: "ring",
+                    text: `in: ${currentValue}, out: none`
+                });
+            }
+
+            node.runtime.lastValue = currentValue;
+            if (done) done();
+        });
+
+        node.on("close", function(done) {
+            done();
+        });
+    }
+
+    RED.nodes.registerType("edge-block", EdgeBlockNode);
+};