runmat 0.3.6 → 0.4.1

package/dist/generated/builtins/eig.js

@@ -0,0 +1,167 @@
+// @generated by scripts/generate-builtins.cjs
+// Do not edit by hand.
+const builtinDoc = {
+    "title": "eig",
+    "category": "math/linalg/factor",
+    "keywords": [
+        "eig",
+        "eigenvalues",
+        "eigenvectors",
+        "linalg",
+        "gpu"
+    ],
+    "summary": "Eigenvalue decomposition with MATLAB-compatible multi-output forms.",
+    "references": [],
+    "gpu_support": {
+        "elementwise": false,
+        "reduction": false,
+        "precisions": [
+            "f64"
+        ],
+        "broadcasting": "none",
+        "notes": "Uses the provider `eig` hook when available (the WGPU backend reuploads host-computed results for real spectra) and falls back to the CPU path when complex storage or unsupported options are required."
+    },
+    "fusion": {
+        "elementwise": false,
+        "reduction": false,
+        "max_inputs": 1,
+        "constants": "inline"
+    },
+    "requires_feature": null,
+    "tested": {
+        "unit": "builtins::math::linalg::factor::eig::tests",
+        "integration": "builtins::math::linalg::factor::eig::tests::eig_three_outputs_biorthogonality"
+    },
+    "description": "`eig(A)` computes the eigenvalues of a square matrix `A`. With additional outputs it also returns right and left eigenvectors, matching MATLAB’s multi-output semantics (`A*V = V*D` and `W'*A = D*W'`).",
+    "behaviors": [
+        "Single output `d = eig(A)` returns the eigenvalues as an `n × 1` column vector (values may be complex even when `A` is real).",
+        "Two outputs `[V,D] = eig(A)` return the eigenvectors (columns of `V`) and the diagonal eigenvalue matrix `D`.",
+        "Three outputs `[V,D,W] = eig(A)` additionally return the left eigenvectors `W` satisfying `W' * A = D * W'`.",
+        "The selector `'vector'` may be supplied (`eig(A,'vector')`, `[V,d] = eig(A,'vector')`) to request the eigenvalues as a column vector even when two outputs are requested. `'matrix'` resets the second output to the diagonal-matrix form.",
+        "Logical and integer inputs are promoted to double precision. Complex inputs remain complex throughout the factorisation.",
+        "Empty and scalar matrices follow MATLAB’s shape conventions (`eig([])` returns `[]`, `eig(5)` returns `5`).",
+        "Generalised problems `eig(A,B)` are not yet implemented; RunMat emits a clear error if you pass the second matrix argument.",
+        "Optional balancing keywords (`'balance'`, `'nobalance'`) are accepted. Balancing defaults to on; the current implementation leaves balancing as a no-op while retaining the option for forward compatibility."
+    ],
+    "examples": [
+        {
+            "description": "Computing Eigenvalues of a 2x2 Matrix",
+            "input": "A = [2 1; 0 3];\nd = eig(A)",
+            "output": "d = [2; 3]"
+        },
+        {
+            "description": "Diagonalizing a Matrix with Two Outputs",
+            "input": "A = [0 1; -2 -3];\n[V,D] = eig(A);\nrecon = V * D / V"
+        },
+        {
+            "description": "Retrieving Left Eigenvectors with Three Outputs",
+            "input": "A = [4 2; 1 3];\n[V,D,W] = eig(A);\ncheck = W' * A - D * W'"
+        },
+        {
+            "description": "Eigenvalues of a Complex-Valued Matrix",
+            "input": "A = [1+2i, 2-1i; 0, -3i];\n[V,D] = eig(A);\ndiag(D)      % Complex eigenvalues"
+        },
+        {
+            "description": "Eigenvalues of a Diagonal Matrix",
+            "input": "A = diag([10, -2, 7]);\nd = eig(A)"
+        },
+        {
+            "description": "Handling Repeated Eigenvalues",
+            "input": "A = [3 1 0; 0 3 0; 0 0 5];\nd = eig(A)"
+        },
+        {
+            "description": "Using the 'nobalance' Option",
+            "input": "A = [1e6 1; 0 1e-6];\nd_balanced = eig(A);\nd_nobalance = eig(A, 'nobalance')"
+        },
+        {
+            "description": "Returning Eigenvalues as a Vector with Two Outputs",
+            "input": "A = [0 1; -2 -3];\n[V,d] = eig(A, 'vector');\nsize(d)    % 2 x 1 column vector"
+        },
+        {
+            "description": "Running eig on a gpuArray",
+            "input": "G = gpuArray(randn(128));\nd = eig(G);          % Real spectra stay on the GPU when the provider implements eig\nisa(d, 'gpuArray')   % logical 1 when the provider kept the result on device"
+        }
+    ],
+    "faqs": [
+        {
+            "question": "What shapes does `eig` support?",
+            "answer": "`eig` requires a square matrix. Scalars are treated as `1×1` matrices, and empty inputs return empty outputs. Non-square inputs raise an error, matching MATLAB."
+        },
+        {
+            "question": "Do I always get complex outputs?",
+            "answer": "Eigenvalues and eigenvectors are returned as complex arrays when necessary. If all imaginary parts are numerically zero, RunMat returns real doubles for convenience, mirroring MATLAB behaviour."
+        },
+        {
+            "question": "How do I obtain the eigenvalues as a vector when requesting eigenvectors?",
+            "answer": "Pass the `'vector'` selector. For example, `[V,d] = eig(A,'vector')` returns a column vector `d` and the right eigenvectors in `V`. Use `'matrix'` (or omit the selector) when you prefer the diagonal-matrix form."
+        },
+        {
+            "question": "What about the optional balancing keywords?",
+            "answer": "`'balance'` (default) and `'nobalance'` are accepted. The current release treats balancing as a no-op; the option remains so future releases can introduce a true balancing implementation without breaking user code."
+        },
+        {
+            "question": "Are generalised eigenvalue problems supported?",
+            "answer": "Not yet. Calling `eig(A,B)` raises a descriptive error. This builtin focuses on the standard eigenvalue problem; the generalised form will be added in a future update."
+        },
+        {
+            "question": "How are left eigenvectors normalised?",
+            "answer": "RunMat scales left eigenvectors so that `W' * V = I` (bi-orthonormal columns), matching MATLAB’s conventions. When a provider supplies the GPU implementation the same normalisation is expected."
+        },
+        {
+            "question": "Does `eig` participate in fusion or auto-offload?",
+            "answer": "No. Eigenvalue decomposition executes eagerly and acts as a residency sink. The fusion planner will gather any GPU-resident inputs before factorisation."
+        },
+        {
+            "question": "How can I continue on the GPU after calling `eig` today?",
+            "answer": "When the active provider implements the `eig` hook (the WGPU backend does for real spectra), the outputs remain on the GPU automatically. If the decomposition falls back to the CPU—because the spectrum is complex or `'nobalance'` was requested—call `gpuArray` on whichever results you need on the device."
+        },
+        {
+            "question": "What happens if the eigenvector matrix is singular?",
+            "answer": "When the right eigenvectors form a singular matrix, RunMat falls back to computing left eigenvectors from the conjugate-transposed problem. If that fails, requesting the third output raises an error, matching MATLAB’s failure behaviour."
+        }
+    ],
+    "links": [
+        {
+            "label": "svd",
+            "url": "./svd"
+        },
+        {
+            "label": "qr",
+            "url": "./qr"
+        },
+        {
+            "label": "lu",
+            "url": "./lu"
+        },
+        {
+            "label": "chol",
+            "url": "./chol"
+        },
+        {
+            "label": "gpuArray",
+            "url": "./gpuarray"
+        },
+        {
+            "label": "gather",
+            "url": "./gather"
+        }
+    ],
+    "source": {
+        "label": "crates/runmat-runtime/src/builtins/math/linalg/factor/eig.rs",
+        "url": "crates/runmat-runtime/src/builtins/math/linalg/factor/eig.rs"
+    },
+    "gpu_behavior": [
+        "The WGPU provider implements the reserved `eig` hook by downloading the input, running the same CPU decomposition used by the host path, and immediately re-uploading the double-precision eigenvalues, eigenvectors, and diagonal matrix. When the spectrum is real, the outputs therefore remain on the GPU without any user intervention.",
+        "If any output requires complex storage or you pass `'nobalance'`, RunMat automatically falls back to the host implementation and returns CPU-resident arrays. The `'vector'` selector also triggers this transparent host fallback today. Reapply `gpuArray` if you want to continue on the device after such a fallback.",
+        "Because `eig` is a residency sink, the fusion planner treats it as a barrier and does not attempt to fuse surrounding elementwise work."
+    ],
+    "key": "eig",
+    "slug": "eig",
+    "categoryPath": [
+        "math",
+        "linalg",
+        "factor"
+    ]
+};
+export default builtinDoc;
+//# sourceMappingURL=eig.js.map

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

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

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

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

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

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

