@tbrandenburg/node-red-cli 0.2.3

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Tom Brandenburg
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,356 @@
+# node-red-cli 🔗
+
+[![Checks](https://github.com/tbrandenburg/node-red-cli/actions/workflows/checks.yml/badge.svg)](https://github.com/tbrandenburg/node-red-cli/actions/workflows/checks.yml)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](LICENSE)
+[![Node.js >=24](https://img.shields.io/badge/node-%3E%3D24-brightgreen.svg)](package.json)
+
+## Call Node-RED flows like Unix functions ⚡
+
+`node-red-cli` explores a simple, powerful idea: existing Node-RED flows
+should be usable from a CLI or a Node.js host just like ordinary functions.
+
+```bash
+node-red-cli flows.json calculate --set x=4 --set y=5 < /dev/null
+```
+
+```
+9
+```
+
+By default only the resulting payload is printed as plain text. Pass
+`--format=json` to print the full result object as JSON instead:
+
+```bash
+node bin/node-red-cli.js test/fixtures/flows.json calculate \
+  --set x=4 --set y=5 --format=json < /dev/null
+```
+
+```json
+{ "payload": 9, "_msgid": "..." }
+```
+
+This turns Node-RED from a visual automation tool into a reusable runtime
+building block for scripts, services, pipelines, and developer tooling. 🧩
+
+## The idea 💡
+
+An existing flow becomes a clean input/output interface:
+
+```text
+stdin / CLI args
+        |
+        v
+   Node-RED runtime
+        |
+        v
+   link in: calculate -> any flow -> link out: return
+        |
+        v
+stdout / Promise<Result>
+```
+
+The flow itself stays untouched. No extra CLI nodes, no copy-pasted logic, and
+no permanently deployed adapter structure. 🚫🔧
+
+## Why node-red-cli? ✅
+
+- **Reuse existing flows:** business logic stays where it's already
+  maintained — in Node-RED.
+- **Uses the real Node-RED runtime:** core and contrib nodes don't need to be
+  reimplemented.
+- **CLI-friendly I/O:** JSON in, JSON out.
+- **Async support included:** Node-RED flows keep working exactly as they
+  normally do.
+- **Safely bounded calls:** timeouts prevent a process from hanging forever.
+- **Clean separation:** results go to `stdout`, logs and errors go to
+  `stderr`.
+- **No flow mutation:** the current implementation adds no temporary nodes and
+  never redeploys `flows.json`.
+
+## Current state 🚧
+
+This repository provides an early-stage CLI and host-side adapter for
+Node-RED 5.0.4. The adapter invokes an existing `link in` node and captures
+the response from a `link out` node in return mode as a Promise.
+
+The included example flow (`test/fixtures/flows.json`) computes `x + y`:
+
+```text
+link in: calculate -> Function -> link out: return
+```
+
+The test suite (`test/e2e/flow.e2e.test.js`) verifies:
+
+1. ✅ A successful call returning `{ payload: 9 }`.
+2. ✅ Preflight validation rejecting an unknown target.
+3. ✅ A timeout when a flow doesn't respond in time.
+4. ✅ An unchanged SHA-256 hash of the flow file before and after the call.
+
+## Project layout 📁
+
+```text
+bin/                CLI entrypoint (node-red-cli)
+src/                Host-side link-call adapter (library API)
+test/unit/          Fast tests against a fake Node-RED runtime
+test/integration/   Adapter tests against a real embedded runtime
+test/e2e/           Full round trip through the example flow
+test/fixtures/      Example Node-RED flow used as a test asset
+```
+
+## Install 📦
+
+```bash
+npm install -g @tbrandenburg/node-red-cli
+```
+
+This installs the `node-red-cli` command globally, ready to use against
+any Node-RED flow file (see [Quick start](#quick-start-) below).
+
+## Quick start 🚀
+
+To build and run from a repo checkout instead (e.g. for contributing):
+
+```bash
+make install
+make test
+```
+
+`make install` also wires up a `pre-push` git hook that runs `make ci`
+(format, lint, and tests) automatically before every push.
+
+To use `node-red-cli` as a regular command from a checkout instead of via
+`node bin/...`, install it globally from the local source:
+
+```bash
+make install-global
+```
+
+Try the CLI directly against the example flow:
+
+```bash
+echo '{"payload":{"x":4,"y":5}}' | node bin/node-red-cli.js test/fixtures/flows.json calculate
+```
+
+```
+9
+```
+
+The `_msgid` is generated by Node-RED and differs on every run. To see it
+along with the rest of the result object, pass `--format=json`.
+
+The `target` argument is optional; if the flow has exactly one `link in`
+node, it is used automatically (with a warning on stderr if it also had to be
+inferred across multiple tabs):
+
+```bash
+echo '{"payload":{"x":4,"y":5}}' | node bin/node-red-cli.js test/fixtures/single-link-in.flows.json
+```
+
+Instead of building the whole JSON message yourself, individual payload
+attributes can be set directly from CLI params with repeatable
+`--set <key>=<value>` flags. Values are JSON-parsed when possible (so `4`
+becomes a number, `true` a boolean), otherwise kept as plain strings, and they
+are applied on top of (and override) any payload read from stdin:
+
+```bash
+node bin/node-red-cli.js test/fixtures/flows.json calculate \
+  --set x=4 --set y=5 < /dev/null
+```
+
+```
+9
+```
+
+## Passing flow JSON inline 📥
+
+Instead of a `<flows.json>` file path, `--flow-json <value>` accepts the flow
+definition directly, so in-memory callers (tests, another Node.js process, a
+Node-RED editor "run this flow" action) never have to write a temp file just
+to satisfy this CLI's file-based API. It is mutually exclusive with the
+`<flows.json>` positional argument. `<value>` is one of:
+
+- an inline JSON array: `--flow-json '[{"id":"a",...}]'`
+- `-` to read the flow JSON from stdin
+- `@<path>` to read it from a file (equivalent to the positional argument)
+
+The flow is never written to disk in any of these forms.
+
+```bash
+node bin/node-red-cli.js --flow-json @test/fixtures/flows.json calculate \
+  --set x=4 --set y=5 < /dev/null
+```
+
+```
+9
+```
+
+Since stdin is also used to read the `msg` payload, `--flow-json -` and the
+stdin `msg` are mutually exclusive: when `--flow-json -` is used, stdin is
+consumed by the flow definition instead, so `msg` must be built entirely from
+`--set` params:
+
+```bash
+node bin/node-red-cli.js --flow-json - calculate --set x=4 --set y=5 \
+  < test/fixtures/flows.json
+```
+
+```
+9
+```
+
+## Installing additional Node-RED node packages 📦
+
+By default the CLI creates a fresh, ephemeral Node-RED `userDir` per
+invocation and deletes it afterwards, so only the node types bundled with
+`node-red` itself are available to a flow. To use community/custom nodes
+(e.g. `node-red-contrib-something`), two options work together:
+
+- `--user-dir [path]` makes the `userDir` persistent/reusable across runs
+  instead of ephemeral. Pass a path to use a specific directory, or the bare
+  flag to use a stable cache dir (`$XDG_CACHE_HOME/node-red-cli`, falling
+  back to `~/.cache/node-red-cli`). Omitting `--user-dir` entirely preserves
+  today's ephemeral behavior unchanged.
+- `--node-modules <name[@version]>[,...]` installs any of the given
+  Node-RED node npm packages that are missing from `<userDir>/node_modules`
+  before the flow runs. Repeatable and/or comma-separated. **Requires an
+  explicit `--user-dir`** — using it with the default ephemeral `userDir`
+  is rejected with a clear error, since the installed module would be
+  thrown away immediately and reinstalled from npm on every single
+  invocation.
+
+```bash
+node bin/node-red-cli.js flows.json calculate \
+  --user-dir ~/.cache/node-red-cli \
+  --node-modules node-red-node-random \
+  --set x=4 --set y=5 < /dev/null
+```
+
+Already-installed, version-matching modules are left untouched, so repeat
+runs against a warm cache do not touch the network. **No invocation ever
+reaches out to npm unless `--node-modules` is explicitly passed.**
+
+⚠️ **Security note**: `--node-modules` runs a real `npm install`, i.e.
+arbitrary code execution from whatever npm registry is configured. Only
+use it with trusted module names. A minimal built-in denylist blocks
+obviously unsafe values (path traversal, URLs, whitespace); operators can
+add exact names or `*`-glob patterns via the `NODE_RED_CLI_DENY_MODULES`
+environment variable (comma-separated), e.g.
+`NODE_RED_CLI_DENY_MODULES="node-red-contrib-*-internal"`.
+
+⚠️ **Persistent `userDir` caveat**: a shared `userDir` accumulates
+Node-RED runtime/state files (e.g. `.config.runtime.json`) across runs.
+Delete the directory (or the default `~/.cache/node-red-cli`) to clear the
+cache and start fresh.
+
+## Host API 🛠️
+
+The core interface is intentionally small:
+
+```js
+const { createHostLinkCaller } = require("./src/link-call");
+
+const caller = createHostLinkCaller(RED);
+
+const result = await caller.call(
+  "calculate",
+  { payload: { x: 4, y: 5 } },
+  { flow: "calculator", timeout: 5000 }
+);
+
+console.log(result.payload); // 9
+caller.close();
+```
+
+`flow` accepts either the tab ID or the unique tab label. If omitted, the only
+existing workspace tab is selected automatically.
+
+`target` (the `link in` node) is also optional. If omitted, the only `link in`
+node in the resolved flow is used automatically. If no `flow` is given and
+several tabs exist, but only one `link in` node is present overall, that node
+(and its tab) is inferred and a warning is reported via the optional
+`onWarning` callback — pass one to `caller.call(...)` to observe it:
+
+```js
+const result = await caller.call(
+  undefined,
+  { payload: { x: 4, y: 5 } },
+  {
+    onWarning: (warning) => console.error(warning)
+  }
+);
+```
+
+If either the flow or the target remains ambiguous (more than one candidate),
+`call()` rejects with a preflight validation error naming what must be
+specified explicitly.
+
+## Technical approach 🔬
+
+Node-RED's link-call semantics use `_linkSource` to make the origin of a call
+available to a return link. This adapter sets the required stack entry on the
+host side and registers a targeted `onReceive` hook. The returned message
+resolves the Promise before the link-out node needs to resolve the caller via
+`RED.nodes.getNode(...)`.
+
+This is a lightweight compatibility layer for Node-RED 5.0.x, not a public
+runtime API. The internal semantics are therefore encapsulated behind
+`createHostLinkCaller(RED)` and should be integration-tested separately for
+each supported Node-RED version.
+
+## Preflight and limitations ⚠️
+
+Before a call, `validateTarget(RED, targetId)` checks:
+
+- target ID and target type `link in`
+- instantiation of the target node
+- missing wire targets and duplicate IDs
+- at least one reachable `link out` with `mode: "return"`
+- instantiation of reachable return nodes
+- availability of the required runtime hooks
+
+Validation does not prove that a flow terminates semantically or replies
+exactly once. A runtime timeout remains necessary for that.
+
+## Roadmap 🗺️
+
+The long-term goal is a stable, official host API in Node-RED core:
+
+```js
+const result = await callNodeRedFlow({
+  target: "calculate",
+  msg,
+  timeout: 5000
+});
+```
+
+Or as a runtime interface:
+
+```js
+const result = await RED.runtime.flows.call("calculate", msg, {
+  timeout: 5000
+});
+```
+
+The research focuses on which parts of the existing `node.linkcall()`
+implementation can be generalized, and what a small upstream API such as
+`RED.nodes.callLink()` or `RED.runtime.flows.call()` could look like.
+
+## Status 📊
+
+**Early-stage CLI:** the approach works for the included Node-RED 5.0.4
+example flow. The link-call internals used here are not stabilized as a
+public Node-RED API. Production use therefore requires deliberate version
+pinning, integration tests, and robust error handling for ambiguous or
+non-terminating flows.
+
+## Contributing 🤝
+
+Contributions are welcome — see [CONTRIBUTING.md](CONTRIBUTING.md).
+
+## Security 🔒
+
+Please report vulnerabilities responsibly — see [SECURITY.md](SECURITY.md).
+
+## License 📄
+
+MIT — see [LICENSE](LICENSE).

package/bin/node-red-cli.js

@@ -0,0 +1,295 @@
+#!/usr/bin/env node
+"use strict";
+
+const fs = require("node:fs");
+const path = require("node:path");
+const { Command } = require("commander");
+const RED = require("node-red");
+const { createHostLinkCaller } = require("../src/link-call");
+const { createMemoryStorageModule } = require("../src/flow-storage");
+const { applySetParams, parseFlowJsonParam, parseFormatParam, formatPlain } = require("../src/cli-params");
+const { parseNodeModulesParam, resolveUserDir } = require("../src/node-modules");
+const { installMissingNodeModules } = require("../src/node-modules-install");
+const { version } = require("../package.json");
+
+const HELP_TEXT = [
+  "",
+  "Reads a JSON message from stdin and invokes the given link-in target",
+  "in the specified Node-RED flow file. The message returned by the",
+  "matching link-out (return) node is printed to stdout.",
+  "",
+  "target defaults to the sole link-in node in the flow file when omitted.",
+  "If multiple tabs exist but only one link-in node is present overall,",
+  "it is used automatically (a warning is printed to stderr).",
+  "",
+  "--set <key>=<value> sets msg.payload.<key> to <value>, repeatable.",
+  "Values are JSON-parsed when possible (4 -> number, true -> boolean),",
+  "otherwise kept as plain strings. --set params are applied on top of",
+  "the payload read from stdin (if any) and override matching keys.",
+  "",
+  "--format=json|plain selects the stdout output format (default: plain).",
+  "json prints the full result object as JSON. plain prints only the",
+  "result payload as plain text.",
+  "",
+  "--flow-json <value> supplies the flow definition inline instead of the",
+  "<flows.json> positional argument (the two are mutually exclusive).",
+  "<value> is one of:",
+  '  - an inline JSON array, e.g. --flow-json \'[{"id":"a",...}]\'',
+  "  - '-' to read the flow JSON from stdin",
+  "  - '@<path>' to read it from a file",
+  "The flow is never written to disk. Because stdin can only be consumed",
+  "once, --flow-json - takes stdin for the flow definition, not for msg;",
+  "in that mode msg must be built entirely from --set params.",
+  "",
+  "--user-dir [path] makes Node-RED's userDir persistent/reusable across",
+  "runs instead of the default ephemeral tmpdir that is created fresh and",
+  "deleted after every invocation. Pass a path to use a specific directory,",
+  "or the bare flag to use a stable cache dir ($XDG_CACHE_HOME/node-red-cli,",
+  "falling back to ~/.cache/node-red-cli). A shared userDir accumulates",
+  "Node-RED runtime/state files (e.g. .config.runtime.json) across runs;",
+  "delete the directory to clear the cache.",
+  "",
+  "--node-modules <name[@version]>[,...] installs any of the given",
+  "Node-RED node npm packages that are missing from userDir/node_modules",
+  "before the flow runs (repeatable and/or comma-separated). Requires an",
+  "explicit --user-dir (installing into an ephemeral userDir would just",
+  "reinstall from npm on every run). Already-installed, version-matching",
+  "modules are left untouched (no network access). This runs a real",
+  "`npm install`, i.e. arbitrary code execution from the configured npm",
+  "registry - only use it with trusted module names.",
+  "",
+  "Example:",
+  '  echo \'{"payload":{"x":4,"y":5}}\' | node-red-cli flows.json calculate',
+  "",
+  "Equivalent using --set instead of stdin:",
+  "  node-red-cli flows.json calculate --set x=4 --set y=5 < /dev/null"
+].join("\n");
+
+const LEVEL_NAMES = {
+  10: "fatal",
+  20: "error",
+  30: "warn",
+  40: "info",
+  50: "debug",
+  60: "trace",
+  98: "audit",
+  99: "metric"
+};
+
+/**
+ * Node-RED's built-in console log handler always writes via console.log,
+ * i.e. to stdout. That would corrupt the JSON result on stdout, so replace
+ * it with a handler that writes to stderr instead.
+ */
+function stderrLogHandler() {
+  return (msg) => {
+    const levelName = LEVEL_NAMES[msg.level] || msg.level;
+    const source = msg.type ? `[${msg.type}:${msg.name || msg.id}] ` : "";
+    const message = msg.msg && msg.msg.message ? msg.msg.message : msg.msg;
+    console.error(`node-red-cli: [${levelName}] ${source}${message}`);
+  };
+}
+
+function readStdin() {
+  return new Promise((resolve, reject) => {
+    const chunks = [];
+    process.stdin.on("data", (chunk) => chunks.push(chunk));
+    process.stdin.on("end", () => resolve(Buffer.concat(chunks).toString("utf8")));
+    process.stdin.on("error", reject);
+  });
+}
+
+/** Collects a repeatable `--set key=value` option into an array. */
+function collectSet(value, previous) {
+  return [...previous, value];
+}
+
+/** Collects a repeatable `--node-modules` option into an array. */
+function collectNodeModules(value, previous) {
+  return [...previous, value];
+}
+
+async function run(args, options) {
+  // <flows.json> and --flow-json are mutually exclusive, and both share the
+  // "first positional" slot conceptually, so parse positionals manually
+  // instead of relying on commander's fixed argument order: when
+  // --flow-json is given, the sole remaining positional is the target;
+  // otherwise the first positional is the flow file and the second the
+  // target.
+  const [flowFileArg, target] = options.flowJson ? [undefined, args[0]] : args;
+
+  if (args.length > (options.flowJson ? 1 : 2)) {
+    console.error("node-red-cli: too many positional arguments");
+    process.exitCode = 1;
+    return;
+  }
+
+  if (!flowFileArg && !options.flowJson) {
+    console.error("node-red-cli: either <flows.json> or --flow-json must be given");
+    process.exitCode = 1;
+    return;
+  }
+  if (flowFileArg && options.flowJson) {
+    console.error("node-red-cli: <flows.json> and --flow-json are mutually exclusive");
+    process.exitCode = 1;
+    return;
+  }
+
+  let flowFile;
+  let flows;
+  if (options.flowJson) {
+    try {
+      flows = await parseFlowJsonParam(options.flowJson, { readStdin });
+    } catch (error) {
+      console.error(`node-red-cli: ${error.message}`);
+      process.exitCode = 1;
+      return;
+    }
+  } else {
+    flowFile = path.resolve(process.cwd(), flowFileArg);
+    if (!fs.existsSync(flowFile)) {
+      console.error(`node-red-cli: flow file not found: ${flowFile}`);
+      process.exitCode = 1;
+      return;
+    }
+  }
+
+  const usedStdinForFlow = options.flowJson === "-";
+  let msg;
+  if (usedStdinForFlow) {
+    msg = { payload: {} };
+  } else {
+    const rawInput = (await readStdin()).trim();
+    try {
+      msg = rawInput.length > 0 ? JSON.parse(rawInput) : {};
+    } catch (error) {
+      console.error(`node-red-cli: invalid JSON on stdin: ${error.message}`);
+      process.exitCode = 1;
+      return;
+    }
+
+    if (!msg || typeof msg !== "object" || Array.isArray(msg)) {
+      console.error("node-red-cli: the JSON message on stdin must be an object");
+      process.exitCode = 1;
+      return;
+    }
+  }
+
+  try {
+    msg.payload = applySetParams(msg.payload, options.set);
+  } catch (error) {
+    console.error(`node-red-cli: ${error.message}`);
+    process.exitCode = 1;
+    return;
+  }
+
+  try {
+    parseFormatParam(options.format);
+  } catch (error) {
+    console.error(`node-red-cli: ${error.message}`);
+    process.exitCode = 1;
+    return;
+  }
+
+  let nodeModules;
+  try {
+    nodeModules = options.nodeModules.length > 0 ? parseNodeModulesParam(options.nodeModules) : [];
+  } catch (error) {
+    console.error(`node-red-cli: ${error.message}`);
+    process.exitCode = 1;
+    return;
+  }
+
+  const persistentUserDir = resolveUserDir(options.userDir);
+  if (nodeModules.length > 0 && !persistentUserDir) {
+    console.error(
+      "node-red-cli: --node-modules requires an explicit --user-dir (a persistent directory); " +
+        "using it with the default ephemeral userDir would reinstall from npm on every run"
+    );
+    process.exitCode = 1;
+    return;
+  }
+
+  const userDir =
+    persistentUserDir || fs.mkdtempSync(path.join(require("node:os").tmpdir(), "node-red-cli-"));
+
+  if (nodeModules.length > 0) {
+    try {
+      await installMissingNodeModules(userDir, nodeModules);
+    } catch (error) {
+      console.error(`node-red-cli: ${error.message}`);
+      process.exitCode = 1;
+      if (!persistentUserDir) fs.rmSync(userDir, { recursive: true, force: true });
+      return;
+    }
+  }
+
+  let caller;
+
+  RED.init({
+    ...(flows ? { storageModule: createMemoryStorageModule(flows) } : { flowFile }),
+    userDir,
+    httpAdminRoot: false,
+    httpNodeRoot: false,
+    editorTheme: { projects: { enabled: false } },
+    logging: { console: { level: "warn", metrics: false, audit: false, handler: stderrLogHandler } }
+  });
+
+  try {
+    const flowsStarted = new Promise((resolve) => RED.events.once("flows:started", resolve));
+    await RED.start();
+    await flowsStarted;
+
+    caller = createHostLinkCaller(RED);
+    const result = await caller.call(target, msg, {
+      flow: options.flow,
+      timeout: options.timeout,
+      onWarning: (warning) => console.error(`node-red-cli: warning: ${warning}`)
+    });
+    process.stdout.write(
+      options.format === "plain" ? `${formatPlain(result.payload)}\n` : `${JSON.stringify(result)}\n`
+    );
+  } catch (error) {
+    console.error(`node-red-cli: ${error.message}`);
+    process.exitCode = 1;
+  } finally {
+    caller?.close();
+    await RED.stop();
+    if (!persistentUserDir) fs.rmSync(userDir, { recursive: true, force: true });
+  }
+}
+
+const program = new Command();
+
+program
+  .name("node-red-cli")
+  .usage(
+    "<flows.json>|--flow-json <value> [target] [--flow=<tab>] [--timeout=<ms>] [--set <key>=<value>]... [--format=json|plain]"
+  )
+  .argument("[args...]", "[flows.json] [target], or [target] alone when --flow-json is given (see --help)")
+  .option("--flow <tab>", "flow tab name/id to search the target in")
+  .option(
+    "--flow-json <value>",
+    "flow JSON inline, '-' for stdin, or '@path' for a file; mutually exclusive with <flows.json>"
+  )
+  .option("--timeout <ms>", "call timeout in milliseconds", (value) => Number(value), 5000)
+  .option("--format <format>", "output format: json|plain", "plain")
+  .option("--set <key=value>", "set msg.payload.<key> to <value>, repeatable", collectSet, [])
+  .option(
+    "--user-dir [path]",
+    "persistent Node-RED userDir (bare flag = default cache dir); omit for an ephemeral tmpdir"
+  )
+  .option(
+    "--node-modules <name[@version]>",
+    "install missing Node-RED node npm package(s), comma-separated and/or repeatable; requires --user-dir",
+    collectNodeModules,
+    []
+  )
+  .addHelpText("after", HELP_TEXT)
+  .version(version, "-v, --version", "print the installed node-red-cli version and exit")
+  .action(run);
+
+program.parseAsync(process.argv).catch((error) => {
+  console.error(error.stack || error.message);
+  process.exitCode = 1;
+});