runmat 0.3.6 → 0.4.0

package/dist/generated/builtins/real.js

@@ -0,0 +1,228 @@
+// @generated by scripts/generate-builtins.cjs
+// Do not edit by hand.
+const builtinDoc = {
+    "title": "real",
+    "category": "math/elementwise",
+    "keywords": [
+        "real",
+        "real part",
+        "complex",
+        "elementwise",
+        "gpu"
+    ],
+    "summary": "Extract the real part of scalars, vectors, matrices, or N-D tensors.",
+    "references": [],
+    "gpu_support": {
+        "elementwise": true,
+        "reduction": false,
+        "precisions": [
+            "f32",
+            "f64"
+        ],
+        "broadcasting": "matlab",
+        "notes": "Falls back to the host when the active provider lacks unary_real or when inputs require host-side conversions (complex tensors, characters)."
+    },
+    "fusion": {
+        "elementwise": true,
+        "reduction": false,
+        "max_inputs": 1,
+        "constants": "inline"
+    },
+    "requires_feature": null,
+    "tested": {
+        "unit": "builtins::math::elementwise::real::tests",
+        "integration": "builtins::math::elementwise::real::tests::real_gpu_provider_roundtrip"
+    },
+    "description": "`real(x)` returns the real component of each element in `x`. Real inputs are passed through unchanged, while complex inputs discard their imaginary component.",
+    "behaviors": [
+        "Complex scalars, vectors, matrices, and higher-dimensional tensors return only their real parts.",
+        "Real inputs (double, single, logical) are preserved exactly, but results are materialised as double precision when necessary (e.g., logical masks become doubles).",
+        "Character arrays are converted to their numeric code points and returned as doubles, matching MATLAB semantics.",
+        "String arrays are not supported and raise an error (`real` expects numeric, logical, or character data).",
+        "Sparse arrays are currently densified (sparse support is planned)."
+    ],
+    "examples": [
+        {
+            "description": "Extract the real part of a complex scalar",
+            "input": "z = 3 + 4i;\nr = real(z)",
+            "output": "r = 3"
+        },
+        {
+            "description": "Take the real part of a complex matrix",
+            "input": "Z = [1+2i, 4-3i; -5+0i, 7+8i];\nR = real(Z)",
+            "output": "R =\n     1     4\n    -5     7"
+        },
+        {
+            "description": "Confirm that real inputs remain unchanged",
+            "input": "data = [-2.5 0 9.75];\nresult = real(data)",
+            "output": "result = [-2.5 0 9.75]"
+        },
+        {
+            "description": "Convert logical masks to doubles",
+            "input": "mask = logical([0 1 0; 1 1 0]);\nnumeric = real(mask)",
+            "output": "numeric =\n     0     1     0\n     1     1     0"
+        },
+        {
+            "description": "Convert characters to numeric codes",
+            "input": "chars = 'RunMat';\ncodes = real(chars)",
+            "output": "codes = [82 117 110 77 97 116]"
+        },
+        {
+            "description": "Keep GPU tensors device-resident when possible",
+            "input": "G = rand(4096, 512, \"gpuArray\");\nR = real(G)"
+        }
+    ],
+    "faqs": [
+        {
+            "question": "Does `real` change purely real inputs?",
+            "answer": "No. Real, logical, and character inputs are preserved numerically, though logical and character values are returned as doubles to match MATLAB."
+        },
+        {
+            "question": "How does `real` handle complex zeros?",
+            "answer": "`real(0 + 0i)` returns exactly `0`. Imaginary zeros are simply discarded."
+        },
+        {
+            "question": "Can I call `real` on string arrays?",
+            "answer": "No. Like MATLAB, `real` only accepts numeric, logical, or character arrays. Converting strings with `double(string)` first will produce numeric codes if required."
+        },
+        {
+            "question": "Does `real` allocate a new array?",
+            "answer": "Yes. The builtin returns a new tensor (or scalar). Fusion may combine kernels to avoid materialising intermediates when safe."
+        },
+        {
+            "question": "What happens on the GPU without `unary_real`?",
+            "answer": "RunMat gathers the tensor to host memory, applies the CPU semantics, and allows subsequent operations to re-upload if profitable. Providers are encouraged to implement `unary_real` for zero-copy behaviour."
+        },
+        {
+            "question": "Is GPU execution numerically identical to CPU?",
+            "answer": "Yes—`real` is an identity for real tensors. Results match within the provider's precision (`single` or `double`)."
+        },
+        {
+            "question": "Does `real` participate in fusion?",
+            "answer": "Yes. The fusion planner can fold `real` into neighbouring elementwise kernels, keeping data on the GPU when possible."
+        }
+    ],
+    "links": [
+        {
+            "label": "imag",
+            "url": "./imag"
+        },
+        {
+            "label": "abs",
+            "url": "./abs"
+        },
+        {
+            "label": "sign",
+            "url": "./sign"
+        },
+        {
+            "label": "gpuArray",
+            "url": "./gpuarray"
+        },
+        {
+            "label": "gather",
+            "url": "./gather"
+        },
+        {
+            "label": "angle",
+            "url": "./angle"
+        },
+        {
+            "label": "conj",
+            "url": "./conj"
+        },
+        {
+            "label": "double",
+            "url": "./double"
+        },
+        {
+            "label": "exp",
+            "url": "./exp"
+        },
+        {
+            "label": "expm1",
+            "url": "./expm1"
+        },
+        {
+            "label": "factorial",
+            "url": "./factorial"
+        },
+        {
+            "label": "gamma",
+            "url": "./gamma"
+        },
+        {
+            "label": "hypot",
+            "url": "./hypot"
+        },
+        {
+            "label": "ldivide",
+            "url": "./ldivide"
+        },
+        {
+            "label": "log",
+            "url": "./log"
+        },
+        {
+            "label": "log10",
+            "url": "./log10"
+        },
+        {
+            "label": "log1p",
+            "url": "./log1p"
+        },
+        {
+            "label": "log2",
+            "url": "./log2"
+        },
+        {
+            "label": "minus",
+            "url": "./minus"
+        },
+        {
+            "label": "plus",
+            "url": "./plus"
+        },
+        {
+            "label": "pow2",
+            "url": "./pow2"
+        },
+        {
+            "label": "power",
+            "url": "./power"
+        },
+        {
+            "label": "rdivide",
+            "url": "./rdivide"
+        },
+        {
+            "label": "single",
+            "url": "./single"
+        },
+        {
+            "label": "sqrt",
+            "url": "./sqrt"
+        },
+        {
+            "label": "times",
+            "url": "./times"
+        }
+    ],
+    "source": {
+        "label": "`crates/runmat-runtime/src/builtins/math/elementwise/real.rs`",
+        "url": "https://github.com/runmat-org/runmat/blob/main/crates/runmat-runtime/src/builtins/math/elementwise/real.rs"
+    },
+    "gpu_residency": "You usually do **not** need to call `gpuArray` explicitly. RunMat's fusion planner and Accelerate layer track residency automatically, keeping tensors on the GPU whenever device execution is beneficial. Explicit `gpuArray` / `gather` calls remain available for MATLAB compatibility or when you need deterministic residency control (e.g., integrating with third-party GPU kernels).",
+    "gpu_behavior": [
+        "**Hook available:** The real part is taken directly on the device with no host transfers (the WGPU provider and the in-process provider both implement this hook).",
+        "**Hook missing or unsupported dtype:** RunMat gathers the tensor to host memory, applies the CPU semantics (including logical and character promotion), and hands control back to the caller. Downstream fusion can still re-upload if the planner decides it is profitable.\n\nComplex GPU tensors are currently gathered because device-side complex storage is not yet available; providers can add fused support later without changing this builtin."
+    ],
+    "key": "real",
+    "slug": "real",
+    "categoryPath": [
+        "math",
+        "elementwise"
+    ]
+};
+export default builtinDoc;
+//# sourceMappingURL=real.js.map

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

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

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

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

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

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