package/dist/generated/builtins/endsWith.js

@@ -0,0 +1,151 @@
+// @generated by scripts/generate-builtins.cjs
+// Do not edit by hand.
+const builtinDoc = {
+    "title": "endsWith",
+    "category": "strings/search",
+    "keywords": [
+        "endswith",
+        "suffix",
+        "string array",
+        "ignorecase",
+        "text search"
+    ],
+    "summary": "Check whether text inputs end with specific patterns using MATLAB-compatible broadcasting and case handling.",
+    "references": [
+        "https://www.mathworks.com/help/matlab/ref/endswith.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::endswith::tests",
+        "integration": "builtins::strings::search::endswith::tests::endswith_cell_array_patterns"
+    },
+    "description": "`endsWith(str, pattern)` returns a logical result indicating whether each element of `str` ends 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 string scalars (`<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": "Check if a filename ends with an extension",
+            "input": "tf = endsWith(\"report.pdf\", \".pdf\")",
+            "output": "tf = logical\n   1"
+        },
+        {
+            "description": "Perform a case-insensitive suffix test",
+            "input": "tf = endsWith(\"RunMat\", \"MAT\", 'IgnoreCase', true)",
+            "output": "tf = logical\n   1"
+        },
+        {
+            "description": "Apply a scalar suffix to every element of a string array",
+            "input": "labels = [\"alpha\" \"beta\" \"gamma\"];\ntf = endsWith(labels, \"ma\")",
+            "output": "tf = 1×3 logical array\n   0   0   1"
+        },
+        {
+            "description": "Use element-wise suffixes with implicit expansion",
+            "input": "names = [\"hydrogen\"; \"helium\"; \"lithium\"];\nsuffixes = [\"gen\"; \"ium\"; \"ium\"];\ntf = endsWith(names, suffixes)",
+            "output": "tf = 3×1 logical array\n   1\n   1\n   1"
+        },
+        {
+            "description": "Test suffixes for a cell array of character vectors",
+            "input": "C = {'Mercury', 'Venus', 'Mars'};\ntf = endsWith(C, 's')",
+            "output": "tf = 1×3 logical array\n   0   1   1"
+        },
+        {
+            "description": "Provide multiple suffixes as a column vector",
+            "input": "tf = endsWith(\"saturn\", ['n'; 'x'; 'r'])",
+            "output": "tf = 3×1 logical array\n   1\n   0\n   0"
+        },
+        {
+            "description": "Handle empty patterns and missing values",
+            "input": "texts = [\"\", \"<missing>\"];\ntf = endsWith(texts, \"\")",
+            "output": "tf = 1×2 logical array\n   1   0"
+        }
+    ],
+    "faqs": [
+        {
+            "question": "What types can I pass to `endsWith`?",
+            "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 suffixes 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 `endsWith` 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 `endsWith` 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": "`startsWith`",
+            "url": "./startswith"
+        },
+        {
+            "label": "`regexp`",
+            "url": "./regexp"
+        },
+        {
+            "label": "`regexpi`",
+            "url": "./regexpi"
+        },
+        {
+            "label": "strfind",
+            "url": "./strfind"
+        }
+    ],
+    "source": {
+        "label": "`crates/runmat-runtime/src/builtins/strings/search/endswith.rs`",
+        "url": "https://github.com/runmat-org/runmat/blob/main/crates/runmat-runtime/src/builtins/strings/search/endswith.rs"
+    },
+    "gpu_residency": "You usually do NOT need to call `gpuArray` yourself in RunMat (unlike MATLAB).\n\n`endsWith` always executes on the host, but RunMat's runtime automatically gathers any GPU-resident inputs before evaluating the suffix 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": [
+        "`endsWith` performs host-side suffix 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": "endswith",
+    "slug": "endswith",
+    "categoryPath": [
+        "strings",
+        "search"
+    ]
+};
+export default builtinDoc;
+//# sourceMappingURL=endsWith.js.map

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

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

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

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

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

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

