runmat 0.3.6 → 0.4.0

package/dist/generated/builtins/squeeze.js

@@ -0,0 +1,216 @@
+// @generated by scripts/generate-builtins.cjs
+// Do not edit by hand.
+const builtinDoc = {
+    "title": "squeeze",
+    "category": "array/shape",
+    "keywords": [
+        "squeeze",
+        "singleton dimensions",
+        "array reshape",
+        "gpu"
+    ],
+    "summary": "Remove singleton (size-one) dimensions while preserving MATLAB vector semantics.",
+    "references": [],
+    "gpu_support": {
+        "elementwise": false,
+        "reduction": false,
+        "precisions": [
+            "f32",
+            "f64",
+            "i32",
+            "bool"
+        ],
+        "broadcasting": "none",
+        "notes": "Backends reuse the reshape hook to update device metadata; runtimes fall back to host metadata updates when unavailable."
+    },
+    "fusion": {
+        "elementwise": false,
+        "reduction": false,
+        "max_inputs": 1,
+        "constants": "inline"
+    },
+    "requires_feature": null,
+    "tested": {
+        "unit": "builtins::array::shape::squeeze::tests",
+        "integration": "builtins::array::shape::squeeze::tests::squeeze_gpu_roundtrip"
+    },
+    "description": "`squeeze(A)` removes singleton (dimension size equal to one) dimensions from `A`. The result keeps MATLAB's row/column vector semantics—2-D matrices stay 2-D, and higher-rank arrays collapse down until only meaningful axes remain.",
+    "behaviors": [
+        "Dimensions greater than two drop all size-one axes. If exactly one dimension remains, the output becomes an `N × 1` column vector.",
+        "Two-dimensional inputs (row/column vectors and matrices) are returned unchanged.",
+        "Zero-length dimensions are preserved; only length-one axes are removed.",
+        "Scalar values remain scalars.",
+        "GPU arrays stay resident on the device where possible; the runtime only gathers when it cannot infer the shape."
+    ],
+    "examples": [
+        {
+            "description": "Removing Singleton Dimensions from a 3-D Matrix",
+            "input": "A = reshape(1:12, [1, 3, 4]);\nB = squeeze(A);\nsize(B)",
+            "output": "ans = [3 4]"
+        },
+        {
+            "description": "Turning 1x1xN Slices into Column Vectors",
+            "input": "T = zeros(1, 1, 5);\nT(:, :, 3) = 7;\nvec = squeeze(T);\nsize(vec)",
+            "output": "ans = [5 1]"
+        },
+        {
+            "description": "Keeping Row Vectors Unchanged After Squeeze",
+            "input": "row = rand(1, 8);\nout = squeeze(row);\nsize(out)",
+            "output": "ans = [1 8]"
+        },
+        {
+            "description": "Squeezing Logical Masks from Simulations",
+            "input": "mask = false(1, 10, 1, 1);\nmask(1, 4, 1, 1) = true;\nflat = squeeze(mask)",
+            "output": "flat = [0 0 0 1 0 0 0 0 0 0]'"
+        },
+        {
+            "description": "Using Squeeze on GPU-Resident Data",
+            "input": "G = gpuArray(rand(1, 64, 1));\nH = squeeze(G);\nisgpuarray(H)",
+            "output": "ans = logical 1"
+        },
+        {
+            "description": "Squeezing String Arrays While Preserving Layout",
+            "input": "S = strings(1, 1, 3);\nS(1, 1, 1) = \"run\";\nS(1, 1, 2) = \"mat\";\nS(1, 1, 3) = \"gpu\";\nT = squeeze(S);\nsize(T)",
+            "output": "ans = [3 1]"
+        }
+    ],
+    "faqs": [
+        {
+            "question": "Why does `squeeze` keep 2-D matrices unchanged?",
+            "answer": "MATLAB treats row and column vectors as 2-D objects. Preserving those dimensions avoids turning row vectors into column vectors or scalars unintentionally."
+        },
+        {
+            "question": "What happens when every dimension is singleton?",
+            "answer": "The result becomes a `1 × 1` array. Scalars (e.g., plain doubles) remain scalars."
+        },
+        {
+            "question": "Does `squeeze` affect zero-length dimensions?",
+            "answer": "No. Only size-one dimensions are removed. Zero-length dimensions are preserved exactly."
+        },
+        {
+            "question": "Can I `squeeze` character or cell arrays?",
+            "answer": "Yes. They already store up to two dimensions in RunMat, so `squeeze` leaves them unchanged but still validates inputs."
+        },
+        {
+            "question": "How does `squeeze` interact with GPU tensors?",
+            "answer": "The runtime updates GPU tensor metadata via the provider's reshape hook. Data stays on the device unless a provider cannot report shape information, in which case RunMat gathers once to infer dimensions."
+        },
+        {
+            "question": "What if I need to remove a specific dimension?",
+            "answer": "Use `reshape`, `permute`, or indexing to reorganize axes manually before calling `squeeze`."
+        },
+        {
+            "question": "Does `squeeze` change data ordering?",
+            "answer": "No. It only alters metadata. Element order in memory remains unchanged."
+        },
+        {
+            "question": "Will `squeeze` ever increase the number of dimensions?",
+            "answer": "No. It either returns the same number or fewer. The only exception is padding with a trailing singleton to maintain MATLAB's column-vector convention when exactly one dimension remains."
+        },
+        {
+            "question": "Is `squeeze` safe to run before GPU fusion?",
+            "answer": "Yes. Since it only updates shapes, it integrates cleanly with fusion and does not impede kernel generation."
+        },
+        {
+            "question": "How do I undo a squeeze?",
+            "answer": "Use `reshape` with the original size vector (for example, captured via `size(A)`) to restore the previous dimension layout."
+        }
+    ],
+    "links": [
+        {
+            "label": "`reshape`",
+            "url": "./reshape"
+        },
+        {
+            "label": "`permute`",
+            "url": "./permute"
+        },
+        {
+            "label": "`ndims`",
+            "url": "./ndims"
+        },
+        {
+            "label": "`size`",
+            "url": "./size"
+        },
+        {
+            "label": "`gpuArray`",
+            "url": "./gpuarray"
+        },
+        {
+            "label": "`gather`",
+            "url": "./gather"
+        },
+        {
+            "label": "cat",
+            "url": "./cat"
+        },
+        {
+            "label": "circshift",
+            "url": "./circshift"
+        },
+        {
+            "label": "diag",
+            "url": "./diag"
+        },
+        {
+            "label": "flip",
+            "url": "./flip"
+        },
+        {
+            "label": "fliplr",
+            "url": "./fliplr"
+        },
+        {
+            "label": "flipud",
+            "url": "./flipud"
+        },
+        {
+            "label": "horzcat",
+            "url": "./horzcat"
+        },
+        {
+            "label": "ipermute",
+            "url": "./ipermute"
+        },
+        {
+            "label": "kron",
+            "url": "./kron"
+        },
+        {
+            "label": "repmat",
+            "url": "./repmat"
+        },
+        {
+            "label": "rot90",
+            "url": "./rot90"
+        },
+        {
+            "label": "tril",
+            "url": "./tril"
+        },
+        {
+            "label": "triu",
+            "url": "./triu"
+        },
+        {
+            "label": "vertcat",
+            "url": "./vertcat"
+        }
+    ],
+    "source": {
+        "label": "`crates/runmat-runtime/src/builtins/array/shape/squeeze.rs`",
+        "url": "https://github.com/runmat-org/runmat/blob/main/crates/runmat-runtime/src/builtins/array/shape/squeeze.rs"
+    },
+    "gpu_behavior": [
+        "When a GPU provider is active, RunMat calls the provider's `reshape` hook to update tensor metadata without copying data. Providers that do not override `reshape` fall back to the in-process behaviour, simply updating the handle shape locally. If a handle advertises no shape, RunMat downloads metadata once to infer dimensions before applying `squeeze`."
+    ],
+    "key": "squeeze",
+    "slug": "squeeze",
+    "categoryPath": [
+        "array",
+        "shape"
+    ]
+};
+export default builtinDoc;
+//# sourceMappingURL=squeeze.js.map

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

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

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

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

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

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

