runmat 0.3.6 → 0.4.0

package/dist/generated/builtins/strncmp.js

@@ -0,0 +1,169 @@
+// @generated by scripts/generate-builtins.cjs
+// Do not edit by hand.
+const builtinDoc = {
+    "title": "strncmp",
+    "category": "strings/core",
+    "keywords": [
+        "strncmp",
+        "string compare",
+        "prefix",
+        "text equality",
+        "case-sensitive"
+    ],
+    "summary": "Compare text inputs for equality up to N leading characters with MATLAB-compatible broadcasting.",
+    "references": [
+        "https://www.mathworks.com/help/matlab/ref/strncmp.html"
+    ],
+    "gpu_support": {
+        "elementwise": false,
+        "reduction": false,
+        "precisions": [],
+        "broadcasting": "matlab",
+        "notes": "Executes on the CPU. GPU-resident inputs are gathered automatically so prefix comparisons match MATLAB exactly."
+    },
+    "fusion": {
+        "elementwise": false,
+        "reduction": false,
+        "max_inputs": 3,
+        "constants": "inline"
+    },
+    "requires_feature": null,
+    "tested": {
+        "unit": "builtins::strings::core::strncmp::tests",
+        "integration": "builtins::strings::core::strncmp::tests::strncmp_char_array_rows"
+    },
+    "description": "`strncmp(A, B, N)` compares text values element-wise and returns logical `true` when the first `N` characters of the corresponding elements are identical. Comparisons are case-sensitive and respect MATLAB's implicit expansion rules across strings, character arrays, and cell arrays of character vectors.",
+    "behaviors": [
+        "**Accepted text types**: String scalars/arrays, character vectors or character arrays, and cell arrays of character vectors.",
+        "**Scalar `N` requirement**: The third argument must evaluate to a finite, nonnegative integer scalar. Numeric, logical, and scalar tensor/logical-array values are accepted when they convert cleanly.",
+        "**Implicit expansion**: Scalars expand to match the size of the other operand before comparison.",
+        "**Character arrays**: Rows are treated as independent character vectors. Each row is compared against the other operand and the result is returned as a column vector.",
+        "**Unicode-aware comparisons**: Prefixes are counted in MATLAB characters (Unicode scalar values), so multi-byte UTF-8 sequences are handled transparently.",
+        "**Prefix length semantics**: If `N` is `0`, every comparison evaluates to `true`. If either text element is shorter than `N`, it must match exactly up to the end of the shorter value and the longer value must also end within `N` characters to be considered equal.",
+        "**Missing strings**: Any comparison involving a missing string returns `false` unless `N == 0`.",
+        "**Result type**: Scalar comparisons return logical scalars. Array comparisons return logical arrays that follow MATLAB's column-major ordering."
+    ],
+    "examples": [
+        {
+            "description": "Checking whether two strings share a prefix",
+            "input": "tf = strncmp(\"RunMat\", \"Runway\", 3)",
+            "output": "tf = logical\n   1"
+        },
+        {
+            "description": "Comparing string arrays with implicit expansion",
+            "input": "names = [\"north\" \"south\" \"east\"];\ntf = strncmp(names, \"no\", 2)",
+            "output": "tf = 1×3 logical array\n   1   0   0"
+        },
+        {
+            "description": "Comparing rows of a character array",
+            "input": "animals = char(\"cat\", \"camel\", \"cow\");\ntf = strncmp(animals, \"ca\", 2)",
+            "output": "tf = 3×1 logical array\n   1\n   1\n   0"
+        },
+        {
+            "description": "Comparing cell arrays element-wise",
+            "input": "C1 = {'red', 'green', 'blue'};\nC2 = {'rose', 'grey', 'black'};\ntf = strncmp(C1, C2, 2)",
+            "output": "tf = 1×3 logical array\n   1   0   0"
+        },
+        {
+            "description": "Handling zero-length comparisons",
+            "input": "tf = strncmp(\"alpha\", \"omega\", 0)",
+            "output": "tf = logical\n   1"
+        }
+    ],
+    "faqs": [
+        {
+            "question": "What argument types does `strncmp` accept?",
+            "answer": "String arrays, character vectors/arrays, and cell arrays of character vectors. Mixed combinations are converted automatically. The third argument `N` must be a nonnegative integer scalar."
+        },
+        {
+            "question": "Is the comparison case-sensitive?",
+            "answer": "Yes. Use `strncmpi` if you need a case-insensitive prefix comparison."
+        },
+        {
+            "question": "What happens when `N` is zero?",
+            "answer": "The builtin returns `true` for every element because zero leading characters are compared."
+        },
+        {
+            "question": "How are shorter strings handled when `N` is larger than their length?",
+            "answer": "The shorter value must match the longer value exactly for its entire length, and the longer value must not have additional characters within the first `N` positions. Otherwise the comparison returns `false`."
+        },
+        {
+            "question": "How are missing string values treated?",
+            "answer": "Any comparison that involves a missing string returns `false`, except when `N` is zero (because no characters are compared)."
+        },
+        {
+            "question": "Does `strncmp` produce logical results?",
+            "answer": "Yes. Scalar comparisons yield logical scalars; array inputs produce logical arrays that follow MATLAB’s column-major ordering."
+        }
+    ],
+    "links": [
+        {
+            "label": "strcmp",
+            "url": "./strcmp"
+        },
+        {
+            "label": "strcmpi",
+            "url": "./strcmpi"
+        },
+        {
+            "label": "contains",
+            "url": "./contains"
+        },
+        {
+            "label": "startswith",
+            "url": "./startswith"
+        },
+        {
+            "label": "strlength",
+            "url": "./strlength"
+        },
+        {
+            "label": "char",
+            "url": "./char"
+        },
+        {
+            "label": "compose",
+            "url": "./compose"
+        },
+        {
+            "label": "num2str",
+            "url": "./num2str"
+        },
+        {
+            "label": "sprintf",
+            "url": "./sprintf"
+        },
+        {
+            "label": "str2double",
+            "url": "./str2double"
+        },
+        {
+            "label": "string.empty",
+            "url": "./string.empty"
+        },
+        {
+            "label": "string",
+            "url": "./string"
+        },
+        {
+            "label": "strings",
+            "url": "./strings"
+        }
+    ],
+    "source": {
+        "label": "`crates/runmat-runtime/src/builtins/strings/core/strncmp.rs`",
+        "url": "https://github.com/runmat-org/runmat/blob/main/crates/runmat-runtime/src/builtins/strings/core/strncmp.rs"
+    },
+    "gpu_residency": "No. If you pass GPU-resident data, RunMat automatically gathers it to host memory before running `strncmp`. The builtin is an acceleration sink and always returns host logical outputs. Explicit `gpuArray` / `gather` calls are only required for compatibility with legacy MATLAB workflows.",
+    "gpu_behavior": [
+        "`strncmp` is registered as an acceleration **sink**. When any operand resides on the GPU, RunMat gathers all inputs back to host memory before performing the comparison so that the behaviour matches MATLAB exactly. The logical result is always returned on the host. Providers do not need to supply specialised kernels."
+    ],
+    "key": "strncmp",
+    "slug": "strncmp",
+    "categoryPath": [
+        "strings",
+        "core"
+    ]
+};
+export default builtinDoc;
+//# sourceMappingURL=strncmp.js.map

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

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

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

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

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

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

