@jxsuite/formulas 0.0.1

package/README.md

@@ -0,0 +1,58 @@
+# @jxsuite/formulas
+
+Composite **pure formulas** for Jx, authored as declarative `$expression` JSON
+(spec §19.4c). Each formula is a named, parameterized computation — `clamp`,
+`sum`, `average`, `truncate`, `initials`, … — whose body is built exclusively
+from blessed operators, pure standard-library method operators (§19.4d), and
+blessed globals. No JavaScript source anywhere: every formula is inspectable
+data that the visual editor can open, badge with live values, and recompose.
+
+## Consumption model: copy-in, not a project dependency
+
+This package is a **studio/tooling dependency**, deliberately _not_ a runtime
+or project dependency. Jx documents stay self-contained plain JSON:
+
+- **In Jx Studio** — the formula catalog lists these formulas alongside
+  operators and blessed globals. Picking one **copies its state entry into the
+  document** (vendoring the JSON) and inserts a `call` node referencing it.
+  From that moment the project owns the formula: no package resolution at
+  build or run time, no version coupling, and the user can edit their copy
+  like any other named formula.
+- **Programmatically** — `formulaEntries()` returns the catalog as
+  ready-to-merge `state` entries for tooling that seeds documents or
+  `project.json` state (starters, importers, AI agents):
+
+  ```ts
+  import { catalog, formulaEntries } from "@jxsuite/formulas";
+
+  const state = { ...formulaEntries() };
+  // → { clamp: { $expression: …, parameters: […] }, sum: …, … }
+  ```
+
+Because consumption is copy-in, publishing a new package version never changes
+existing projects — they upgrade a formula by re-inserting it.
+
+## Authoring a formula
+
+One folder per formula under `formulas/`:
+
+```
+formulas/<name>/formula.json     # metadata: name, description, parameters (CEM convention)
+formulas/<name>/expression.json  # the pure $expression body over $args/<name> refs
+```
+
+Then regenerate the catalog module:
+
+```sh
+bun run generate
+```
+
+The generator (`bin/generate.ts`) emits `src/catalog.ts` and **fails the build
+on anything impure**: unknown or mutating operators, or `call` targets outside
+the blessed pure globals (`window#/Math/…`, `window#/JSON/…`, …). Descriptions
+are mandatory — they double as editor tooltips and the LLM contract.
+
+## Releases
+
+Versioned independently via release-please (`formulas` component); published to
+npm with provenance by the repo's publish workflow when a release is cut.

package/formulas/average/expression.json

@@ -0,0 +1,19 @@
+{
+  "operator": "?:",
+  "target": { "$ref": "$args/values/length" },
+  "value": {
+    "operator": "/",
+    "target": {
+      "operator": "reduce",
+      "target": { "$ref": "$args/values" },
+      "initial": 0,
+      "value": {
+        "operator": "+",
+        "target": { "$ref": "$reduce/acc" },
+        "value": { "$ref": "$map/item" }
+      }
+    },
+    "value": { "$ref": "$args/values/length" }
+  },
+  "initial": 0
+}

package/formulas/average/formula.json

@@ -0,0 +1,5 @@
+{
+  "name": "average",
+  "description": "Arithmetic mean of an array of numbers; 0 for an empty array.",
+  "parameters": [{ "name": "values", "type": { "text": "number[]" } }]
+}

package/formulas/capitalize/expression.json

@@ -0,0 +1,8 @@
+{
+  "operator": "+",
+  "target": {
+    "operator": "toUpperCase",
+    "target": { "operator": "charAt", "target": { "$ref": "$args/text" }, "value": 0 }
+  },
+  "value": { "operator": "slice", "target": { "$ref": "$args/text" }, "value": 1 }
+}

package/formulas/capitalize/formula.json

@@ -0,0 +1,5 @@
+{
+  "name": "capitalize",
+  "description": "Uppercase the first character of a string, leaving the rest unchanged (the CSS text-transform: capitalize shape for a single word).",
+  "parameters": [{ "name": "text", "type": { "text": "string" } }]
+}

package/formulas/clamp/expression.json

