runmat 0.3.6 → 0.4.1

package/dist/generated/builtins/isscalar.js

@@ -0,0 +1,162 @@
+// @generated by scripts/generate-builtins.cjs
+// Do not edit by hand.
+const builtinDoc = {
+    "title": "isscalar",
+    "category": "array/introspection",
+    "keywords": [
+        "isscalar",
+        "scalar",
+        "metadata query",
+        "gpu",
+        "logical"
+    ],
+    "summary": "Return true when a value has exactly one element and unit dimensions.",
+    "references": [],
+    "gpu_support": {
+        "elementwise": false,
+        "reduction": false,
+        "precisions": [],
+        "broadcasting": "none",
+        "notes": "Inspects tensor metadata on GPU handles; gathers only when metadata is missing."
+    },
+    "fusion": {
+        "elementwise": false,
+        "reduction": false,
+        "max_inputs": 0,
+        "constants": "inline"
+    },
+    "requires_feature": null,
+    "tested": {
+        "unit": "builtins::array::introspection::isscalar::tests",
+        "integration": "builtins::array::introspection::isscalar::tests::isscalar_gpu_tensor_checks_dimensions"
+    },
+    "description": "`isscalar(A)` returns logical `true` when an input has exactly one element and every visible dimension equals one. The builtin mirrors MATLAB behaviour across numeric values, logical arrays, strings, character arrays, cells, structs, GPU tensors, and handle-like values.",
+    "behaviors": [
+        "`isscalar` is true if and only if `numel(A) == 1` **and** every entry of `size(A)` equals `1`.",
+        "Numeric, logical, and complex scalars (`42`, `true`, `3+4i`) satisfy both conditions.",
+        "Row, column, or higher-dimensional vectors (e.g. `[1 2 3]`, `zeros(2,1)`) are not scalar because at least one dimension exceeds one.",
+        "String scalars (`\"hello\"`, `\"\"`) are scalar because they are `1×1` string arrays. Character arrays must be `1×1` to count as scalar—`'h'` is scalar, while `'runmat'` (`1×6`) is not.",
+        "Cell arrays, structs, objects, and handle objects are scalar when their MATLAB dimensions are `1×1`, regardless of the contents they wrap.",
+        "Empty arrays (`[]`, `cell(0,1)`, strings of size `0×1`) are **not** scalar because they contain zero elements even if some dimensions equal one.",
+        "GPU tensors rely on the shape metadata stored in their `GpuTensorHandle`. If a provider omits that metadata, RunMat gathers once to confirm the dimensions before answering."
+    ],
+    "examples": [
+        {
+            "description": "Checking if a numeric value is scalar",
+            "input": "tf = isscalar(42)",
+            "output": "tf = logical(1)"
+        },
+        {
+            "description": "Detecting that a row vector is not scalar",
+            "input": "tf = isscalar([1 2 3])",
+            "output": "tf = logical(0)"
+        },
+        {
+            "description": "Verifying scalar status of string vs char arrays",
+            "input": "tf_string = isscalar(\"hello\");\ntf_char = isscalar('h');\ntf_char_row = isscalar('runmat')",
+            "output": "tf_string = logical(1)\ntf_char = logical(1)\ntf_char_row = logical(0)"
+        },
+        {
+            "description": "Identifying that an empty array is not scalar",
+            "input": "tf_empty = isscalar([])",
+            "output": "tf_empty = logical(0)"
+        },
+        {
+            "description": "Confirming that single-element cell arrays are scalar",
+            "input": "C = {pi};\ntf_cell = isscalar(C)",
+            "output": "tf_cell = logical(1)"
+        },
+        {
+            "description": "Inspecting a GPU-resident tensor",
+            "input": "G = gpuArray(ones(1,1));\ntf_gpu = isscalar(G)",
+            "output": "tf_gpu = logical(1)"
+        }
+    ],
+    "faqs": [
+        {
+            "question": "Does `isscalar([])` return true?",
+            "answer": "No. Empty arrays contain zero elements, so `isscalar([])` returns `false`."
+        },
+        {
+            "question": "Are string scalars considered scalar even when the text is empty?",
+            "answer": "Yes. A string scalar is a `1×1` array regardless of its text, so `isscalar(\"\")` returns `true`."
+        },
+        {
+            "question": "How does `isscalar` treat GPU arrays?",
+            "answer": "It checks the metadata exposed by the `GpuTensorHandle`. If the provider omits shape metadata, RunMat downloads the tensor once to obtain it and then answers on the host."
+        },
+        {
+            "question": "What about objects or structs?",
+            "answer": "Objects and structs are scalar when their array dimensions are `1×1`. The contents do not affect the result."
+        },
+        {
+            "question": "Is a 1-by-1-by-1 array scalar?",
+            "answer": "Yes. Any array whose `numel` equals 1 and whose dimensions are all ones is considered scalar."
+        },
+        {
+            "question": "Do character arrays behave differently from strings?",
+            "answer": "Yes. Character arrays reflect their matrix dimensions. `'abc'` is `1×3`, so `isscalar('abc')` returns `false`."
+        },
+        {
+            "question": "Will `isscalar` trigger GPU computation?",
+            "answer": "No. It is a metadata query and never launches GPU kernels. At most it might gather data when metadata is unavailable."
+        },
+        {
+            "question": "Can I rely on `isscalar` inside fused expressions?",
+            "answer": "Yes. The builtin returns a host logical scalar and the fusion planner treats it as a metadata operation."
+        }
+    ],
+    "links": [
+        {
+            "label": "isempty",
+            "url": "./isempty"
+        },
+        {
+            "label": "numel",
+            "url": "./numel"
+        },
+        {
+            "label": "size",
+            "url": "./size"
+        },
+        {
+            "label": "gpuArray",
+            "url": "./gpuarray"
+        },
+        {
+            "label": "gather",
+            "url": "./gather"
+        },
+        {
+            "label": "ismatrix",
+            "url": "./ismatrix"
+        },
+        {
+            "label": "isvector",
+            "url": "./isvector"
+        },
+        {
+            "label": "length",
+            "url": "./length"
+        },
+        {
+            "label": "ndims",
+            "url": "./ndims"
+        }
+    ],
+    "source": {
+        "label": "`crates/runmat-runtime/src/builtins/array/introspection/isscalar.rs`",
+        "url": "https://github.com/runmat-org/runmat/blob/main/crates/runmat-runtime/src/builtins/array/introspection/isscalar.rs"
+    },
+    "gpu_behavior": [
+        "`isscalar` never launches GPU kernels. For `gpuArray` inputs the builtin first inspects the shape stored in the `GpuTensorHandle`. When the active acceleration provider omits that metadata, RunMat performs a single gather to compute `numel` and dimensions on the host. The builtin always returns a host logical scalar, so fusion planning treats it as a metadata query instead of a device-side kernel."
+    ],
+    "key": "isscalar",
+    "slug": "isscalar",
+    "categoryPath": [
+        "array",
+        "introspection"
+    ]
+};
+export default builtinDoc;
+//# sourceMappingURL=isscalar.js.map