package/dist/generated/builtins/strrep.js

@@ -0,0 +1,193 @@
+// @generated by scripts/generate-builtins.cjs
+// Do not edit by hand.
+const builtinDoc = {
+    "title": "strrep",
+    "category": "strings/transform",
+    "keywords": [
+        "strrep",
+        "string replace",
+        "character array replace",
+        "text replacement",
+        "substring replace"
+    ],
+    "summary": "Replace substring occurrences in strings, character arrays, and cell arrays while mirroring MATLAB semantics.",
+    "references": [
+        "https://www.mathworks.com/help/matlab/ref/strrep.html"
+    ],
+    "gpu_support": {
+        "elementwise": false,
+        "reduction": false,
+        "precisions": [],
+        "broadcasting": "none",
+        "notes": "Runs on the CPU. RunMat gathers GPU-resident text inputs before performing replacements."
+    },
+    "fusion": {
+        "elementwise": false,
+        "reduction": false,
+        "max_inputs": 3,
+        "constants": "inline"
+    },
+    "requires_feature": null,
+    "tested": {
+        "unit": "builtins::strings::transform::strrep::tests",
+        "integration": "builtins::strings::transform::strrep::tests::strrep_cell_array_char_vectors, builtins::strings::transform::strrep::tests::strrep_wgpu_provider_fallback"
+    },
+    "description": "`strrep(str, old, new)` replaces every non-overlapping instance of the substring `old` that appears in `str` with the text provided in `new`. The builtin accepts string scalars, string arrays, character arrays, and cell arrays of character vectors, matching MATLAB behaviour exactly.",
+    "behaviors": [
+        "String scalars remain strings. Missing string values (`<missing>`) propagate unchanged.",
+        "String arrays are processed element-wise while preserving their full shape and orientation.",
+        "Character arrays are handled row by row. Rows expand or shrink as needed and are padded with spaces so the result stays a rectangular char array, just like MATLAB.",
+        "Cell arrays must contain character vectors or string scalars. The result is a cell array of identical size where each element has had the replacement applied.",
+        "The `old` and `new` arguments must be string scalars or character vectors of the same data type.",
+        "`old` can be empty. In that case, `strrep` inserts `new` before the first character, between existing characters, and after the final character."
+    ],
+    "examples": [
+        {
+            "description": "Replacing a word inside a string scalar",
+            "input": "txt = \"RunMat turbo mode\";\nresult = strrep(txt, \"turbo\", \"accelerate\")",
+            "output": "result = \"RunMat accelerate mode\""
+        },
+        {
+            "description": "Updating every element of a string array",
+            "input": "labels = [\"GPU planner\", \"CPU planner\"];\nupdated = strrep(labels, \"planner\", \"pipeline\")",
+            "output": "updated = 2×1 string\n    \"GPU pipeline\"\n    \"CPU pipeline\""
+        },
+        {
+            "description": "Preserving rectangular shape in character arrays",
+            "input": "chars = char(\"alpha\", \"beta \");\nout = strrep(chars, \"a\", \"A\")",
+            "output": "out =\n\n  2×5 char array\n\n    'AlphA'\n    'betA '"
+        },
+        {
+            "description": "Applying replacements inside a cell array of character vectors",
+            "input": "C = {'Kernel Fusion', 'GPU Planner'};\nrenamed = strrep(C, ' ', '_')",
+            "output": "renamed = 1×2 cell array\n    {'Kernel_Fusion'}    {'GPU_Planner'}"
+        },
+        {
+            "description": "Inserting text with an empty search pattern",
+            "input": "stub = \"abc\";\nexpanded = strrep(stub, \"\", \"-\")",
+            "output": "expanded = \"-a-b-c-\""
+        },
+        {
+            "description": "Leaving missing string values untouched",
+            "input": "vals = [\"RunMat\", \"<missing>\", \"Accelerate\"];\nout = strrep(vals, \"RunMat\", \"RUNMAT\")",
+            "output": "out = 1×3 string\n    \"RUNMAT\"    <missing>    \"Accelerate\""
+        },
+        {
+            "description": "Replacing substrings gathered from GPU inputs",
+            "input": "g = gpuArray(\"Turbine\");\nhost = strrep(g, \"bine\", \"bo\")",
+            "output": "host = \"Turbo\""
+        }
+    ],
+    "faqs": [
+        {
+            "question": "Which input types does `strrep` accept?",
+            "answer": "String scalars, string arrays, character vectors, character arrays, and cell arrays of character vectors. The `old` and `new` arguments must be string scalars or character vectors of the same data type."
+        },
+        {
+            "question": "Does `strrep` support multiple search terms at once?",
+            "answer": "No. Use the newer `replace` builtin if you need to substitute several search terms in a single call."
+        },
+        {
+            "question": "How does `strrep` handle missing strings?",
+            "answer": "Missing string scalars remain `<missing>` and are returned unchanged, even when the search pattern matches ordinary text."
+        },
+        {
+            "question": "Will rows of a character array stay aligned?",
+            "answer": "Yes. Each row is replaced individually, then padded with spaces so that the overall array stays rectangular, matching MATLAB exactly."
+        },
+        {
+            "question": "What happens when `old` is empty?",
+            "answer": "RunMat mirrors MATLAB: `new` is inserted before the first character, between every existing character, and after the last character."
+        },
+        {
+            "question": "Does `strrep` run on the GPU?",
+            "answer": "Not today. The builtin gathers GPU-resident data to host memory automatically before performing the replacement logic."
+        },
+        {
+            "question": "Can I mix strings and character vectors for `old` and `new`?",
+            "answer": "No. MATLAB requires `old` and `new` to share the same data type. RunMat enforces the same rule and raises a descriptive error when they differ."
+        },
+        {
+            "question": "How do I replace text stored inside cell arrays?",
+            "answer": "`strrep` traverses the cell array, applying the replacement to each character vector or string scalar element and returning a cell array of the same shape."
+        }
+    ],
+    "links": [
+        {
+            "label": "replace",
+            "url": "./replace"
+        },
+        {
+            "label": "regexprep",
+            "url": "./regexprep"
+        },
+        {
+            "label": "string",
+            "url": "./string"
+        },
+        {
+            "label": "char",
+            "url": "./char"
+        },
+        {
+            "label": "join",
+            "url": "./join"
+        },
+        {
+            "label": "erase",
+            "url": "./erase"
+        },
+        {
+            "label": "eraseBetween",
+            "url": "./erasebetween"
+        },
+        {
+            "label": "extractBetween",
+            "url": "./extractbetween"
+        },
+        {
+            "label": "lower",
+            "url": "./lower"
+        },
+        {
+            "label": "pad",
+            "url": "./pad"
+        },
+        {
+            "label": "split",
+            "url": "./split"
+        },
+        {
+            "label": "strcat",
+            "url": "./strcat"
+        },
+        {
+            "label": "strip",
+            "url": "./strip"
+        },
+        {
+            "label": "strtrim",
+            "url": "./strtrim"
+        },
+        {
+            "label": "upper",
+            "url": "./upper"
+        }
+    ],
+    "source": {
+        "label": "`crates/runmat-runtime/src/builtins/strings/transform/strrep.rs`",
+        "url": "https://github.com/runmat-org/runmat/blob/main/crates/runmat-runtime/src/builtins/strings/transform/strrep.rs"
+    },
+    "gpu_residency": "No. `strrep` registers as a sink with RunMat Accelerate, so the fusion planner never keeps its inputs or outputs on the GPU. Even if you start with GPU data, the runtime gathers it automatically—manual `gpuArray` or `gather` calls are unnecessary.",
+    "gpu_behavior": [
+        "RunMat treats text replacement as a CPU-first workflow:\n\n1. The builtin is registered as an Accelerate *sink*, so the planner gathers any GPU-resident inputs (string arrays, char arrays, or cell contents) back to host memory before work begins. 2. Replacements are computed entirely on the CPU, mirroring MATLAB’s behaviour and avoiding GPU/device divergence in string handling. 3. Results are returned as host values (string array, char array, or cell array). Residency is never pushed back to the GPU, keeping semantics deterministic regardless of the active provider."
+    ],
+    "key": "strrep",
+    "slug": "strrep",
+    "categoryPath": [
+        "strings",
+        "transform"
+    ]
+};
+export default builtinDoc;
+//# sourceMappingURL=strrep.js.map

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

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

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

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

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

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