package/dist/generated/builtins/stairs.js

@@ -0,0 +1,89 @@
+// @generated by scripts/generate-builtins.cjs
+// Do not edit by hand.
+const builtinDoc = {
+    "title": "stairs",
+    "category": "plotting",
+    "keywords": [
+        "stairs",
+        "step plot",
+        "stair plot",
+        "sampled signal",
+        "matlab stairs"
+    ],
+    "summary": "Create step plots for sampled signals, piecewise-constant data, and MATLAB `stairs` workflows.",
+    "gpu_support": {
+        "elementwise": false,
+        "reduction": false,
+        "precisions": [
+            "single",
+            "double"
+        ],
+        "broadcasting": "none",
+        "notes": "`stairs` can use a direct GPU-backed geometry path when plotting-compatible buffers are available."
+    },
+    "fusion": {
+        "elementwise": false,
+        "reduction": false,
+        "max_inputs": 2,
+        "constants": "inline"
+    },
+    "requires_feature": null,
+    "tested": {
+        "unit": "builtins::plotting::stairs::tests"
+    },
+    "description": "`stairs` creates staircase-style line plots for sampled or piecewise-constant data. In RunMat it returns a plot handle, supports MATLAB `stairs(y)` and `stairs(x, y)` style workflows, and reuses the shared line/marker property model so step plots behave consistently with the rest of the plotting stack.",
+    "behaviors": [
+        "`stairs(y)` uses implicit x-values `1:n`, while `stairs(x, y)` uses explicit paired coordinates.",
+        "The returned value is a plot handle that works with `get` and `set`.",
+        "Marker styling and display names can be updated through the same handle/property system used by line plots.",
+        "Step-plot rendering is subplot-local and respects current axes state just like `plot` and `scatter`.",
+        "GPU-backed geometry is preferred when exported buffers and the shared plotting device are available."
+    ],
+    "examples": [
+        {
+            "description": "Plot a sampled staircase signal",
+            "input": "t = 0:5;\nstairs(t, cumsum([1 -1 2 -2 1 0]));"
+        },
+        {
+            "description": "Use MATLAB-style y-only shorthand",
+            "input": "stairs([3 1 4 1 5 9]);"
+        },
+        {
+            "description": "Style a stairs object and label it for the legend",
+            "input": "h = stairs(0:4, [1 2 2 3 5]);\nset(h, 'Color', 'm', 'LineWidth', 2, 'DisplayName', 'sampled signal');\nlegend;"
+        }
+    ],
+    "links": [
+        {
+            "label": "plot",
+            "url": "./plot"
+        },
+        {
+            "label": "stem",
+            "url": "./stem"
+        },
+        {
+            "label": "scatter",
+            "url": "./scatter"
+        },
+        {
+            "label": "legend",
+            "url": "./legend"
+        },
+        {
+            "label": "set",
+            "url": "./set"
+        }
+    ],
+    "source": {
+        "label": "`crates/runmat-runtime/src/builtins/plotting/ops/stairs.rs`",
+        "url": "https://github.com/runmat-org/runmat/blob/main/crates/runmat-runtime/src/builtins/plotting/ops/stairs.rs"
+    },
+    "key": "stairs",
+    "slug": "stairs",
+    "categoryPath": [
+        "plotting"
+    ]
+};
+export default builtinDoc;
+//# sourceMappingURL=stairs.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"stairs.js","sourceRoot":"","sources":["../../../src/generated/builtins/stairs.ts"],"names":[],"mappings":"AAAA,8CAA8C;AAC9C,uBAAuB;AAIvB,MAAM,UAAU,GAAe;IAC7B,OAAO,EAAE,QAAQ;IACjB,UAAU,EAAE,UAAU;IACtB,UAAU,EAAE;QACV,QAAQ;QACR,WAAW;QACX,YAAY;QACZ,gBAAgB;QAChB,eAAe;KAChB;IACD,SAAS,EAAE,gGAAgG;IAC3G,aAAa,EAAE;QACb,aAAa,EAAE,KAAK;QACpB,WAAW,EAAE,KAAK;QAClB,YAAY,EAAE;YACZ,QAAQ;YACR,QAAQ;SACT;QACD,cAAc,EAAE,MAAM;QACtB,OAAO,EAAE,oGAAoG;KAC9G;IACD,QAAQ,EAAE;QACR,aAAa,EAAE,KAAK;QACpB,WAAW,EAAE,KAAK;QAClB,YAAY,EAAE,CAAC;QACf,WAAW,EAAE,QAAQ;KACtB;IACD,kBAAkB,EAAE,IAAI;IACxB,QAAQ,EAAE;QACR,MAAM,EAAE,mCAAmC;KAC5C;IACD,aAAa,EAAE,iTAAiT;IAChU,WAAW,EAAE;QACX,kGAAkG;QAClG,sEAAsE;QACtE,6GAA6G;QAC7G,sGAAsG;QACtG,sGAAsG;KACvG;IACD,UAAU,EAAE;QACV;YACE,aAAa,EAAE,iCAAiC;YAChD,OAAO,EAAE,+CAA+C;SACzD;QACD;YACE,aAAa,EAAE,mCAAmC;YAClD,OAAO,EAAE,wBAAwB;SAClC;QACD;YACE,aAAa,EAAE,mDAAmD;YAClE,OAAO,EAAE,gHAAgH;SAC1H;KACF;IACD,OAAO,EAAE;QACP;YACE,OAAO,EAAE,MAAM;YACf,KAAK,EAAE,QAAQ;SAChB;QACD;YACE,OAAO,EAAE,MAAM;YACf,KAAK,EAAE,QAAQ;SAChB;QACD;YACE,OAAO,EAAE,SAAS;YAClB,KAAK,EAAE,WAAW;SACnB;QACD;YACE,OAAO,EAAE,QAAQ;YACjB,KAAK,EAAE,UAAU;SAClB;QACD;YACE,OAAO,EAAE,KAAK;YACd,KAAK,EAAE,OAAO;SACf;KACF;IACD,QAAQ,EAAE;QACR,OAAO,EAAE,6DAA6D;QACtE,KAAK,EAAE,0GAA0G;KAClH;IACD,KAAK,EAAE,QAAQ;IACf,MAAM,EAAE,QAAQ;IAChB,cAAc,EAAE;QACd,UAAU;KACX;CACF,CAAC;AAEF,eAAe,UAAU,CAAC"}

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

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

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

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