@@ -0,0 +1,12 @@
+{
+  "operator": "call",
+  "target": { "$ref": "window#/Math/min" },
+  "value": [
+    {
+      "operator": "call",
+      "target": { "$ref": "window#/Math/max" },
+      "value": [{ "$ref": "$args/value" }, { "$ref": "$args/min" }]
+    },
+    { "$ref": "$args/max" }
+  ]
+}

package/formulas/clamp/formula.json

@@ -0,0 +1,9 @@
+{
+  "name": "clamp",
+  "description": "Bound a number to the [min, max] range (the TC39 Math.clamp shape): returns min when below, max when above, the value itself otherwise.",
+  "parameters": [
+    { "name": "value", "type": { "text": "number" } },
+    { "name": "min", "type": { "text": "number" } },
+    { "name": "max", "type": { "text": "number" } }
+  ]
+}

package/formulas/compact/expression.json

@@ -0,0 +1,5 @@
+{
+  "operator": "filter",
+  "target": { "$ref": "$args/values" },
+  "value": { "operator": "!", "target": { "operator": "!", "target": { "$ref": "$map/item" } } }
+}

package/formulas/compact/formula.json

@@ -0,0 +1,5 @@
+{
+  "name": "compact",
+  "description": "A copy of an array with the falsy elements removed (Array.prototype.filter on truthiness).",
+  "parameters": [{ "name": "values", "type": { "text": "unknown[]" } }]
+}

package/formulas/count/expression.json

@@ -0,0 +1,5 @@
+{
+  "operator": "??",
+  "target": { "$ref": "$args/values/length" },
+  "value": 0
+}

package/formulas/count/formula.json

@@ -0,0 +1,5 @@
+{
+  "name": "count",
+  "description": "The length of an array or string, or 0 when the value is missing.",
+  "parameters": [{ "name": "values", "type": { "text": "unknown[] | string" } }]
+}

package/formulas/first/expression.json

@@ -0,0 +1,5 @@
+{
+  "operator": "??",
+  "target": { "$ref": "$args/values/0" },
+  "value": null
+}

package/formulas/first/formula.json

@@ -0,0 +1,5 @@
+{
+  "name": "first",
+  "description": "The first element of an array (index 0), or null when empty.",
+  "parameters": [{ "name": "values", "type": { "text": "unknown[]" } }]
+}

package/formulas/initials/expression.json

@@ -0,0 +1,12 @@
+{
+  "operator": "join",
+  "target": {
+    "operator": "map",
+    "target": { "operator": "split", "target": { "$ref": "$args/name" }, "value": " " },
+    "value": {
+      "operator": "toUpperCase",
+      "target": { "operator": "charAt", "target": { "$ref": "$map/item" }, "value": 0 }
+    }
+  },
+  "value": ""
+}

package/formulas/initials/formula.json

@@ -0,0 +1,5 @@
+{
+  "name": "initials",
+  "description": "The uppercase first letters of each whitespace-separated word, joined (e.g. \"ada lovelace\" → \"AL\").",
+  "parameters": [{ "name": "name", "type": { "text": "string" } }]
+}

package/formulas/isEmpty/expression.json

@@ -0,0 +1,5 @@
+{
+  "operator": "===",
+  "target": { "operator": "??", "target": { "$ref": "$args/value/length" }, "value": 0 },
+  "value": 0
+}

package/formulas/isEmpty/formula.json

@@ -0,0 +1,5 @@
+{
+  "name": "isEmpty",
+  "description": "True when an array or string has no elements (length 0 — a missing value counts as empty).",
+  "parameters": [{ "name": "value", "type": { "text": "unknown[] | string" } }]
+}

package/formulas/last/expression.json

@@ -0,0 +1,5 @@
+{
+  "operator": "at",
+  "target": { "$ref": "$args/values" },
+  "value": -1
+}

package/formulas/last/formula.json

@@ -0,0 +1,5 @@
+{
+  "name": "last",
+  "description": "The last element of an array (Array.prototype.at(-1)), or undefined when empty.",
+  "parameters": [{ "name": "values", "type": { "text": "unknown[]" } }]
+}

package/formulas/max/expression.json

@@ -0,0 +1,10 @@
+{
+  "operator": "reduce",
+  "target": { "$ref": "$args/values" },
+  "initial": { "$ref": "$args/values/0" },
+  "value": {
+    "operator": "call",
+    "target": { "$ref": "window#/Math/max" },
+    "value": [{ "$ref": "$reduce/acc" }, { "$ref": "$map/item" }]
+  }
+}

