runmat 0.3.6 → 0.4.0

package/dist/generated/builtins/ne.js

@@ -0,0 +1,161 @@
+// @generated by scripts/generate-builtins.cjs
+// Do not edit by hand.
+const builtinDoc = {
+    "title": "ne",
+    "category": "logical/rel",
+    "keywords": [
+        "ne",
+        "~=",
+        "not equal",
+        "logical comparison",
+        "gpuArray inequality"
+    ],
+    "summary": "Element-wise inequality comparison for scalars, arrays, strings, and gpuArray inputs.",
+    "references": [],
+    "gpu_support": {
+        "elementwise": true,
+        "reduction": false,
+        "precisions": [
+            "f32",
+            "f64"
+        ],
+        "broadcasting": "matlab",
+        "notes": "Uses provider elem_ne 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::ne::tests",
+        "integration": "builtins::logical::rel::ne::tests::ne_gpu_provider_roundtrip",
+        "gpu": "builtins::logical::rel::ne::tests::ne_wgpu_matches_host"
+    },
+    "description": "`ne(A, B)` (or the infix `A ~= B`) performs an element-wise inequality 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 considered different when either their real **or** imaginary part differs.",
+        "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": "Checking if two scalars differ",
+            "input": "flag = ne(42, 7)",
+            "output": "flag =\n     1"
+        },
+        {
+            "description": "Finding mismatched elements between vectors",
+            "input": "A = [1 2 3 4];\nB = [1 0 3 5];\nmask = ne(A, B)",
+            "output": "mask =\n  1×4 logical array\n     0     1     0     1"
+        },
+        {
+            "description": "Using implicit expansion for inequality",
+            "input": "M = [1 2 3; 4 5 6];\nsel = ne(M, 2)",
+            "output": "sel =\n  2×3 logical array\n     1     0     1\n     1     1     1"
+        },
+        {
+            "description": "Comparing text values to numeric codes",
+            "input": "letters = ['A' 'B' 'C'];\nnotA = ne(letters, 65)",
+            "output": "notA =\n  1×3 logical array\n     0     1     1"
+        },
+        {
+            "description": "Running `~=` directly on gpuArray inputs",
+            "input": "G1 = gpuArray([1 2 3]);\nG2 = gpuArray([0 2 4]);\ndeviceResult = ne(G1, G2);\nhostResult = gather(deviceResult)",
+            "output": "deviceResult =\n  1×3 gpuArray logical array\n     1     0     1\nhostResult =\n  1×3 logical array\n     1     0     1"
+        }
+    ],
+    "faqs": [
+        {
+            "question": "Does `ne` 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 `true`, matching MATLAB's behaviour because equality comparisons return `false`."
+        },
+        {
+            "question": "Can I compare complex numbers with `ne`?",
+            "answer": "Yes. Results are `true` when either the real or imaginary component differs."
+        },
+        {
+            "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 different unless 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 `ne` inside fused GPU expressions?",
+            "answer": "Yes. The builtin registers element-wise fusion metadata so the planner can fuse inequality checks with surrounding GPU-friendly operations."
+        },
+        {
+            "question": "Is there a shorthand for calling `ne`?",
+            "answer": "Yes. You can use the operator form `A ~= B`, which maps directly to this builtin."
+        }
+    ],
+    "links": [
+        {
+            "label": "`eq`",
+            "url": "./eq"
+        },
+        {
+            "label": "`lt`",
+            "url": "./lt"
+        },
+        {
+            "label": "`gt`",
+            "url": "./gt"
+        },
+        {
+            "label": "`gpuArray`",
+            "url": "./gpuarray"
+        },
+        {
+            "label": "`gather`",
+            "url": "./gather"
+        },
+        {
+            "label": "ge",
+            "url": "./ge"
+        },
+        {
+            "label": "isequal",
+            "url": "./isequal"
+        },
+        {
+            "label": "le",
+            "url": "./le"
+        }
+    ],
+    "source": {
+        "label": "`crates/runmat-runtime/src/builtins/logical/rel/ne.rs`",
+        "url": "https://github.com/runmat-org/runmat/blob/main/crates/runmat-runtime/src/builtins/logical/rel/ne.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_ne` 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": "ne",
+    "slug": "ne",
+    "categoryPath": [
+        "logical",
+        "rel"
+    ]
+};
+export default builtinDoc;
+//# sourceMappingURL=ne.js.map

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

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

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

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

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

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