package/dist/generated/builtins/startsWith.js

@@ -0,0 +1,156 @@
+// @generated by scripts/generate-builtins.cjs
+// Do not edit by hand.
+const builtinDoc = {
+    "title": "startsWith",
+    "category": "strings/search",
+    "keywords": [
+        "startswith",
+        "prefix",
+        "string array",
+        "ignorecase",
+        "text search"
+    ],
+    "summary": "Check whether text inputs start with specific patterns using MATLAB-compatible broadcasting and case handling.",
+    "references": [
+        "https://www.mathworks.com/help/matlab/ref/startswith.html"
+    ],
+    "gpu_support": {
+        "elementwise": false,
+        "reduction": false,
+        "precisions": [],
+        "broadcasting": "matlab",
+        "notes": "Runs on the CPU; GPU-resident inputs are gathered automatically so behaviour matches MATLAB."
+    },
+    "fusion": {
+        "elementwise": false,
+        "reduction": false,
+        "max_inputs": 2,
+        "constants": "inline"
+    },
+    "requires_feature": null,
+    "tested": {
+        "unit": "builtins::strings::search::startswith::tests",
+        "integration": "builtins::strings::search::startswith::tests::startswith_cell_array_patterns"
+    },
+    "description": "`startsWith(str, pattern)` returns a logical result indicating whether each element of `str` begins with the corresponding text in `pattern`. The builtin supports string arrays, character vectors/arrays, and cell arrays of character vectors, mirroring MATLAB's implicit expansion semantics.",
+    "behaviors": [
+        "Accepts text inputs as string scalars/arrays, character vectors/arrays, or cell arrays of character vectors.",
+        "Accepts patterns in the same formats; scalar inputs expand across the other argument following MATLAB broadcast rules.",
+        "Missing strings (`<missing>`) never match any pattern.",
+        "Empty patterns (`\"\"` or `''`) always match non-missing text elements.",
+        "Patterns that are `<missing>` never match and therefore return `false`.",
+        "Character arrays treat each row as an independent element; zero-row character arrays yield empty outputs.",
+        "The optional `IgnoreCase` flag can be supplied either as a trailing scalar or via the `'IgnoreCase', value` name-value pair. It accepts logical/numeric scalars and the strings `'on'`, `'off'`, `'true'`, and `'false'` (default is case-sensitive).",
+        "Returns a logical scalar when the broadcasted size is one element, otherwise returns a logical array."
+    ],
+    "examples": [
+        {
+            "description": "Determine whether a string starts with a prefix",
+            "input": "tf = startsWith(\"RunMat Accelerate\", \"RunMat\")",
+            "output": "tf = logical\n   1"
+        },
+        {
+            "description": "Perform a case-insensitive prefix check",
+            "input": "tf = startsWith(\"RunMat\", \"run\", 'IgnoreCase', true)",
+            "output": "tf = logical\n   1"
+        },
+        {
+            "description": "Ignore case using the legacy logical flag",
+            "input": "tf = startsWith(\"RUNMAT\", \"run\", true)",
+            "output": "tf = logical\n   1"
+        },
+        {
+            "description": "Apply a scalar prefix to every element of a string array",
+            "input": "labels = [\"alpha\" \"beta\" \"gamma\"];\ntf = startsWith(labels, \"a\")",
+            "output": "tf = 1×3 logical array\n   1   0   0"
+        },
+        {
+            "description": "Match element-wise prefixes with implicit expansion",
+            "input": "names = [\"hydrogen\"; \"helium\"; \"lithium\"];\nprefixes = [\"hyd\"; \"hel\"; \"lit\"];\ntf = startsWith(names, prefixes)",
+            "output": "tf = 3×1 logical array\n   1\n   1\n   1"
+        },
+        {
+            "description": "Test prefixes for a cell array of character vectors",
+            "input": "C = {'Mercury', 'Venus', 'Mars'};\ntf = startsWith(C, 'M')",
+            "output": "tf = 1×3 logical array\n   1   0   1"
+        },
+        {
+            "description": "Provide multiple prefixes as a column vector",
+            "input": "tf = startsWith(\"saturn\", ['s'; 'n'; 'x'])",
+            "output": "tf = 3×1 logical array\n   1\n   0\n   0"
+        },
+        {
+            "description": "Handle empty and missing values",
+            "input": "texts = [\"\", \"<missing>\"];\ntf = startsWith(texts, \"\")",
+            "output": "tf = 1×2 logical array\n   1   0"
+        }
+    ],
+    "faqs": [
+        {
+            "question": "What types can I pass to `startsWith`?",
+            "answer": "Use string scalars/arrays, character vectors/arrays, or cell arrays of character vectors for both arguments. Mixed combinations are accepted, and RunMat performs MATLAB-style implicit expansion when the array sizes differ."
+        },
+        {
+            "question": "How do I ignore letter case?",
+            "answer": "Supply `'IgnoreCase', true` (or `'on'`) after the pattern argument. The option is case-insensitive, so `'ignorecase'` also works. The default is `false`, matching MATLAB."
+        },
+        {
+            "question": "What happens with empty patterns?",
+            "answer": "Empty patterns (`\"\"` or `''`) always match non-missing text elements. When the text element is missing (`<missing>`), the result is `false`."
+        },
+        {
+            "question": "Can I provide multiple prefixes at once?",
+            "answer": "Yes. Provide `pattern` as a string array, character array, or cell array of character vectors. RunMat applies implicit expansion so that scalar inputs expand across the other argument automatically."
+        },
+        {
+            "question": "How are missing strings treated?",
+            "answer": "Missing string scalars (displayed as `<missing>`) never match any pattern and produce `false` in the result. Use `ismissing` if you need to handle missing values separately."
+        },
+        {
+            "question": "Does `startsWith` run on the GPU?",
+            "answer": "No. The builtin executes on the CPU. If inputs reside on the GPU (for example, after other accelerated operations), RunMat gathers them automatically so behaviour matches MATLAB."
+        },
+        {
+            "question": "Does `startsWith` preserve the input shape?",
+            "answer": "Yes. The output is a logical array whose shape reflects the MATLAB-style implicit expansion result. When that shape contains exactly one element, the builtin returns a logical scalar."
+        }
+    ],
+    "links": [
+        {
+            "label": "`contains`",
+            "url": "./contains"
+        },
+        {
+            "label": "`endsWith`",
+            "url": "./endswith"
+        },
+        {
+            "label": "`regexp`",
+            "url": "./regexp"
+        },
+        {
+            "label": "`regexpi`",
+            "url": "./regexpi"
+        },
+        {
+            "label": "strfind",
+            "url": "./strfind"
+        }
+    ],
+    "source": {
+        "label": "`crates/runmat-runtime/src/builtins/strings/search/startswith.rs`",
+        "url": "https://github.com/runmat-org/runmat/blob/main/crates/runmat-runtime/src/builtins/strings/search/startswith.rs"
+    },
+    "gpu_residency": "You usually do NOT need to call `gpuArray` yourself in RunMat (unlike MATLAB).\n\n`startsWith` always executes on the host, but RunMat's runtime automatically gathers any GPU-resident inputs before evaluating the prefix check. Because the builtin registers a `ResidencyPolicy::GatherImmediately`, the planner gathers device handles eagerly and computes the logical result on the CPU. You may still call `gpuArray` manually for compatibility with MATLAB code; the runtime gathers the inputs just in time, so results match MATLAB precisely.",
+    "gpu_behavior": [
+        "`startsWith` performs host-side prefix comparison. When inputs currently live on the GPU, RunMat gathers them back to the host before evaluation so the behaviour is identical to MATLAB. No acceleration provider hooks are required for this builtin."
+    ],
+    "key": "startswith",
+    "slug": "startswith",
+    "categoryPath": [
+        "strings",
+        "search"
+    ]
+};
+export default builtinDoc;
+//# sourceMappingURL=startsWith.js.map

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

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

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

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

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

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