package/formulas/max/formula.json

@@ -0,0 +1,5 @@
+{
+  "name": "max",
+  "description": "The largest number in an array (Math.max folded over the values); undefined for an empty array.",
+  "parameters": [{ "name": "values", "type": { "text": "number[]" } }]
+}

package/formulas/min/expression.json

@@ -0,0 +1,10 @@
+{
+  "operator": "reduce",
+  "target": { "$ref": "$args/values" },
+  "initial": { "$ref": "$args/values/0" },
+  "value": {
+    "operator": "call",
+    "target": { "$ref": "window#/Math/min" },
+    "value": [{ "$ref": "$reduce/acc" }, { "$ref": "$map/item" }]
+  }
+}

package/formulas/min/formula.json

@@ -0,0 +1,5 @@
+{
+  "name": "min",
+  "description": "The smallest number in an array (Math.min folded over the values); undefined for an empty array.",
+  "parameters": [{ "name": "values", "type": { "text": "number[]" } }]
+}

package/formulas/percent/expression.json

@@ -0,0 +1,14 @@
+{
+  "operator": "?:",
+  "target": { "$ref": "$args/whole" },
+  "value": {
+    "operator": "*",
+    "target": {
+      "operator": "/",
+      "target": { "$ref": "$args/part" },
+      "value": { "$ref": "$args/whole" }
+    },
+    "value": 100
+  },
+  "initial": 0
+}

package/formulas/percent/formula.json

@@ -0,0 +1,8 @@
+{
+  "name": "percent",
+  "description": "part / whole as a percentage (0 when the whole is 0 or missing).",
+  "parameters": [
+    { "name": "part", "type": { "text": "number" } },
+    { "name": "whole", "type": { "text": "number" } }
+  ]
+}

package/formulas/roundTo/expression.json

@@ -0,0 +1,23 @@
+{
+  "operator": "/",
+  "target": {
+    "operator": "call",
+    "target": { "$ref": "window#/Math/round" },
+    "value": [
+      {
+        "operator": "*",
+        "target": { "$ref": "$args/value" },
+        "value": {
+          "operator": "call",
+          "target": { "$ref": "window#/Math/pow" },
+          "value": [10, { "$ref": "$args/digits" }]
+        }
+      }
+    ]
+  },
+  "value": {
+    "operator": "call",
+    "target": { "$ref": "window#/Math/pow" },
+    "value": [10, { "$ref": "$args/digits" }]
+  }
+}

package/formulas/roundTo/formula.json

@@ -0,0 +1,8 @@
+{
+  "name": "roundTo",
+  "description": "Round a number to the given decimal places (Math.round against a Math.pow(10, digits) scale).",
+  "parameters": [
+    { "name": "value", "type": { "text": "number" } },
+    { "name": "digits", "type": { "text": "number" }, "default": 0 }
+  ]
+}

package/formulas/sum/expression.json

@@ -0,0 +1,10 @@
+{
+  "operator": "reduce",
+  "target": { "$ref": "$args/values" },
+  "initial": 0,
+  "value": {
+    "operator": "+",
+    "target": { "$ref": "$reduce/acc" },
+    "value": { "$ref": "$map/item" }
+  }
+}

package/formulas/sum/formula.json

@@ -0,0 +1,5 @@
+{
+  "name": "sum",
+  "description": "Add every number in an array (Array.prototype.reduce with +, seeded at 0).",
+  "parameters": [{ "name": "values", "type": { "text": "number[]" } }]
+}

package/formulas/truncate/expression.json

@@ -0,0 +1,18 @@
+{
+  "operator": "?:",
+  "target": {
+    "operator": ">",
+    "target": { "$ref": "$args/text/length" },
+    "value": { "$ref": "$args/length" }
+  },
+  "value": {
+    "operator": "+",
+    "target": {
+      "operator": "slice",
+      "target": { "$ref": "$args/text" },
+      "value": [0, { "$ref": "$args/length" }]
+    },
+    "value": "…"
+  },
+  "initial": { "$ref": "$args/text" }
+}

package/formulas/truncate/formula.json