package/dist/generated/builtins/strtrim.js

@@ -0,0 +1,180 @@
+// @generated by scripts/generate-builtins.cjs
+// Do not edit by hand.
+const builtinDoc = {
+    "title": "strtrim",
+    "category": "strings/transform",
+    "keywords": [
+        "strtrim",
+        "trim whitespace",
+        "leading spaces",
+        "trailing spaces",
+        "character arrays",
+        "string arrays"
+    ],
+    "summary": "Remove leading and trailing whitespace from strings, character arrays, and cell arrays.",
+    "references": [
+        "https://www.mathworks.com/help/matlab/ref/strtrim.html"
+    ],
+    "gpu_support": {
+        "elementwise": false,
+        "reduction": false,
+        "precisions": [],
+        "broadcasting": "none",
+        "notes": "Executes on the CPU; GPU-resident inputs are gathered automatically before trimming."
+    },
+    "fusion": {
+        "elementwise": false,
+        "reduction": false,
+        "max_inputs": 1,
+        "constants": "inline"
+    },
+    "requires_feature": null,
+    "tested": {
+        "unit": "builtins::strings::transform::strtrim::tests",
+        "integration": "builtins::strings::transform::strtrim::tests::strtrim_cell_array_mixed_content"
+    },
+    "description": "`strtrim(text)` removes leading and trailing whitespace characters from `text`. The input can be a string scalar, string array, character array, or a cell array of character vectors, mirroring MATLAB behaviour. Internal whitespace is preserved exactly as provided.",
+    "behaviors": [
+        "Whitespace is defined via MATLAB's `isspace`, so spaces, tabs, newlines, and other Unicode whitespace code points are removed from both ends of each element.",
+        "String scalars and arrays keep their type and shape. Missing string scalars (`<missing>`) remain missing and are returned unchanged.",
+        "Character arrays are trimmed row by row. The result keeps the original number of rows and shrinks the column count to the longest trimmed row, padding shorter rows with spaces so the output stays rectangular.",
+        "Cell arrays must contain string scalars or character vectors. Results preserve the original cell layout with each element trimmed.",
+        "Numeric, logical, or structured inputs raise MATLAB-compatible type errors."
+    ],
+    "examples": [
+        {
+            "description": "Trim Leading And Trailing Spaces From A String Scalar",
+            "input": "name = \"   RunMat   \";\nclean = strtrim(name)",
+            "output": "clean = \"RunMat\""
+        },
+        {
+            "description": "Remove Extra Whitespace From Each Element Of A String Array",
+            "input": "labels = [\"  Alpha  \"; \"Beta   \"; \"   Gamma\"];\ntrimmed = strtrim(labels)",
+            "output": "trimmed = 3×1 string\n    \"Alpha\"\n    \"Beta\"\n    \"Gamma\""
+        },
+        {
+            "description": "Trim Character Array Rows While Preserving Shape",
+            "input": "animals = char('  cat   ', 'dog', ' cow ');\nresult = strtrim(animals)",
+            "output": "result =\n\n  3×3 char array\n\n    'cat'\n    'dog'\n    'cow'"
+        },
+        {
+            "description": "Trim Tabs And Newlines Alongside Spaces",
+            "input": "text = \"\\tMetrics \" + newline;\nclean = strtrim(text)",
+            "output": "clean = \"Metrics\""
+        },
+        {
+            "description": "Trim Each Element Of A Cell Array Of Character Vectors",
+            "input": "pieces = {'  GPU  ', \" Accelerate\", 'RunMat   '};\nout = strtrim(pieces)",
+            "output": "out = 1×3 cell array\n    {'GPU'}    {\"Accelerate\"}    {'RunMat'}"
+        },
+        {
+            "description": "Preserve Missing String Scalars",
+            "input": "vals = [\" ok \"; \"<missing>\"; \" trimmed \"];\ntrimmed = strtrim(vals)",
+            "output": "trimmed = 1×3 string\n    \"ok\"\n    <missing>\n    \"trimmed\""
+        }
+    ],
+    "faqs": [
+        {
+            "question": "Does `strtrim` modify internal whitespace?",
+            "answer": "No. Only leading and trailing whitespace is removed; interior spacing remains intact."
+        },
+        {
+            "question": "Which characters count as whitespace?",
+            "answer": "`strtrim` removes code points that MATLAB's `isspace` recognises, including spaces, tabs, newlines, carriage returns, and many Unicode space separators."
+        },
+        {
+            "question": "How are character arrays resized?",
+            "answer": "Each row is trimmed independently. The output keeps the same number of rows and shrinks the width to match the longest trimmed row, padding shorter rows with spaces if necessary."
+        },
+        {
+            "question": "What happens to missing strings?",
+            "answer": "Missing string scalars (`string(missing)`) remain `<missing>` exactly as in MATLAB."
+        },
+        {
+            "question": "Can I pass numeric or logical arrays to `strtrim`?",
+            "answer": "No. Passing non-text inputs raises a MATLAB-compatible error indicating that text input is required."
+        },
+        {
+            "question": "How does `strtrim` differ from `strip`?",
+            "answer": "`strtrim` always removes leading and trailing whitespace. `strip` is newer and adds options for custom characters and directional trimming; use it when you need finer control."
+        },
+        {
+            "question": "What does strtrim do in MATLAB?",
+            "answer": "`strtrim` removes leading and trailing whitespace from a string or character array. Interior whitespace is preserved."
+        },
+        {
+            "question": "How is strtrim different from strip in MATLAB?",
+            "answer": "Both remove leading and trailing whitespace, but `strip` additionally lets you specify which side to trim (`'left'`, `'right'`, or `'both'`) and which characters to remove."
+        },
+        {
+            "question": "Does strtrim work with string arrays?",
+            "answer": "Yes. `strtrim` operates element-wise on string arrays, removing whitespace from each element independently. Missing strings remain missing."
+        }
+    ],
+    "links": [
+        {
+            "label": "strip",
+            "url": "./strip"
+        },
+        {
+            "label": "upper",
+            "url": "./upper"
+        },
+        {
+            "label": "lower",
+            "url": "./lower"
+        },
+        {
+            "label": "erase",
+            "url": "./erase"
+        },
+        {
+            "label": "eraseBetween",
+            "url": "./erasebetween"
+        },
+        {
+            "label": "extractBetween",
+            "url": "./extractbetween"
+        },
+        {
+            "label": "join",
+            "url": "./join"
+        },
+        {
+            "label": "pad",
+            "url": "./pad"
+        },
+        {
+            "label": "replace",
+            "url": "./replace"
+        },
+        {
+            "label": "split",
+            "url": "./split"
+        },
+        {
+            "label": "strcat",
+            "url": "./strcat"
+        },
+        {
+            "label": "strrep",
+            "url": "./strrep"
+        }
+    ],
+    "source": {
+        "label": "`crates/runmat-runtime/src/builtins/strings/transform/strtrim.rs`",
+        "url": "https://github.com/runmat-org/runmat/blob/main/crates/runmat-runtime/src/builtins/strings/transform/strtrim.rs"
+    },
+    "gpu_residency": "You do not need to call `gpuArray` or `gather` manually. RunMat automatically gathers any GPU-resident text data before applying `strtrim`, so the builtin behaves the same regardless of where the data lives.",
+    "gpu_behavior": [
+        "`strtrim` runs on the CPU. When the input (or any nested element) resides on the GPU, RunMat gathers it to host memory before trimming so the output matches MATLAB exactly. Providers do not need to implement device kernels for this builtin today."
+    ],
+    "key": "strtrim",
+    "slug": "strtrim",
+    "categoryPath": [
+        "strings",
+        "transform"
+    ]
+};
+export default builtinDoc;
+//# sourceMappingURL=strtrim.js.map

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

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

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

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

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

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