package/dist/generated/builtins/regexp.js

@@ -0,0 +1,154 @@
+// @generated by scripts/generate-builtins.cjs
+// Do not edit by hand.
+const builtinDoc = {
+    "title": "regexp",
+    "category": "strings/regex",
+    "keywords": [
+        "regexp",
+        "regular expression",
+        "pattern",
+        "match",
+        "split",
+        "tokens"
+    ],
+    "summary": "Search text using regular expressions, returning match positions, substrings, tokens, or splits with MATLAB-compatible semantics.",
+    "references": [
+        "https://www.mathworks.com/help/matlab/ref/regexp.html"
+    ],
+    "gpu_support": {
+        "elementwise": false,
+        "reduction": false,
+        "precisions": [],
+        "broadcasting": "none",
+        "notes": "Runs entirely on the CPU. When inputs or outputs reside on the GPU, RunMat gathers data before matching and re-uploads cell contents after evaluation."
+    },
+    "fusion": {
+        "elementwise": false,
+        "reduction": false,
+        "max_inputs": 0,
+        "constants": "inline"
+    },
+    "requires_feature": null,
+    "tested": {
+        "unit": "builtins::strings::regex::regexp::tests",
+        "integration": "builtins::strings::regex::regexp::tests::regexp_multi_output_default"
+    },
+    "description": "`regexp(text, pattern)` locates regular expression matches inside character vectors, string scalars, string arrays, and cell arrays of character vectors. It can return starting indices, ending indices, matched substrings, capture tokens, token extents, named-token structures, or the text split around matches. The optional `'once'` flag restricts the search to the first match, while `'emptymatch','allow'` keeps zero-length matches that otherwise get filtered out.",
+    "behaviors": [
+        "Single character vectors and string scalars return a numeric row vector of 1-based match start indices by default.",
+        "String arrays and cell arrays always produce cell outputs that mirror the input shape, with each cell holding the result for the corresponding element.",
+        "`'match'` returns matched substrings, `'tokens'` returns nested cells of capture-group substrings, `'tokenExtents'` returns `n × 2` double matrices with start/end indices for each token, `'names'` returns scalar struct values keyed by named tokens, and `'split'` yields the text segments between matches.",
+        "`'once'` stops after the first match (per element), and every requested output honours that limit.",
+        "`'emptymatch','remove'` (default) filters zero-length matches; `'emptymatch','allow'` keeps them so callers can observe optional patterns.",
+        "`'forceCellOutput'` forces cell-array containers even for scalar inputs so downstream code can rely on uniform dimensions. MATLAB-compatible `'warnings','on'/'off'` flags are accepted but currently informational only.",
+        "`'matchcase'` and `'ignorecase'` toggle case sensitivity, while `'lineanchors'` (`^`/`$`) and `'dotall'`/`'dotExceptNewline'` control how `.` interacts with newlines, mirroring MATLAB flags."
+    ],
+    "examples": [
+        {
+            "description": "Find all 1-based match positions in a character vector",
+            "input": "idx = regexp('abracadabra', 'a')",
+            "output": "idx =\n     1     4     6     8    11"
+        },
+        {
+            "description": "Return matched substrings using `'match'`",
+            "input": "matches = regexp('abc123xyz', '\\d+', 'match')",
+            "output": "matches =\n  1×1 cell array\n    {'123'}"
+        },
+        {
+            "description": "Extract capture tokens",
+            "input": "tokens = regexp('2024-03-14', '(\\d{4})-(\\d{2})-(\\d{2})', 'tokens');\nyear = tokens{1}{1};\nmonth = tokens{1}{2};\nday = tokens{1}{3}",
+            "output": "year =\n    '2024'\nmonth =\n    '03'\nday =\n    '14'"
+        },
+        {
+            "description": "Split a string array around commas",
+            "input": "parts = regexp([\"a,b,c\"; \"1,2,3\"], ',', 'split')",
+            "output": "parts =\n  2×1 cell array\n    {1×3 cell}\n    {1×3 cell}"
+        },
+        {
+            "description": "Return only the first match with `'once'`",
+            "input": "first_idx = regexp('abababa', 'ba', 'once')",
+            "output": "first_idx =\n     2"
+        },
+        {
+            "description": "Work with named tokens",
+            "input": "matches = regexp('X=42; Y=7;', '(?<name>[A-Z])=(?<value>\\d+)', 'names');\nvalues = cellfun(@(s) str2double(s.value), matches)",
+            "output": "values =\n     42     7"
+        },
+        {
+            "description": "Keep zero-length matches with `'emptymatch','allow'`",
+            "input": "idx = regexp('aba', 'b*', 'emptymatch', 'allow')",
+            "output": "idx =\n     1     2     3     4"
+        }
+    ],
+    "faqs": [
+        {
+            "question": "What outputs does `regexp` return by default?",
+            "answer": "With a single output argument, `regexp` returns a numeric row vector of 1-based match starts. When the call site asks for multiple outputs (e.g. `[startIdx, endIdx, matchStr] = regexp(...)`), RunMat returns match starts, match ends, and matched substrings in that order, just like MATLAB."
+        },
+        {
+            "question": "How can I request tokens or splits instead of indices?",
+            "answer": "Specify the desired output types as string flags, for example `regexp(str, pat, 'match')`, `regexp(str, pat, 'tokens')`, or `regexp(str, pat, 'split')`. Multiple flags combine, so `regexp(str, pat, 'match', 'tokens')` returns both outputs."
+        },
+        {
+            "question": "Does `regexp` support case-insensitive matching?",
+            "answer": "Yes. Use `'ignorecase'` (or call `regexpi`) to enable case-insensitive matching, and `'matchcase'` to revert to the default case-sensitive behaviour."
+        },
+        {
+            "question": "How are string arrays and cell arrays handled?",
+            "answer": "For string arrays and cell arrays of char vectors, every output is a cell array whose shape matches the input. Each cell contains the result for the corresponding element, which mirrors MATLAB's container semantics."
+        },
+        {
+            "question": "How do zero-length matches behave?",
+            "answer": "By default (`'emptymatch','remove'`), zero-length matches are filtered out so loops do not stall. Specify `'emptymatch','allow'` to keep them, matching MATLAB's `'emptymatch'` flag."
+        },
+        {
+            "question": "Can I force cell output even for character vectors?",
+            "answer": "Yes. Pass `'forceCellOutput'` to force the outputs into cell arrays, which is useful when writing code that handles both scalar and array inputs uniformly."
+        },
+        {
+            "question": "Does `regexp` run on the GPU?",
+            "answer": "No. RunMat executes `regexp` on the CPU. If inputs reside on the GPU, it gathers them first and then re-uploads any numeric outputs when beneficial, preserving residency for downstream kernels."
+        },
+        {
+            "question": "What happens when I ask for more outputs than I requested via flags?",
+            "answer": "RunMat follows MATLAB's rules: if you do not supply explicit output flags, the default multi-output order is start indices, end indices, and matched substrings. Extra requested outputs beyond what you specified become numeric zeros."
+        }
+    ],
+    "links": [
+        {
+            "label": "regexpi",
+            "url": "./regexpi"
+        },
+        {
+            "label": "regexprep",
+            "url": "./regexprep"
+        },
+        {
+            "label": "contains",
+            "url": "./contains"
+        },
+        {
+            "label": "split",
+            "url": "./split"
+        },
+        {
+            "label": "strfind",
+            "url": "./strfind"
+        }
+    ],
+    "source": {
+        "label": "`crates/runmat-runtime/src/builtins/strings/regex/regexp.rs`",
+        "url": "https://github.com/runmat-org/runmat/blob/main/crates/runmat-runtime/src/builtins/strings/regex/regexp.rs"
+    },
+    "gpu_behavior": [
+        "`regexp` executes entirely on the CPU and is registered as an acceleration sink. If any argument resides on the GPU, the runtime gathers it before evaluation, computes all requested outputs on the host, and returns host-side containers. Providers do not implement custom hooks for this builtin, so no GPU kernels are required or invoked."
+    ],
+    "key": "regexp",
+    "slug": "regexp",
+    "categoryPath": [
+        "strings",
+        "regex"
+    ]
+};
+export default builtinDoc;
+//# sourceMappingURL=regexp.js.map

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

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

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

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

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

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