package/dist/generated/builtins/isscalar.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"isscalar.js","sourceRoot":"","sources":["../../../src/generated/builtins/isscalar.ts"],"names":[],"mappings":"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"}

package/dist/generated/builtins/issorted.d.ts

@@ -0,0 +1,4 @@
+import type { BuiltinDoc } from "../../builtins.js";
+declare const builtinDoc: BuiltinDoc;
+export default builtinDoc;
+//# sourceMappingURL=issorted.d.ts.map

package/dist/generated/builtins/issorted.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"issorted.d.ts","sourceRoot":"","sources":["../../../src/generated/builtins/issorted.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AAEpD,QAAA,MAAM,UAAU,EAAE,UA8KjB,CAAC;AAEF,eAAe,UAAU,CAAC"}

package/dist/generated/builtins/issorted.js

@@ -0,0 +1,179 @@
+// @generated by scripts/generate-builtins.cjs
+// Do not edit by hand.
+const builtinDoc = {
+    "title": "issorted",
+    "category": "array/sorting_sets",
+    "keywords": [
+        "issorted",
+        "sorted",
+        "monotonic",
+        "strictascend",
+        "rows",
+        "comparisonmethod",
+        "missingplacement"
+    ],
+    "summary": "Determine whether an array is already sorted along a dimension or across rows.",
+    "references": [
+        "https://www.mathworks.com/help/matlab/ref/double.issorted.html"
+    ],
+    "gpu_support": {
+        "elementwise": false,
+        "reduction": false,
+        "precisions": [
+            "f32",
+            "f64"
+        ],
+        "broadcasting": "none",
+        "notes": "GPU inputs are gathered to the host while providers gain native predicate support."
+    },
+    "fusion": {
+        "elementwise": false,
+        "reduction": false,
+        "max_inputs": 1,
+        "constants": "inline"
+    },
+    "requires_feature": null,
+    "tested": {
+        "unit": "builtins::array::sorting_sets::issorted::tests",
+        "integration": "builtins::array::sorting_sets::issorted::tests::issorted_gpu_roundtrip"
+    },
+    "description": "`issorted(A)` checks whether the elements of `A` already appear in sorted order. You can examine a specific dimension, enforce strict monotonicity, require descending order, and control how missing values are positioned. The function also supports row-wise checks that match `issorted(A,'rows')` from MATLAB.",
+    "behaviors": [
+        "`issorted(A)` examines the first non-singleton dimension and returns a logical scalar.",
+        "`issorted(A, dim)` selects the dimension explicitly (1-based).",
+        "Direction flags include `'ascend'`, `'descend'`, `'monotonic'`, `'strictascend'`, `'strictdescend'`, and `'strictmonotonic'`.",
+        "Name-value options mirror MATLAB:",
+        "`'MissingPlacement'` accepts `'auto'`, `'first'`, or `'last'`.",
+        "`'ComparisonMethod'` accepts `'auto'`, `'real'`, or `'abs'` for numeric and complex data.",
+        "`issorted(A,'rows', ...)` verifies lexicographic ordering of rows.",
+        "Logical and character arrays are promoted to double precision for comparison; string arrays are compared lexicographically, recognising the literal `<missing>` token as a missing element.",
+        "Empty arrays, scalars, and singleton dimensions are always reported as sorted."
+    ],
+    "examples": [
+        {
+            "description": "Checking an ascending vector",
+            "input": "A = [5 12 33 39 78 90 95 107];\ntf = issorted(A)",
+            "output": "tf =\n     1"
+        },
+        {
+            "description": "Verifying strict increase",
+            "input": "B = [1 1 2 3];\ntf = issorted(B, 'strictascend')",
+            "output": "tf =\n     0"
+        },
+        {
+            "description": "Using a specific dimension",
+            "input": "C = [1 4 2; 3 6 5];\ntf = issorted(C, 2, 'descend')",
+            "output": "tf =\n     0"
+        },
+        {
+            "description": "Allowing either ascending or descending order",
+            "input": "D = [10 8 8 5 1];\ntf = issorted(D, 'monotonic')",
+            "output": "tf =\n     1"
+        },
+        {
+            "description": "Controlling missing placements",
+            "input": "E = [NaN NaN 4 7];\ntf = issorted(E, 'MissingPlacement', 'first')",
+            "output": "tf =\n     0"
+        },
+        {
+            "description": "Comparing complex data by magnitude",
+            "input": "Z = [1+1i, 2+3i, 4+0i];\ntf = issorted(Z, 'ComparisonMethod', 'abs')",
+            "output": "tf =\n     1"
+        },
+        {
+            "description": "Checking row order",
+            "input": "R = [1 2 3; 1 2 4; 2 0 1];\ntf = issorted(R, 'rows')",
+            "output": "tf =\n     1"
+        },
+        {
+            "description": "Working with string arrays",
+            "input": "str = [ \"apple\" \"banana\"; \"apple\" \"carrot\" ];\ntf = issorted(str, 2)",
+            "output": "tf =\n     0"
+        }
+    ],
+    "faqs": [
+        {
+            "question": "Does `issorted` modify its input?",
+            "answer": "No. The function inspects the data in-place and returns a logical scalar."
+        },
+        {
+            "question": "What is the difference between `'ascend'` and `'strictascend'`?",
+            "answer": "`'ascend'` allows consecutive equal values, while `'strictascend'` requires every element to be strictly greater than its predecessor and rejects missing values."
+        },
+        {
+            "question": "How does `'monotonic'` work?",
+            "answer": "`'monotonic'` succeeds when the data is entirely non-decreasing *or* non-increasing. Use `'strictmonotonic'` to forbid repeated or missing values."
+        },
+        {
+            "question": "Can I control where NaN values appear?",
+            "answer": "Yes. `'MissingPlacement','first'` requires missing values to precede finite ones, `'last'` requires them to trail, and `'auto'` follows MATLAB’s default (end for ascending checks, start for descending)."
+        },
+        {
+            "question": "Is `'ComparisonMethod'` relevant for real data?",
+            "answer": "For real data `'auto'` and `'real'` are identical. `'abs'` compares magnitudes first and breaks ties using the signed value, matching MATLAB."
+        },
+        {
+            "question": "Does the function support GPU arrays?",
+            "answer": "Yes. GPU inputs are gathered automatically and the result is computed on the host to guarantee correctness until dedicated provider hooks are available."
+        },
+        {
+            "question": "How are string arrays treated?",
+            "answer": "Strings are compared lexicographically using Unicode code-point order. The literal `<missing>` is treated as a missing value so `'MissingPlacement'` rules apply."
+        },
+        {
+            "question": "What about empty arrays or dimensions of length 0?",
+            "answer": "Empty slices are considered sorted. Passing a dimension larger than `ndims(A)` also returns `true`."
+        }
+    ],
+    "links": [
+        {
+            "label": "sort",
+            "url": "./sort"
+        },
+        {
+            "label": "sortrows",
+            "url": "./sortrows"
+        },
+        {
+            "label": "unique",
+            "url": "./unique"
+        },
+        {
+            "label": "argsort",
+            "url": "./argsort"
+        },
+        {
+            "label": "intersect",
+            "url": "./intersect"
+        },
+        {
+            "label": "ismember",
+            "url": "./ismember"
+        },
+        {
+            "label": "setdiff",
+            "url": "./setdiff"
+        },
+        {
+            "label": "union",
+            "url": "./union"
+        }
+    ],
+    "source": {
+        "label": "`crates/runmat-runtime/src/builtins/array/sorting_sets/issorted.rs`",
+        "url": "https://github.com/runmat-org/runmat/blob/main/crates/runmat-runtime/src/builtins/array/sorting_sets/issorted.rs"
+    },
+    "gpu_behavior": [
+        "`issorted` is registered as a sink builtin. When the input tensor lives on the GPU the runtime gathers it to host memory and performs the check there, guaranteeing MATLAB-compatible semantics.",
+        "Future providers may implement a predicate hook so that simple monotonic checks can execute entirely on device. Until then the behaviour is identical for CPU and GPU arrays.",
+        "The result is a logical scalar (`true` or `false`) regardless of input residency."
+    ],
+    "key": "issorted",
+    "slug": "issorted",
+    "categoryPath": [
+        "array",
+        "sorting_sets"
+    ]
+};
+export default builtinDoc;
+//# sourceMappingURL=issorted.js.map