@@ -0,0 +1,8 @@
+{
+  "name": "truncate",
+  "description": "Shorten a string to at most the given length, appending a horizontal ellipsis when cut.",
+  "parameters": [
+    { "name": "text", "type": { "text": "string" } },
+    { "name": "length", "type": { "text": "number" } }
+  ]
+}

package/package.json

@@ -0,0 +1,33 @@
+{
+  "name": "@jxsuite/formulas",
+  "version": "0.0.1",
+  "description": "Composite pure formulas for Jx, authored as declarative $expression JSON",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/jxsuite/jx.git",
+    "directory": "packages/formulas"
+  },
+  "files": [
+    "src/",
+    "formulas/"
+  ],
+  "type": "module",
+  "exports": {
+    ".": "./src/index.ts",
+    "./catalog": "./src/catalog.ts"
+  },
+  "publishConfig": {
+    "provenance": false
+  },
+  "scripts": {
+    "generate": "bun run bin/generate.ts",
+    "test": "bun test --isolate"
+  },
+  "dependencies": {
+    "@jxsuite/schema": "workspace:^"
+  },
+  "devDependencies": {
+    "@jxsuite/runtime": "workspace:^"
+  }
+}

package/src/catalog.ts

@@ -0,0 +1,537 @@
+/**
+ * GENERATED by bin/generate.ts — do not edit. Regenerate with `bun run generate`.
+ *
+ * Every entry is a named formula (spec §19.4c): a pure $expression body over $args/<name>
+ * parameters, verified against the blessed operator and global sets at generation time.
+ */
+
+import type { CemParameter, JxExpressionNode } from "@jxsuite/schema/types";
+
+export interface FormulaCatalogEntry {
+  name: string;
+  description: string;
+  parameters: (string | CemParameter)[];
+  expression: JxExpressionNode;
+}
+
+export const catalog: FormulaCatalogEntry[] = [
+  {
+    description: "Arithmetic mean of an array of numbers; 0 for an empty array.",
+    expression: {
+      operator: "?:",
+      target: {
+        $ref: "$args/values/length",
+      },
+      value: {
+        operator: "/",
+        target: {
+          operator: "reduce",
+          target: {
+            $ref: "$args/values",
+          },
+          initial: 0,
+          value: {
+            operator: "+",
+            target: {
+              $ref: "$reduce/acc",
+            },
+            value: {
+              $ref: "$map/item",
+            },
+          },
+        },
+        value: {
+          $ref: "$args/values/length",
+        },
+      },
+      initial: 0,
+    },
+    name: "average",
+    parameters: [
+      {
+        name: "values",
+        type: {
+          text: "number[]",
+        },
+      },
+    ],
+  },
+  {
+    description:
+      "Uppercase the first character of a string, leaving the rest unchanged (the CSS text-transform: capitalize shape for a single word).",
+    expression: {
+      operator: "+",
+      target: {
+        operator: "toUpperCase",
+        target: {
+          operator: "charAt",
+          target: {
+            $ref: "$args/text",
+          },
+          value: 0,
+        },
+      },
+      value: {
+        operator: "slice",
+        target: {
+          $ref: "$args/text",
+        },
+        value: 1,
+      },
+    },
+    name: "capitalize",
+    parameters: [
+      {
+        name: "text",
+        type: {
+          text: "string",
+        },
+      },
+    ],
+  },
+  {
+    description:
+      "Bound a number to the [min, max] range (the TC39 Math.clamp shape): returns min when below, max when above, the value itself otherwise.",
+    expression: {
+      operator: "call",
+      target: {
+        $ref: "window#/Math/min",
+      },
+      value: [
+        {
+          operator: "call",
+          target: {
+            $ref: "window#/Math/max",
+          },
+          value: [
+            {
+              $ref: "$args/value",
+            },
+            {
+              $ref: "$args/min",
+            },
+          ],
+        },
+        {
+          $ref: "$args/max",
+        },
+      ],
+    },
+    name: "clamp",
+    parameters: [
+      {
+        name: "value",
+        type: {
+          text: "number",
+        },
+      },
+      {
+        name: "min",
+        type: {
+          text: "number",
+        },
+      },
+      {
+        name: "max",
+        type: {
+          text: "number",
+        },
+      },
+    ],
+  },
+  {
+    description:
+      "A copy of an array with the falsy elements removed (Array.prototype.filter on truthiness).",
+    expression: {
+      operator: "filter",
+      target: {
+        $ref: "$args/values",
+      },
+      value: {
+        operator: "!",
+        target: {
+          operator: "!",
+          target: {
+            $ref: "$map/item",
+          },
+        },
+      },
+    },
+    name: "compact",
+    parameters: [
+      {
+        name: "values",
+        type: {
+          text: "unknown[]",
+        },
+      },
+    ],
+  },
+  {
+    description: "The length of an array or string, or 0 when the value is missing.",
+    expression: {
+      operator: "??",
+      target: {
+        $ref: "$args/values/length",
+      },
+      value: 0,
+    },
+    name: "count",
+    parameters: [
+      {
+        name: "values",
+        type: {
+          text: "unknown[] | string",
+        },
+      },
+    ],
+  },
+  {
+    description: "The first element of an array (index 0), or null when empty.",
+    expression: {
+      operator: "??",
+      target: {
+        $ref: "$args/values/0",
+      },
+      value: null,
+    },
+    name: "first",
+    parameters: [
+      {
+        name: "values",
+        type: {
+          text: "unknown[]",
+        },
+      },
+    ],
+  },
+  {
+    description:
+      'The uppercase first letters of each whitespace-separated word, joined (e.g. "ada lovelace" → "AL").',
+    expression: {
+      operator: "join",
+      target: {
+        operator: "map",
+        target: {
+          operator: "split",
+          target: {
+            $ref: "$args/name",
+          },
+          value: " ",
+        },
+        value: {
+          operator: "toUpperCase",
+          target: {
+            operator: "charAt",
+            target: {
+              $ref: "$map/item",
+            },
+            value: 0,
+          },
+        },
+      },
+      value: "",
+    },
+    name: "initials",
+    parameters: [
+      {
+        name: "name",
+        type: {
+          text: "string",
+        },
+      },
+    ],
+  },
+  {
+    description:
+      "True when an array or string has no elements (length 0 — a missing value counts as empty).",
+    expression: {
+      operator: "===",
+      target: {
+        operator: "??",
+        target: {
+          $ref: "$args/value/length",
+        },
+        value: 0,
+      },
+      value: 0,
+    },
+    name: "isEmpty",
+    parameters: [
+      {
+        name: "value",
+        type: {
+          text: "unknown[] | string",
+        },
+      },
+    ],
+  },
+  {
+    description: "The last element of an array (Array.prototype.at(-1)), or undefined when empty.",
+    expression: {
+      operator: "at",
+      target: {
+        $ref: "$args/values",
+      },
+      value: -1,
+    },
+    name: "last",
+    parameters: [
+      {
+        name: "values",
+        type: {
+          text: "unknown[]",
+        },
+      },
+    ],
+  },
+  {
+    description:
+      "The largest number in an array (Math.max folded over the values); undefined for an empty array.",
+    expression: {
+      operator: "reduce",
+      target: {
+        $ref: "$args/values",
+      },
+      initial: {
+        $ref: "$args/values/0",
+      },
+      value: {
+        operator: "call",
+        target: {
+          $ref: "window#/Math/max",
+        },
+        value: [
+          {
+            $ref: "$reduce/acc",
+          },
+          {
+            $ref: "$map/item",
+          },
+        ],
+      },
+    },
+    name: "max",
+    parameters: [
+      {
+        name: "values",
+        type: {
+          text: "number[]",
+        },
+      },
+    ],
+  },
+  {
+    description:
+      "The smallest number in an array (Math.min folded over the values); undefined for an empty array.",
+    expression: {
+      operator: "reduce",
+      target: {
+        $ref: "$args/values",
+      },
+      initial: {
+        $ref: "$args/values/0",
+      },
+      value: {
+        operator: "call",
+        target: {
+          $ref: "window#/Math/min",
+        },
+        value: [
+          {
+            $ref: "$reduce/acc",
+          },
+          {
+            $ref: "$map/item",
+          },
+        ],
+      },
+    },
+    name: "min",
+    parameters: [
+      {
+        name: "values",
+        type: {
+          text: "number[]",
+        },
+      },
+    ],
+  },
+  {
+    description: "part / whole as a percentage (0 when the whole is 0 or missing).",
+    expression: {
+      operator: "?:",
+      target: {
+        $ref: "$args/whole",
+      },
+      value: {
+        operator: "*",
+        target: {
+          operator: "/",
+          target: {
+            $ref: "$args/part",
+          },
+          value: {
+            $ref: "$args/whole",
+          },
+        },
+        value: 100,
+      },
+      initial: 0,
+    },
+    name: "percent",
+    parameters: [
+      {
+        name: "part",
+        type: {
+          text: "number",
+        },
+      },
+      {
+        name: "whole",
+        type: {
+          text: "number",
+        },
+      },
+    ],
+  },
+  {
+    description:
+      "Round a number to the given decimal places (Math.round against a Math.pow(10, digits) scale).",
+    expression: {
+      operator: "/",
+      target: {
+        operator: "call",
+        target: {
+          $ref: "window#/Math/round",
+        },
+        value: [
+          {
+            operator: "*",
+            target: {
+              $ref: "$args/value",
+            },
+            value: {
+              operator: "call",
+              target: {
+                $ref: "window#/Math/pow",
+              },
+              value: [
+                10,
+                {
+                  $ref: "$args/digits",
+                },
+              ],
+            },
+          },
+        ],
+      },
+      value: {
+        operator: "call",
+        target: {
+          $ref: "window#/Math/pow",
+        },
+        value: [
+          10,
+          {
+            $ref: "$args/digits",
+          },
+        ],
+      },
+    },
+    name: "roundTo",
+    parameters: [
+      {
+        name: "value",
+        type: {
+          text: "number",
+        },
+      },
+      {
+        name: "digits",
+        type: {
+          text: "number",
+        },
+        default: 0,
+      },
+    ],
+  },
+  {
+    description: "Add every number in an array (Array.prototype.reduce with +, seeded at 0).",
+    expression: {
+      operator: "reduce",
+      target: {
+        $ref: "$args/values",
+      },
+      initial: 0,
+      value: {
+        operator: "+",
+        target: {
+          $ref: "$reduce/acc",
+        },
+        value: {
+          $ref: "$map/item",
+        },
+      },
+    },
+    name: "sum",
+    parameters: [
+      {
+        name: "values",
+        type: {
+          text: "number[]",
+        },
+      },
+    ],
+  },
+  {
+    description:
+      "Shorten a string to at most the given length, appending a horizontal ellipsis when cut.",
+    expression: {
+      operator: "?:",
+      target: {
+        operator: ">",
+        target: {
+          $ref: "$args/text/length",
+        },
+        value: {
+          $ref: "$args/length",
+        },
+      },
+      value: {
+        operator: "+",
+        target: {
+          operator: "slice",
+          target: {
+            $ref: "$args/text",
+          },
+          value: [
+            0,
+            {
+              $ref: "$args/length",
+            },
+          ],
+        },
+        value: "…",
+      },
+      initial: {
+        $ref: "$args/text",
+      },
+    },
+    name: "truncate",
+    parameters: [
+      {
+        name: "text",
+        type: {
+          text: "string",
+        },
+      },
+      {
+        name: "length",
+        type: {
+          text: "number",
+        },
+      },
+    ],
+  },
+] as unknown as FormulaCatalogEntry[];

package/src/index.ts

@@ -0,0 +1,29 @@
+/**
+ * The `jxsuite formulas` package — composite pure formulas, authored as declarative $expression
+ * JSON.
+ *
+ * Each catalog entry is a named formula (spec §19.4c): a pure body over $args/<name> parameters
+ * built from blessed operators, pure standard-library methods (§19.4d), and blessed globals.
+ * `formulaEntries()` returns them as ready-to-merge `state` entries — drop them into a document or
+ * project `state` and invoke via the `call` operator.
+ */
+
+import { catalog } from "./catalog.ts";
+
+import type { JxExpressionDef } from "@jxsuite/schema/types";
+
+export { catalog } from "./catalog.ts";
+export type { FormulaCatalogEntry } from "./catalog.ts";
+
+/** The catalog as named-formula state entries, keyed by formula name. */
+export function formulaEntries(): Record<string, JxExpressionDef> {
+  const entries: Record<string, JxExpressionDef> = {};
+  for (const formula of catalog) {
+    entries[formula.name] = {
+      $description: formula.description,
+      $expression: formula.expression,
+      parameters: formula.parameters,
+    };
+  }
+  return entries;
+}