package/dist/generated/builtins/nnz.js

@@ -0,0 +1,198 @@
+// @generated by scripts/generate-builtins.cjs
+// Do not edit by hand.
+const builtinDoc = {
+    "title": "nnz",
+    "category": "math/reduction",
+    "keywords": [
+        "nnz",
+        "nonzero",
+        "count",
+        "sparsity",
+        "gpu"
+    ],
+    "summary": "Count the number of nonzero elements in an array with MATLAB-compatible semantics.",
+    "references": [],
+    "gpu_support": {
+        "elementwise": false,
+        "reduction": true,
+        "precisions": [
+            "f32",
+            "f64"
+        ],
+        "broadcasting": "matlab",
+        "notes": "Uses provider reduce_nnz / reduce_nnz_dim kernels when available and gathers results to the host for MATLAB-compatible doubles."
+    },
+    "fusion": {
+        "elementwise": false,
+        "reduction": true,
+        "max_inputs": 1,
+        "constants": "inline"
+    },
+    "requires_feature": null,
+    "tested": {
+        "unit": "builtins::math::reduction::nnz::tests::nnz_tensor_counts_entries",
+        "integration": "builtins::math::reduction::nnz::tests::nnz_gpu_provider_roundtrip",
+        "gpu": "builtins::math::reduction::nnz::tests::nnz_wgpu_dim_matches_cpu"
+    },
+    "description": "`nnz(X)` returns the number of elements of `X` that are nonzero. The result is always a double-precision value, matching MATLAB, and the builtin works for dense tensors, logical arrays, complex inputs, and character data.",
+    "behaviors": [
+        "`nnz(X)` treats any value that is not exactly zero as nonzero. Both `NaN` and `Inf` therefore contribute to the total.",
+        "Complex numbers are counted when either the real or imaginary part is nonzero (including `NaN`).",
+        "Logical arrays (`logical`) are summed as if `true` were `1` and `false` were `0`.",
+        "Character arrays use their code points; only the null character (`char(0)`) is considered zero.",
+        "Empty arrays return `0` because no elements are nonzero.",
+        "`nnz(X, dim)` counts nonzeros along the specified dimension, returning a tensor whose size in that dimension becomes `1` (mirroring `sum(X ~= 0, dim)`).",
+        "Dimensions larger than `ndims(X)` leave the result unchanged, again following MATLAB's reduction rules for singleton trailing dimensions."
+    ],
+    "examples": [
+        {
+            "description": "Counting nonzero elements in a dense matrix",
+            "input": "A = [1 0 3; 0 0 5];\ncount = nnz(A)",
+            "output": "count = 3"
+        },
+        {
+            "description": "Counting nonzero entries in each column",
+            "input": "A = [1 0 3; 0 7 5];\nperColumn = nnz(A, 1)",
+            "output": "perColumn = [1 1 2]"
+        },
+        {
+            "description": "Counting nonzero entries in each row",
+            "input": "A = [1 0 3; 0 7 0];\nperRow = nnz(A, 2)",
+            "output": "perRow = [2; 1]"
+        },
+        {
+            "description": "Recognising `NaN` values as nonzero",
+            "input": "values = [0 NaN 5];\nnanCount = nnz(values)",
+            "output": "nanCount = 2"
+        },
+        {
+            "description": "Counting GPU-resident values without manual gathers",
+            "input": "G = gpuArray([1 0 2 0 3]);\ngpuCount = nnz(G)",
+            "output": "gpuCount = 3"
+        }
+    ],
+    "faqs": [
+        {
+            "question": "When should I use the `nnz` function?",
+            "answer": "Use `nnz` whenever you need a quick count of nonzero elements—for example when measuring sparsity or validating that an algorithm produced the expected number of nonzeros."
+        },
+        {
+            "question": "What data types does `nnz` support?",
+            "answer": "Numeric, logical, complex, and character arrays are supported. Other types (structs, cell arrays, strings, objects) raise descriptive errors, as in MATLAB."
+        },
+        {
+            "question": "Does `nnz` treat `NaN` as nonzero?",
+            "answer": "Yes. Because `NaN ~= 0`, each `NaN` contributes to the result."
+        },
+        {
+            "question": "How can I count nonzeros along a dimension?",
+            "answer": "Use `nnz(X, dim)`—it behaves like `sum(X ~= 0, dim)` and returns a tensor whose size in the specified dimension becomes `1`."
+        },
+        {
+            "question": "What does `nnz` return for logical arrays?",
+            "answer": "It returns the number of `true` elements, effectively behaving like `sum(logicalArray)`."
+        },
+        {
+            "question": "Does `nnz` work with GPU arrays?",
+            "answer": "Yes. The builtin dispatches to provider kernels when possible and downloads the MATLAB-compatible double result. When a provider lacks specialised kernels, RunMat gathers the tensor and counts on the CPU."
+        },
+        {
+            "question": "How does `nnz` handle character arrays?",
+            "answer": "Characters are converted to their numeric code points; any character other than the null character counts as nonzero."
+        },
+        {
+            "question": "Can the result exceed double precision?",
+            "answer": "Counts are stored in double precision (like MATLAB). Extremely large arrays share MATLAB's limitation where values above `2^53` may lose the least significant bit, but RunMat still returns a finite double."
+        }
+    ],
+    "links": [
+        {
+            "label": "sum",
+            "url": "./sum"
+        },
+        {
+            "label": "any",
+            "url": "./any"
+        },
+        {
+            "label": "find",
+            "url": "./find"
+        },
+        {
+            "label": "gpuArray",
+            "url": "./gpuarray"
+        },
+        {
+            "label": "gather",
+            "url": "./gather"
+        },
+        {
+            "label": "all",
+            "url": "./all"
+        },
+        {
+            "label": "cummax",
+            "url": "./cummax"
+        },
+        {
+            "label": "cummin",
+            "url": "./cummin"
+        },
+        {
+            "label": "cumprod",
+            "url": "./cumprod"
+        },
+        {
+            "label": "cumsum",
+            "url": "./cumsum"
+        },
+        {
+            "label": "diff",
+            "url": "./diff"
+        },
+        {
+            "label": "max",
+            "url": "./max"
+        },
+        {
+            "label": "mean",
+            "url": "./mean"
+        },
+        {
+            "label": "median",
+            "url": "./median"
+        },
+        {
+            "label": "min",
+            "url": "./min"
+        },
+        {
+            "label": "prod",
+            "url": "./prod"
+        },
+        {
+            "label": "std",
+            "url": "./std"
+        },
+        {
+            "label": "var",
+            "url": "./var"
+        }
+    ],
+    "source": {
+        "label": "`crates/runmat-runtime/src/builtins/math/reduction/nnz.rs`",
+        "url": "https://github.com/runmat-org/runmat/blob/main/crates/runmat-runtime/src/builtins/math/reduction/nnz.rs"
+    },
+    "gpu_residency": "You usually do **not** need to call `gpuArray` explicitly. RunMat's auto-offload planner tracks residency automatically. For `nnz`, the runtime inspects the active provider and, when available, invokes device-side reduction kernels to count nonzeros on the GPU before downloading the final result. When a provider cannot supply those kernels, RunMat gathers the tensor and computes on the CPU, preserving MATLAB semantics.",
+    "gpu_behavior": [
+        "When RunMat Accelerate is active, `nnz` keeps work on the GPU whenever the provider implements `reduce_nnz` / `reduce_nnz_dim`. The WGPU provider ships with dedicated kernels that count nonzero elements without gathering intermediate data. The resulting scalar or tensor is then downloaded to the host so the return value matches MATLAB's CPU-resident doubles. If a provider lacks these hooks RunMat falls back to gathering the input and computing on the CPU."
+    ],
+    "key": "nnz",
+    "slug": "nnz",
+    "categoryPath": [
+        "math",
+        "reduction"
+    ]
+};
+export default builtinDoc;
+//# sourceMappingURL=nnz.js.map

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

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

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

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

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

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