package/dist/generated/builtins/issorted.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"issorted.js","sourceRoot":"","sources":["../../../src/generated/builtins/issorted.ts"],"names":[],"mappings":"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"}

package/dist/generated/builtins/isstring.d.ts

@@ -0,0 +1,4 @@
+import type { BuiltinDoc } from "../../builtins.js";
+declare const builtinDoc: BuiltinDoc;
+export default builtinDoc;
+//# sourceMappingURL=isstring.d.ts.map

package/dist/generated/builtins/isstring.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"isstring.d.ts","sourceRoot":"","sources":["../../../src/generated/builtins/isstring.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AAEpD,QAAA,MAAM,UAAU,EAAE,UAwJjB,CAAC;AAEF,eAAe,UAAU,CAAC"}

package/dist/generated/builtins/isstring.js

@@ -0,0 +1,157 @@
+// @generated by scripts/generate-builtins.cjs
+// Do not edit by hand.
+const builtinDoc = {
+    "title": "isstring",
+    "category": "introspection",
+    "keywords": [
+        "isstring",
+        "string array",
+        "type checking",
+        "string scalar",
+        "logical predicate",
+        "gpuArray"
+    ],
+    "summary": "Return true when a value is a MATLAB string array (including string scalars).",
+    "references": [
+        "https://www.mathworks.com/help/matlab/ref/isstring.html"
+    ],
+    "gpu_support": {
+        "elementwise": false,
+        "reduction": false,
+        "precisions": [],
+        "broadcasting": "none",
+        "notes": "Inspects metadata on the host; gpuArray inputs are classified without kernel launches."
+    },
+    "fusion": {
+        "elementwise": false,
+        "reduction": false,
+        "max_inputs": 1,
+        "constants": "inline"
+    },
+    "requires_feature": null,
+    "tested": {
+        "unit": "builtins::introspection::isstring::tests",
+        "integration": "builtins::introspection::isstring::tests::isstring_gpu_inputs_return_false"
+    },
+    "description": "`tf = isstring(x)` returns a logical scalar `true` when `x` is a MATLAB string array (including string scalars and empty string arrays) and logical `false` otherwise. Use it when you need to validate arguments, branch on string support, or distinguish strings from other text representations.",
+    "behaviors": [
+        "String scalars such as `\"RunMat\"` and string arrays like `[\"alpha\", \"beta\"]` both return `logical(1)`.",
+        "Empty string arrays produced by `strings(0)` or `string.empty(...)` are still recognised as the string type, so they return `logical(1)`.",
+        "Character arrays created with single quotes (`'text'`), cell arrays of character vectors, numeric tensors, logical masks, structs, tables, and other non-string containers return `logical(0)`.",
+        "gpuArray inputs currently store numeric or logical tensors in RunMat, so `isstring(gpuArray(...))` returns `logical(0)`, matching MATLAB’s behaviour.",
+        "The result is always a host logical scalar, making it easy to use for argument validation, control-flow guards, or input parsing."
+    ],
+    "examples": [
+        {
+            "description": "Checking if a string scalar is recognised",
+            "input": "tf = isstring(\"RunMat\")",
+            "output": "tf = logical(1)"
+        },
+        {
+            "description": "Detecting string arrays with multiple elements",
+            "input": "values = [\"alpha\", \"beta\", \"gamma\"];\ntf = isstring(values)",
+            "output": "tf = logical(1)"
+        },
+        {
+            "description": "Distinguishing strings from character vectors",
+            "input": "tf_string = isstring(\"hello\");\ntf_char   = isstring('hello')",
+            "output": "tf_string = logical(1)\ntf_char   = logical(0)"
+        },
+        {
+            "description": "Confirming that empty string arrays are still strings",
+            "input": "emptyStrs = strings(0, 2);\ntf = isstring(emptyStrs)",
+            "output": "tf = logical(1)"
+        },
+        {
+            "description": "Recognising that numeric and logical arrays are not strings",
+            "input": "numbers = [1 2 3];\nmask = true(1, 3);\ntf_numbers = isstring(numbers);\ntf_mask = isstring(mask)",
+            "output": "tf_numbers = logical(0)\ntf_mask = logical(0)"
+        },
+        {
+            "description": "Validating cell arrays of character vectors",
+            "input": "cells = {'a', 'b', 'c'};\ntf = isstring(cells)",
+            "output": "tf = logical(0)"
+        },
+        {
+            "description": "Inspecting gpuArray inputs without transfers",
+            "input": "G = gpuArray(ones(2, 2));\ntf = isstring(G)",
+            "output": "tf = logical(0)"
+        },
+        {
+            "description": "Using `isstring` in argument validation",
+            "input": "function greet(name)\n    if ~isstring(name)\n        error(\"Name must be provided as a string.\");\n    end\n    disp(\"Hello \" + name + \"!\");\nend\n\ngreet(\"RunMat\");\n% greet(42); % throws \"Name must be provided as a string.\"",
+            "output": "Hello RunMat!"
+        }
+    ],
+    "faqs": [
+        {
+            "question": "Does `isstring` return true for empty string arrays?",
+            "answer": "Yes. Empty string arrays are still of type string, so `isstring(strings(0))` returns `logical(1)`."
+        },
+        {
+            "question": "How is `isstring` different from `ischar`?",
+            "answer": "`isstring` recognises MATLAB’s modern string type introduced in R2016b. `ischar` recognises legacy character arrays created with single quotes. Only `isstring` returns `true` for double-quoted values."
+        },
+        {
+            "question": "What about string arrays stored inside cell arrays?",
+            "answer": "Cell arrays are containers, so `isstring({'a', 'b'})` returns `logical(0)`. Use `iscellstr` or `all(isstring(cells))` to validate the contents instead."
+        },
+        {
+            "question": "Can gpuArray hold string data in RunMat?",
+            "answer": "Not currently. gpuArray values hold numeric or logical tensors, so `isstring` always reports `logical(0)` for device-resident data."
+        },
+        {
+            "question": "Does `isstring` inspect array contents element by element?",
+            "answer": "No. It only checks the value’s type metadata, so the cost is constant regardless of array size."
+        }
+    ],
+    "links": [
+        {
+            "label": "ischar",
+            "url": "./ischar"
+        },
+        {
+            "label": "isa",
+            "url": "./isa"
+        },
+        {
+            "label": "string",
+            "url": "./string"
+        },
+        {
+            "label": "gpuArray",
+            "url": "./gpuarray"
+        },
+        {
+            "label": "class",
+            "url": "./class"
+        },
+        {
+            "label": "which",
+            "url": "./which"
+        },
+        {
+            "label": "who",
+            "url": "./who"
+        },
+        {
+            "label": "whos",
+            "url": "./whos"
+        }
+    ],
+    "source": {
+        "label": "`crates/runmat-runtime/src/builtins/introspection/isstring.rs`",
+        "url": "https://github.com/runmat-org/runmat/blob/main/crates/runmat-runtime/src/builtins/introspection/isstring.rs"
+    },
+    "gpu_residency": "You usually do NOT need to call `gpuArray` yourself in RunMat (unlike MATLAB).\n\nIn RunMat, the fusion planner keeps residency on GPU in branches of fused expressions. As such, calling `isstring` on a gpuArray result leaves the device allocation untouched while still answering the question using metadata only.\n\nTo preserve backwards compatibility with MathWorks MATLAB, and for when you want to explicitly bootstrap GPU residency, you can call `gpuArray` explicitly to move data to the GPU if you want to be explicit about the residency.\n\nSince MathWorks MATLAB does not have a fusion planner, and they kept their parallel execution toolbox separate from the core language, as their toolbox is a separate commercial product, MathWorks MATLAB users need to call `gpuArray` to move data to the GPU manually whereas RunMat users can rely on the fusion planner to keep data on the GPU automatically.",
+    "gpu_behavior": [
+        "`isstring` runs entirely from metadata. When you pass a gpuArray, RunMat inspects the handle and returns `logical(0)` because device buffers do not yet store string data. No kernels are launched, and no host↔device transfers occur, so the device allocation remains resident for subsequent operations."
+    ],
+    "key": "isstring",
+    "slug": "isstring",
+    "categoryPath": [
+        "introspection"
+    ]
+};
+export default builtinDoc;
+//# sourceMappingURL=isstring.js.map

package/dist/generated/builtins/isstring.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"isstring.js","sourceRoot":"","sources":["../../../src/generated/builtins/isstring.ts"],"names":[],"mappings":"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"}

package/dist/generated/builtins/issymmetric.d.ts

@@ -0,0 +1,4 @@
+import type { BuiltinDoc } from "../../builtins.js";
+declare const builtinDoc: BuiltinDoc;
+export default builtinDoc;
+//# sourceMappingURL=issymmetric.d.ts.map

package/dist/generated/builtins/issymmetric.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"issymmetric.d.ts","sourceRoot":"","sources":["../../../src/generated/builtins/issymmetric.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AAEpD,QAAA,MAAM,UAAU,EAAE,UAiKjB,CAAC;AAEF,eAAe,UAAU,CAAC"}