@@ -0,0 +1,154 @@
+// @generated by scripts/generate-builtins.cjs
+// Do not edit by hand.
+const builtinDoc = {
+    "title": "eq",
+    "category": "logical/rel",
+    "keywords": [
+        "eq",
+        "==",
+        "equality",
+        "logical comparison",
+        "gpuArray equality"
+    ],
+    "summary": "Element-wise equality comparison for scalars, arrays, strings, and gpuArray inputs.",
+    "references": [],
+    "gpu_support": {
+        "elementwise": true,
+        "reduction": false,
+        "precisions": [
+            "f32",
+            "f64"
+        ],
+        "broadcasting": "matlab",
+        "notes": "Uses provider elem_eq kernels when available; otherwise inputs gather back to host memory transparently."
+    },
+    "fusion": {
+        "elementwise": true,
+        "reduction": false,
+        "max_inputs": 2,
+        "constants": "inline"
+    },
+    "requires_feature": "wgpu",
+    "tested": {
+        "unit": "builtins::logical::rel::eq::tests",
+        "integration": "builtins::logical::rel::eq::tests::eq_gpu_provider_roundtrip",
+        "gpu": "builtins::logical::rel::eq::tests::eq_wgpu_matches_host"
+    },
+    "description": "`eq(A, B)` (or the infix `A == B`) performs an element-wise equality comparison. The result is a logical scalar when the broadcasted shape contains one element, or a logical array otherwise.",
+    "behaviors": [
+        "Numeric, logical, and character inputs are compared element-wise using MATLAB's implicit expansion rules.",
+        "Complex numbers are equal only when both their real and imaginary parts match.",
+        "Character arrays compare by Unicode code point; you can mix them with numeric arrays (`'A' == 65`) or strings.",
+        "String scalars and string arrays compare lexically; implicit expansion works across the string dimensions.",
+        "Handle objects compare by identity rather than by structural equality.",
+        "Mixed numeric/string inputs raise MATLAB-compatible type errors."
+    ],
+    "examples": [
+        {
+            "description": "Check If Two Scalars Are Equal",
+            "input": "flag = eq(42, 42)",
+            "output": "flag =\n     1"
+        },
+        {
+            "description": "Compare Two Vectors Element-Wise",
+            "input": "A = [1 2 3 4];\nB = [1 0 3 5];\nmask = eq(A, B)",
+            "output": "mask =\n  1×4 logical array\n     1     0     1     0"
+        },
+        {
+            "description": "Apply Equality With Implicit Expansion",
+            "input": "M = [1 2 3; 4 5 6];\nsel = eq(M, 2)",
+            "output": "sel =\n  2×3 logical array\n     0     1     0\n     0     0     0"
+        },
+        {
+            "description": "Compare Character Data To Numeric Codes",
+            "input": "letters = ['A' 'B' 'C'];\nisA = eq(letters, 65)",
+            "output": "isA =\n  1×3 logical array\n     1     0     0"
+        },
+        {
+            "description": "Compare String Arrays To A Scalar String",
+            "input": "names = [\"alice\" \"bob\" \"alice\"];\nmatches = eq(names, \"alice\")",
+            "output": "matches =\n  1×3 logical array\n     1     0     1"
+        },
+        {
+            "description": "Run `eq` Directly On `gpuArray` Inputs",
+            "input": "G1 = gpuArray([1 2 3]);\nG2 = gpuArray([1 0 3]);\ndeviceResult = eq(G1, G2)\nhostResult = gather(deviceResult)",
+            "output": "deviceResult =\n  1  0  1\nhostResult =\n  1  0  1"
+        }
+    ],
+    "faqs": [
+        {
+            "question": "Does `eq` return logical values?",
+            "answer": "Yes. Scalars return `true` or `false`. Arrays return logical arrays, and `gpuArray` inputs return `gpuArray` logical outputs."
+        },
+        {
+            "question": "How are NaN values treated?",
+            "answer": "`NaN == NaN` evaluates to `false`, matching MATLAB's behaviour."
+        },
+        {
+            "question": "Can I compare complex numbers with `eq`?",
+            "answer": "Yes. Both the real and imaginary parts must match for the comparison to return `true`."
+        },
+        {
+            "question": "Are character vectors treated as numbers or text?",
+            "answer": "Both: they compare numerically (character code) against numeric inputs, and textually when compared to strings or other character arrays."
+        },
+        {
+            "question": "What happens when I mix numeric and string inputs?",
+            "answer": "RunMat raises a MATLAB-compatible error describing the unsupported type combination."
+        },
+        {
+            "question": "Do handle objects compare by value?",
+            "answer": "No. Handles compare by identity: two handles are equal only when they reference the same underlying object."
+        },
+        {
+            "question": "Does implicit expansion apply to string arrays?",
+            "answer": "Yes. String arrays support MATLAB-style implicit expansion, so you can compare against scalar strings without manual replication."
+        },
+        {
+            "question": "Can I chain `eq` inside fused GPU expressions?",
+            "answer": "Yes. The builtin registers element-wise fusion metadata so the planner can fuse comparisons with surrounding GPU-friendly operations."
+        }
+    ],
+    "links": [
+        {
+            "label": "ge",
+            "url": "./ge"
+        },
+        {
+            "label": "gt",
+            "url": "./gt"
+        },
+        {
+            "label": "isequal",
+            "url": "./isequal"
+        },
+        {
+            "label": "le",
+            "url": "./le"
+        },
+        {
+            "label": "lt",
+            "url": "./lt"
+        },
+        {
+            "label": "ne",
+            "url": "./ne"
+        }
+    ],
+    "source": {
+        "label": "`crates/runmat-runtime/src/builtins/logical/rel/eq.rs`",
+        "url": "https://github.com/runmat-org/runmat/blob/main/crates/runmat-runtime/src/builtins/logical/rel/eq.rs"
+    },
+    "gpu_residency": "You usually do **not** need to call `gpuArray` explicitly. RunMat's native auto-offload planner keeps intermediate results on the GPU when fused expressions benefit from device execution. Explicit `gpuArray` and `gather` calls remain available for compatibility with MATLAB code that manages residency manually.",
+    "gpu_behavior": [
+        "When both operands are `gpuArray` values and the active acceleration provider implements the `elem_eq` hook, RunMat executes the comparison entirely on the device and returns a `gpuArray` logical result. If the provider does not expose this hook, the runtime gathers the inputs to host memory automatically and performs the CPU comparison instead of failing."
+    ],
+    "key": "eq",
+    "slug": "eq",
+    "categoryPath": [
+        "logical",
+        "rel"
+    ]
+};
+export default builtinDoc;
+//# sourceMappingURL=eq.js.map

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

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

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

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

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

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