package/dist/generated/builtins/norm.js

@@ -0,0 +1,167 @@
+// @generated by scripts/generate-builtins.cjs
+// Do not edit by hand.
+const builtinDoc = {
+    "title": "norm",
+    "category": "math/linalg/solve",
+    "keywords": [
+        "norm",
+        "vector norm",
+        "matrix norm",
+        "frobenius",
+        "nuclear",
+        "gpu"
+    ],
+    "summary": "Compute vector and matrix norms with MATLAB-compatible semantics, including Frobenius and nuclear norms.",
+    "references": [
+        "https://www.mathworks.com/help/matlab/ref/norm.html"
+    ],
+    "gpu_support": {
+        "elementwise": false,
+        "reduction": true,
+        "precisions": [
+            "f32",
+            "f64"
+        ],
+        "broadcasting": "none",
+        "notes": "RunMat gathers to the host when specialized provider hooks are unavailable; providers may add custom norm kernels in the future."
+    },
+    "fusion": {
+        "elementwise": false,
+        "reduction": false,
+        "max_inputs": 1,
+        "constants": "inline"
+    },
+    "requires_feature": null,
+    "tested": {
+        "unit": "builtins::math::linalg::solve::norm::tests",
+        "gpu": "builtins::math::linalg::solve::norm::tests::norm_gpu_roundtrip_matches_cpu",
+        "wgpu": "builtins::math::linalg::solve::norm::tests::norm_wgpu_matches_cpu"
+    },
+    "description": "`norm(X)` returns the magnitude of vectors and matrices. For vectors it defaults to the Euclidean 2-norm. For matrices it defaults to the spectral norm (largest singular value). Alternate norms — such as the 1-norm, infinity norm, Frobenius norm, and nuclear norm — are selected with the second argument.\n\n- `norm(X)` and `norm(X, 2)` compute the Euclidean norm for vectors and the largest singular value for matrices. - `norm(X, 1)` is the maximum absolute column sum of `X`. - `norm(X, Inf)` is the maximum absolute row sum of `X`; `norm(x, -Inf)` returns the minimum absolute element for vectors. - `norm(X, 'fro')` is the Frobenius norm, equivalent to treating the matrix as a vector and applying the 2-norm. - `norm(X, 'nuc')` is the nuclear norm (sum of singular values) for matrices. - `norm(x, p)` accepts any real scalar `p ≥ 1` for vectors (plus the special cases `0`, `Inf`, `-Inf`), matching MATLAB’s behavior. - Inputs must be vectors or 2-D matrices. Higher-dimensional arrays raise an error. - Empty inputs (e.g., `[]` or matrices with a zero dimension) return `0`. - Logical and integer inputs are promoted to double precision before the norm is computed. - Complex values use the magnitude of each entry, and the final result is always a non-negative real scalar.",
+    "behaviors": [],
+    "examples": [
+        {
+            "description": "Computing the Euclidean norm of a vector",
+            "input": "x = [3 4];\nmag = norm(x)",
+            "output": "mag = 5"
+        },
+        {
+            "description": "Calculating the Frobenius norm of a matrix",
+            "input": "A = [1 -2 3; -4 5 -6];\nf = norm(A, 'fro')",
+            "output": "f = 9.5394"
+        },
+        {
+            "description": "Using the infinity norm for robust bounds",
+            "input": "x = [2 -7 4];\nbound = norm(x, Inf)",
+            "output": "bound = 7"
+        },
+        {
+            "description": "Summing singular values with the nuclear norm",
+            "input": "A = [2 0 0; 0 1 0];\ntau = norm(A, 'nuc')",
+            "output": "tau = 3"
+        },
+        {
+            "description": "Computing the norm of complex-valued data",
+            "input": "z = [1+2i 3-4i];\nmag = norm(z)",
+            "output": "mag = 5.4772"
+        },
+        {
+            "description": "Preserving GPU residency transparently",
+            "input": "G = gpuArray([3 4 12]);\nmag = norm(G);      % falls back to CPU today; future providers can stay on device",
+            "output": "mag = 13"
+        }
+    ],
+    "faqs": [
+        {
+            "question": "What is the difference between `norm(x)` and `norm(x, 2)`?",
+            "answer": "No difference. Both compute the Euclidean norm for vectors (or the spectral norm for matrices)."
+        },
+        {
+            "question": "Does `norm` support fractional powers?",
+            "answer": "Yes. For vectors you can pass any non-zero real scalar `p`, including fractional values. MATLAB’s special cases (`p = 0`, `Inf`, `-Inf`) are also supported."
+        },
+        {
+            "question": "Can I use `norm` on complex matrices?",
+            "answer": "Absolutely. RunMat mirrors MATLAB by computing singular values in complex arithmetic and always returning a non-negative real scalar."
+        },
+        {
+            "question": "When should I use `'fro'` versus `'nuc'`?",
+            "answer": "`'fro'` returns the square root of the sum of squares (robust and inexpensive). `'nuc'` sums singular values and is particularly useful in low-rank optimization problems."
+        },
+        {
+            "question": "Why does `norm` of an empty matrix return `0`?",
+            "answer": "That matches MATLAB’s convention: the sum over an empty set is zero, so every supported norm returns `0` for empty inputs."
+        },
+        {
+            "question": "Can the norm overflow or underflow?",
+            "answer": "Yes. The result obeys IEEE-754 double precision rules, just like MATLAB. Extremely large or tiny values may overflow to `Inf` or underflow toward zero."
+        },
+        {
+            "question": "Will the result stay on the GPU?",
+            "answer": "The current in-process provider gathers the tensor to host memory. Providers that implement custom norm kernels can keep the computation entirely on device without user-visible changes."
+        }
+    ],
+    "links": [
+        {
+            "label": "sum",
+            "url": "./sum"
+        },
+        {
+            "label": "svd",
+            "url": "./svd"
+        },
+        {
+            "label": "cond",
+            "url": "./cond"
+        },
+        {
+            "label": "pinv",
+            "url": "./pinv"
+        },
+        {
+            "label": "gpuArray",
+            "url": "./gpuarray"
+        },
+        {
+            "label": "gather",
+            "url": "./gather"
+        },
+        {
+            "label": "det",
+            "url": "./det"
+        },
+        {
+            "label": "inv",
+            "url": "./inv"
+        },
+        {
+            "label": "linsolve",
+            "url": "./linsolve"
+        },
+        {
+            "label": "rank",
+            "url": "./rank"
+        },
+        {
+            "label": "rcond",
+            "url": "./rcond"
+        }
+    ],
+    "source": {
+        "label": "`crates/runmat-runtime/src/builtins/math/linalg/solve/norm.rs`",
+        "url": "https://github.com/runmat-org/runmat/blob/main/crates/runmat-runtime/src/builtins/math/linalg/solve/norm.rs"
+    },
+    "gpu_residency": "```matlab:runnable\nG = gpuArray([3 4 12]);\nmag = norm(G);      % falls back to CPU today; future providers can stay on device\n```\nExpected output:\n```matlab\nmag = 13\n```",
+    "gpu_behavior": [
+        "When an acceleration provider is active, RunMat keeps GPU inputs resident. If the provider exposes a dedicated norm hook in the future it can execute entirely on the device. Until then RunMat gathers the input tensor to the host, computes the norm with the shared CPU implementation, and returns the scalar result. This mirrors MATLAB semantics while guaranteeing correctness even in the absence of specialized kernels."
+    ],
+    "key": "norm",
+    "slug": "norm",
+    "categoryPath": [
+        "math",
+        "linalg",
+        "solve"
+    ]
+};
+export default builtinDoc;
+//# sourceMappingURL=norm.js.map

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

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

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

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

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

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