package/dist/generated/builtins/regexpi.js

@@ -0,0 +1,149 @@
+// @generated by scripts/generate-builtins.cjs
+// Do not edit by hand.
+const builtinDoc = {
+    "title": "regexpi",
+    "category": "strings/regex",
+    "keywords": [
+        "regexpi",
+        "regular expression",
+        "ignore case",
+        "pattern",
+        "match"
+    ],
+    "summary": "Perform case-insensitive regular expression matching with MATLAB-compatible outputs.",
+    "references": [
+        "https://www.mathworks.com/help/matlab/ref/regexpi.html"
+    ],
+    "gpu_support": {
+        "elementwise": false,
+        "reduction": false,
+        "precisions": [],
+        "broadcasting": "none",
+        "notes": "Runs on the CPU. When inputs reside on the GPU, RunMat gathers them before matching and returns host-side containers."
+    },
+    "fusion": {
+        "elementwise": false,
+        "reduction": false,
+        "max_inputs": 0,
+        "constants": "inline"
+    },
+    "requires_feature": null,
+    "tested": {
+        "unit": "builtins::strings::regex::regexpi::tests",
+        "integration": "builtins::strings::regex::regexpi::tests::regexpi_builtin_match_output"
+    },
+    "description": "`regexpi(text, pattern)` evaluates regular expression matches while ignoring case by default. Outputs mirror MATLAB: you can retrieve 1-based match indices, substrings, capture tokens, token extents, named tokens, or the text split around matches. Flags such as `'once'`, `'tokens'`, `'match'`, `'split'`, `'tokenExtents'`, `'names'`, `'emptymatch'`, and `'forceCellOutput'` are supported, together with case toggles (`'ignorecase'`, `'matchcase'`) and newline behaviour (`'dotall'`, `'dotExceptNewline'`, `'lineanchors'`).",
+    "behaviors": [
+        "Case-insensitive matching is the default; include `'matchcase'` when you need case-sensitive behaviour.",
+        "With one output, `regexpi` returns a numeric row vector of 1-based match start indices.",
+        "With multiple outputs, the default order is match starts, match ends, matched substrings.",
+        "When the input is a string array or cell array of character vectors, outputs are cell arrays whose shape matches the input container.",
+        "`'forceCellOutput'` forces cell outputs even for scalar inputs, matching MATLAB semantics.",
+        "`'once'` limits each element to its first match, influencing every requested output.",
+        "`'emptymatch','allow'` keeps zero-length matches; `'emptymatch','remove'` is the default filter.",
+        "Named tokens (using `(?<name>...)`) return scalar struct values per match when `'names'` is requested. Unmatched names resolve to empty strings for MATLAB compatibility."
+    ],
+    "examples": [
+        {
+            "description": "Finding indices regardless of case",
+            "input": "idx = regexpi('Abracadabra', 'a')",
+            "output": "idx =\n     1     4     6     8    11"
+        },
+        {
+            "description": "Returning matched substrings ignoring case",
+            "input": "matches = regexpi('abcXYZ123', '[a-z]{3}', 'match')",
+            "output": "matches =\n  1×2 cell array\n    {'abc'}    {'XYZ'}"
+        },
+        {
+            "description": "Extracting capture tokens case-insensitively",
+            "input": "tokens = regexpi('ID:AB12', '(?<prefix>[a-z]+)(?<digits>\\d+)', 'tokens');\nfirst = tokens{1}{1};\nsecond = tokens{1}{2}",
+            "output": "first =\n    'AB'\nsecond =\n    '12'"
+        },
+        {
+            "description": "Limiting `regexpi` to the first match",
+            "input": "firstMatch = regexpi('aXaXaX', 'ax', 'match', 'once')",
+            "output": "firstMatch =\n    'aX'"
+        },
+        {
+            "description": "Splitting a string array without worrying about letter case",
+            "input": "parts = regexpi([\"Color:Red\"; \"COLOR:Blue\"], 'color:', 'split')",
+            "output": "parts =\n  2×1 cell array\n    {1×2 cell}\n    {1×2 cell}\n\nparts{2}{2}\nans =\n    'Blue'"
+        },
+        {
+            "description": "Enforcing case-sensitive matches with `'matchcase'`",
+            "input": "idx = regexpi('CaseTest', 'case', 'matchcase')",
+            "output": "idx =\n     []"
+        }
+    ],
+    "faqs": [
+        {
+            "question": "How are the outputs ordered when I request several?",
+            "answer": "If you do not specify explicit output flags, the default order is match starts, match ends, and matched substrings—identical to MATLAB. Providing flags such as `'match'` or `'tokens'` returns only the requested outputs."
+        },
+        {
+            "question": "Can I make `regexpi` behave like `regexp` with case sensitivity?",
+            "answer": "Yes. Include the `'matchcase'` flag to disable the default case-insensitive mode. You can also pass `'ignorecase'` explicitly to emphasise the default."
+        },
+        {
+            "question": "Does `regexpi` support string arrays and cell arrays?",
+            "answer": "Yes. Outputs mirror the input container shape, and each element stores results for the corresponding string or character vector."
+        },
+        {
+            "question": "How do zero-length matches behave?",
+            "answer": "By default (`'emptymatch','remove'`), zero-length matches are omitted. Use `'emptymatch','allow'` to keep them, which is helpful when inspecting optional pattern components."
+        },
+        {
+            "question": "Does `regexpi` run on the GPU?",
+            "answer": "No. All matching occurs on the CPU. RunMat gathers GPU-resident inputs before processing and leaves outputs on the host. Explicit `gpuArray` calls are required if you want to move the results back to the GPU."
+        },
+        {
+            "question": "Are named tokens supported?",
+            "answer": "Yes. Use the `(?<name>...)` syntax and request the `'names'` output flag. Each match produces a scalar struct with fields for every named group."
+        },
+        {
+            "question": "What happens with `'once'`?",
+            "answer": "`'once'` restricts each input element to the first match. All requested outputs honour that limit, returning scalars instead of per-match cells."
+        },
+        {
+            "question": "Can I keep scalar outputs in cells?",
+            "answer": "Yes. Pass `'forceCellOutput'` to wrap even scalar results in cells, which is useful when writing code that must treat scalar and array inputs uniformly."
+        }
+    ],
+    "links": [
+        {
+            "label": "regexp",
+            "url": "./regexp"
+        },
+        {
+            "label": "regexprep",
+            "url": "./regexprep"
+        },
+        {
+            "label": "contains",
+            "url": "./contains"
+        },
+        {
+            "label": "split",
+            "url": "./split"
+        },
+        {
+            "label": "strfind",
+            "url": "./strfind"
+        }
+    ],
+    "source": {
+        "label": "`crates/runmat-runtime/src/builtins/strings/regex/regexpi.rs`",
+        "url": "https://github.com/runmat-org/runmat/blob/main/crates/runmat-runtime/src/builtins/strings/regex/regexpi.rs"
+    },
+    "gpu_behavior": [
+        "`regexpi` executes entirely on the CPU. If inputs or previously computed intermediates are resident on the GPU, RunMat gathers the necessary data before evaluation and returns host-side outputs. Acceleration providers do not offer specialised hooks today; computed tensors remain on the host unless explicit GPU transfers are requested later."
+    ],
+    "key": "regexpi",
+    "slug": "regexpi",
+    "categoryPath": [
+        "strings",
+        "regex"
+    ]
+};
+export default builtinDoc;
+//# sourceMappingURL=regexpi.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"regexpi.js","sourceRoot":"","sources":["../../../src/generated/builtins/regexpi.ts"],"names":[],"mappings":"AAAA,8CAA8C;AAC9C,uBAAuB;AAIvB,MAAM,UAAU,GAAe;IAC7B,OAAO,EAAE,SAAS;IAClB,UAAU,EAAE,eAAe;IAC3B,UAAU,EAAE;QACV,SAAS;QACT,oBAAoB;QACpB,aAAa;QACb,SAAS;QACT,OAAO;KACR;IACD,SAAS,EAAE,sFAAsF;IACjG,YAAY,EAAE;QACZ,wDAAwD;KACzD;IACD,aAAa,EAAE;QACb,aAAa,EAAE,KAAK;QACpB,WAAW,EAAE,KAAK;QAClB,YAAY,EAAE,EAAE;QAChB,cAAc,EAAE,MAAM;QACtB,OAAO,EAAE,uHAAuH;KACjI;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,0CAA0C;QAClD,aAAa,EAAE,wEAAwE;KACxF;IACD,aAAa,EAAE,6gBAA6gB;IAC5hB,WAAW,EAAE;QACX,yGAAyG;QACzG,yFAAyF;QACzF,2FAA2F;QAC3F,uIAAuI;QACvI,4FAA4F;QAC5F,sFAAsF;QACtF,kGAAkG;QAClG,2KAA2K;KAC5K;IACD,UAAU,EAAE;QACV;YACE,aAAa,EAAE,oCAAoC;YACnD,OAAO,EAAE,mCAAmC;YAC5C,QAAQ,EAAE,uCAAuC;SAClD;QACD;YACE,aAAa,EAAE,4CAA4C;YAC3D,OAAO,EAAE,qDAAqD;YAC9D,QAAQ,EAAE,qDAAqD;SAChE;QACD;YACE,aAAa,EAAE,8CAA8C;YAC7D,OAAO,EAAE,0HAA0H;YACnI,QAAQ,EAAE,uCAAuC;SAClD;QACD;YACE,aAAa,EAAE,uCAAuC;YACtD,OAAO,EAAE,uDAAuD;YAChE,QAAQ,EAAE,wBAAwB;SACnC;QACD;YACE,aAAa,EAAE,6DAA6D;YAC5E,OAAO,EAAE,qEAAqE;YAC9E,QAAQ,EAAE,6FAA6F;SACxG;QACD;YACE,aAAa,EAAE,qDAAqD;YACpE,OAAO,EAAE,gDAAgD;YACzD,QAAQ,EAAE,gBAAgB;SAC3B;KACF;IACD,MAAM,EAAE;QACN;YACE,UAAU,EAAE,qDAAqD;YACjE,QAAQ,EAAE,6NAA6N;SACxO;QACD;YACE,UAAU,EAAE,kEAAkE;YAC9E,QAAQ,EAAE,yJAAyJ;SACpK;QACD;YACE,UAAU,EAAE,uDAAuD;YACnE,QAAQ,EAAE,kIAAkI;SAC7I;QACD;YACE,UAAU,EAAE,oCAAoC;YAChD,QAAQ,EAAE,+KAA+K;SAC1L;QACD;YACE,UAAU,EAAE,gCAAgC;YAC5C,QAAQ,EAAE,kNAAkN;SAC7N;QACD;YACE,UAAU,EAAE,6BAA6B;YACzC,QAAQ,EAAE,kJAAkJ;SAC7J;QACD;YACE,UAAU,EAAE,6BAA6B;YACzC,QAAQ,EAAE,kJAAkJ;SAC7J;QACD;YACE,UAAU,EAAE,qCAAqC;YACjD,QAAQ,EAAE,0JAA0J;SACrK;KACF;IACD,OAAO,EAAE;QACP;YACE,OAAO,EAAE,QAAQ;YACjB,KAAK,EAAE,UAAU;SAClB;QACD;YACE,OAAO,EAAE,WAAW;YACpB,KAAK,EAAE,aAAa;SACrB;QACD;YACE,OAAO,EAAE,UAAU;YACnB,KAAK,EAAE,YAAY;SACpB;QACD;YACE,OAAO,EAAE,OAAO;YAChB,KAAK,EAAE,SAAS;SACjB;QACD;YACE,OAAO,EAAE,SAAS;YAClB,KAAK,EAAE,WAAW;SACnB;KACF;IACD,QAAQ,EAAE;QACR,OAAO,EAAE,+DAA+D;QACxE,KAAK,EAAE,4GAA4G;KACpH;IACD,cAAc,EAAE;QACd,wVAAwV;KACzV;IACD,KAAK,EAAE,SAAS;IAChB,MAAM,EAAE,SAAS;IACjB,cAAc,EAAE;QACd,SAAS;QACT,OAAO;KACR;CACF,CAAC;AAEF,eAAe,UAAU,CAAC"}

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

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

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

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