runmat 0.3.6 → 0.4.0

package/dist/generated/builtins/area.js

@@ -0,0 +1,104 @@
+// @generated by scripts/generate-builtins.cjs
+// Do not edit by hand.
+const builtinDoc = {
+    "title": "area",
+    "category": "plotting",
+    "keywords": [
+        "area",
+        "area plot",
+        "filled area chart",
+        "stacked area chart",
+        "matlab area",
+        "cumulative area visualization"
+    ],
+    "summary": "Create filled area plots for cumulative totals, stacked series, and MATLAB `area` workflows.",
+    "gpu_support": {
+        "elementwise": false,
+        "reduction": false,
+        "precisions": [
+            "single",
+            "double"
+        ],
+        "broadcasting": "none",
+        "notes": "`area` uses a GPU-backed geometry path, including stacked-series geometry generation."
+    },
+    "fusion": {
+        "elementwise": false,
+        "reduction": false,
+        "max_inputs": 2,
+        "constants": "inline"
+    },
+    "requires_feature": null,
+    "tested": {
+        "unit": "builtins::plotting::area::tests",
+        "integration": "runmat-plot/src/gpu/area.rs::tests"
+    },
+    "description": "`area` creates filled area plots from vector or matrix-style inputs. In RunMat it returns an area-handle object, supports baseline-based and stacked-series workflows, and uses GPU-backed geometry generation together with the shared plotting object and rendering systems.",
+    "behaviors": [
+        "`area(y)` uses implicit x-values `1:n`, while `area(x, y)` uses explicit x coordinates.",
+        "Matrix-style `y` inputs create stacked area series in the MATLAB style.",
+        "The returned value is an area-handle object that works with `get` and `set`.",
+        "Baseline and color workflows flow through the shared plotting property model.",
+        "Stacked-series geometry can be emitted directly from GPU buffers on the happy path."
+    ],
+    "options": [
+        "`'BaseValue'` sets the baseline used by area filling.",
+        "Color and display-name workflows are available through the returned handle and the shared plotting property path."
+    ],
+    "examples": [
+        {
+            "description": "Create a basic filled area plot",
+            "input": "x = 0:0.1:1;\narea(x, x.^2);"
+        },
+        {
+            "description": "Create stacked area series from a matrix",
+            "input": "x = 1:5;\nY = [1 2 1; 2 1 2; 3 2 1; 2 3 2; 1 2 3];\narea(x, Y);"
+        },
+        {
+            "description": "Change the baseline and label the series through the handle",
+            "input": "x = 0:0.2:2;\nh = area(x, sin(x) + 2);\nset(h, 'BaseValue', 1, 'DisplayName', 'offset area');\nlegend;"
+        }
+    ],
+    "links": [
+        {
+            "label": "quiver",
+            "url": "./quiver"
+        },
+        {
+            "label": "bar",
+            "url": "./bar"
+        },
+        {
+            "label": "plot",
+            "url": "./plot"
+        },
+        {
+            "label": "legend",
+            "url": "./legend"
+        },
+        {
+            "label": "get",
+            "url": "./get"
+        },
+        {
+            "label": "set",
+            "url": "./set"
+        }
+    ],
+    "source": {
+        "label": "`crates/runmat-runtime/src/builtins/plotting/ops/area.rs`",
+        "url": "https://github.com/runmat-org/runmat/blob/main/crates/runmat-runtime/src/builtins/plotting/ops/area.rs"
+    },
+    "gpu_residency": "`area` preserves GPU residency on the direct path, including stacked-series geometry generation. Fallback rendering still preserves the same visible semantics and handle behavior when a direct GPU path is not available.",
+    "gpu_behavior": [
+        "The direct area path emits filled geometry from GPU data on the happy path.",
+        "Baseline semantics, stacked-series behavior, and handle/property workflows remain aligned across GPU and fallback paths."
+    ],
+    "key": "area",
+    "slug": "area",
+    "categoryPath": [
+        "plotting"
+    ]
+};
+export default builtinDoc;
+//# sourceMappingURL=area.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"area.js","sourceRoot":"","sources":["../../../src/generated/builtins/area.ts"],"names":[],"mappings":"AAAA,8CAA8C;AAC9C,uBAAuB;AAIvB,MAAM,UAAU,GAAe;IAC7B,OAAO,EAAE,MAAM;IACf,UAAU,EAAE,UAAU;IACtB,UAAU,EAAE;QACV,MAAM;QACN,WAAW;QACX,mBAAmB;QACnB,oBAAoB;QACpB,aAAa;QACb,+BAA+B;KAChC;IACD,SAAS,EAAE,8FAA8F;IACzG,aAAa,EAAE;QACb,aAAa,EAAE,KAAK;QACpB,WAAW,EAAE,KAAK;QAClB,YAAY,EAAE;YACZ,QAAQ;YACR,QAAQ;SACT;QACD,cAAc,EAAE,MAAM;QACtB,OAAO,EAAE,uFAAuF;KACjG;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,iCAAiC;QACzC,aAAa,EAAE,oCAAoC;KACpD;IACD,aAAa,EAAE,gRAAgR;IAC/R,WAAW,EAAE;QACX,yFAAyF;QACzF,yEAAyE;QACzE,8EAA8E;QAC9E,+EAA+E;QAC/E,qFAAqF;KACtF;IACD,SAAS,EAAE;QACT,uDAAuD;QACvD,mHAAmH;KACpH;IACD,UAAU,EAAE;QACV;YACE,aAAa,EAAE,iCAAiC;YAChD,OAAO,EAAE,8BAA8B;SACxC;QACD;YACE,aAAa,EAAE,0CAA0C;YACzD,OAAO,EAAE,iEAAiE;SAC3E;QACD;YACE,aAAa,EAAE,6DAA6D;YAC5E,OAAO,EAAE,wGAAwG;SAClH;KACF;IACD,OAAO,EAAE;QACP;YACE,OAAO,EAAE,QAAQ;YACjB,KAAK,EAAE,UAAU;SAClB;QACD;YACE,OAAO,EAAE,KAAK;YACd,KAAK,EAAE,OAAO;SACf;QACD;YACE,OAAO,EAAE,MAAM;YACf,KAAK,EAAE,QAAQ;SAChB;QACD;YACE,OAAO,EAAE,QAAQ;YACjB,KAAK,EAAE,UAAU;SAClB;QACD;YACE,OAAO,EAAE,KAAK;YACd,KAAK,EAAE,OAAO;SACf;QACD;YACE,OAAO,EAAE,KAAK;YACd,KAAK,EAAE,OAAO;SACf;KACF;IACD,QAAQ,EAAE;QACR,OAAO,EAAE,2DAA2D;QACpE,KAAK,EAAE,wGAAwG;KAChH;IACD,eAAe,EAAE,6NAA6N;IAC9O,cAAc,EAAE;QACd,6EAA6E;QAC7E,0HAA0H;KAC3H;IACD,KAAK,EAAE,MAAM;IACb,MAAM,EAAE,MAAM;IACd,cAAc,EAAE;QACd,UAAU;KACX;CACF,CAAC;AAEF,eAAe,UAAU,CAAC"}

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

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

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

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

@@ -0,0 +1,180 @@
+// @generated by scripts/generate-builtins.cjs
+// Do not edit by hand.
+const builtinDoc = {
+    "title": "argsort",
+    "category": "array/sorting_sets",
+    "keywords": [
+        "argsort",
+        "sort",
+        "indices",
+        "permutation",
+        "gpu"
+    ],
+    "summary": "Return the permutation indices that would sort tensors along a dimension.",
+    "references": [
+        "https://www.mathworks.com/help/matlab/ref/sort.html"
+    ],
+    "gpu_support": {
+        "elementwise": false,
+        "reduction": false,
+        "precisions": [
+            "f32",
+            "f64"
+        ],
+        "broadcasting": "none",
+        "notes": "Uses the same sort kernels as `sort`; falls back to host evaluation when the provider lacks `sort_dim`."
+    },
+    "fusion": {
+        "elementwise": false,
+        "reduction": false,
+        "max_inputs": 1,
+        "constants": "inline"
+    },
+    "requires_feature": null,
+    "tested": {
+        "unit": "builtins::array::sorting_sets::argsort::tests",
+        "integration": "builtins::array::sorting_sets::argsort::tests::argsort_gpu_roundtrip"
+    },
+    "description": "`argsort(X)` returns the permutation indices that order `X` the same way `sort(X)` would. It matches the indices produced by `[~, I] = sort(X, ...)` in MathWorks MATLAB and honours the same argument forms for dimensions, directions, and comparison methods.",
+    "behaviors": [
+        "Operates along the first non-singleton dimension by default. Pass a dimension argument to override.",
+        "Accepts the same direction keywords as `sort`: `'ascend'` (default) or `'descend'`.",
+        "Supports `'ComparisonMethod'` values `'auto'`, `'real'`, and `'abs'` for real and complex inputs.",
+        "Returns indices as double-precision tensors using MATLAB's one-based indexing.",
+        "Treats NaN values as missing: they appear at the end for ascending permutations and at the beginning for descending permutations.",
+        "Acts as a residency sink. GPU tensors are gathered when the active provider does not expose a specialised sort kernel."
+    ],
+    "examples": [
+        {
+            "description": "Getting indices that sort a vector",
+            "input": "A = [4; 1; 3];\nidx = argsort(A)",
+            "output": "idx =\n     2\n     3\n     1"
+        },
+        {
+            "description": "Reordering data with the permutation indices",
+            "input": "A = [3 9 1 5];\nidx = argsort(A);\nsorted = A(idx)",
+            "output": "sorted =\n     1     3     5     9"
+        },
+        {
+            "description": "Sorting along a specific dimension",
+            "input": "A = [1 6 4; 2 3 5];\nidx = argsort(A, 2)",
+            "output": "idx =\n     1     3     2\n     1     2     3"
+        },
+        {
+            "description": "Descending order permutations",
+            "input": "A = [10 4 7 9];\nidx = argsort(A, 'descend')",
+            "output": "idx =\n     1     4     3     2"
+        },
+        {
+            "description": "Using `ComparisonMethod` to sort by magnitude",
+            "input": "A = [-8 -1 3 -2];\nidx = argsort(A, 'ComparisonMethod', 'abs')",
+            "output": "idx =\n     2     4     3     1"
+        },
+        {
+            "description": "Handling NaN values during permutation",
+            "input": "A = [NaN 4 1 2];\nidx = argsort(A)",
+            "output": "idx =\n     3     4     2     1"
+        },
+        {
+            "description": "Argsort on GPU tensors falls back gracefully",
+            "input": "G = gpuArray(randn(5, 1));\nidx = argsort(G)"
+        }
+    ],
+    "faqs": [
+        {
+            "question": "How is `argsort` different from `sort`?",
+            "answer": "`argsort` returns only the permutation indices. It behaves like calling `[~, I] = sort(X, ...)` without materialising the sorted values."
+        },
+        {
+            "question": "Are the indices one-based like MATLAB?",
+            "answer": "Yes. All indices follow MATLAB's one-based convention so they can be used directly with subsequent indexing operations."
+        },
+        {
+            "question": "Does `argsort` support the same arguments as `sort`?",
+            "answer": "Yes. Dimension arguments, direction keywords, and `'ComparisonMethod'` behave exactly like they do for `sort`."
+        },
+        {
+            "question": "How are NaN values ordered?",
+            "answer": "NaNs are treated as missing. They appear at the end for ascending permutations and at the beginning for descending permutations, matching MATLAB."
+        },
+        {
+            "question": "Can I call `argsort` on GPU arrays?",
+            "answer": "Yes. When the active provider implements the `sort_dim` hook, permutations stay on the device. Otherwise tensors are gathered automatically and sorted on the host."
+        },
+        {
+            "question": "Is the permutation stable?",
+            "answer": "Yes. Equal elements keep their relative order so that `argsort` remains consistent with MATLAB's stable sorting semantics."
+        },
+        {
+            "question": "What type is returned?",
+            "answer": "A double-precision tensor (or scalar) with the same shape as the input, containing permutation indices."
+        },
+        {
+            "question": "Does `argsort` mutate its input?",
+            "answer": "No. It only returns indices. Combine the result with indexing (`A(idx)`) to obtain reordered values when needed."
+        }
+    ],
+    "links": [
+        {
+            "label": "sort",
+            "url": "./sort"
+        },
+        {
+            "label": "sortrows",
+            "url": "./sortrows"
+        },
+        {
+            "label": "randperm",
+            "url": "./randperm"
+        },
+        {
+            "label": "max",
+            "url": "./max"
+        },
+        {
+            "label": "min",
+            "url": "./min"
+        },
+        {
+            "label": "intersect",
+            "url": "./intersect"
+        },
+        {
+            "label": "ismember",
+            "url": "./ismember"
+        },
+        {
+            "label": "issorted",
+            "url": "./issorted"
+        },
+        {
+            "label": "setdiff",
+            "url": "./setdiff"
+        },
+        {
+            "label": "union",
+            "url": "./union"
+        },
+        {
+            "label": "unique",
+            "url": "./unique"
+        }
+    ],
+    "source": {
+        "label": "`crates/runmat-runtime/src/builtins/array/sorting_sets/argsort.rs`",
+        "url": "https://github.com/runmat-org/runmat/blob/main/crates/runmat-runtime/src/builtins/array/sorting_sets/argsort.rs"
+    },
+    "gpu_behavior": [
+        "`argsort` shares the `sort_dim` provider hook with the `sort` builtin. When implemented, indices are computed without leaving the device.",
+        "If the provider lacks `sort_dim`, RunMat gathers tensors to host memory, evaluates the permutation, and returns host-resident indices.",
+        "Outputs are always host-resident double tensors because permutation indices are consumed immediately by host-side logic (e.g., indexing)."
+    ],
+    "key": "argsort",
+    "slug": "argsort",
+    "categoryPath": [
+        "array",
+        "sorting_sets"
+    ]
+};
+export default builtinDoc;
+//# sourceMappingURL=argsort.js.map

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

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

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

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

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

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

package/dist/generated/builtins/arrayfun.js

@@ -0,0 +1,138 @@
+// @generated by scripts/generate-builtins.cjs
+// Do not edit by hand.
+const builtinDoc = {
+    "title": "arrayfun",
+    "category": "acceleration/gpu",
+    "keywords": [
+        "arrayfun",
+        "gpuArray",
+        "elementwise map",
+        "anonymous function",
+        "uniformoutput"
+    ],
+    "summary": "Apply a function to each element of array inputs, returning either a numeric array or a cell array.",
+    "references": [
+        "https://www.mathworks.com/help/parallel-computing/arrayfun.html"
+    ],
+    "gpu_support": {
+        "elementwise": true,
+        "reduction": false,
+        "precisions": [
+            "f32",
+            "f64"
+        ],
+        "broadcasting": "matlab",
+        "notes": "Executes directly on the GPU for supported builtin callbacks (sin, cos, abs, exp, log, sqrt, plus, minus, times, rdivide, ldivide) when all inputs are gpuArray values; falls back to host execution for closures, heterogeneous inputs, or unsupported callbacks. Uniform numeric/logical outputs are re-uploaded to the GPU otherwise; complex/character outputs stay on the host."
+    },
+    "fusion": {
+        "elementwise": false,
+        "reduction": false,
+        "max_inputs": 1,
+        "constants": "inline"
+    },
+    "requires_feature": null,
+    "tested": {
+        "unit": "builtins::acceleration::gpu::arrayfun::tests",
+        "integration": "builtins::acceleration::gpu::arrayfun::tests::arrayfun_gpu_roundtrip"
+    },
+    "description": "`arrayfun(func, A1, A2, …)` evaluates `func` for every element (or element-wise combination) of the supplied arrays. The builtin mirrors MATLAB's behaviour:\n\n- Inputs must have the same size. Scalars participate by broadcasting their single value. - The optional `'UniformOutput'` name-value flag controls whether results are collected into a numeric/complex/logical/character array (`true`, the default) or returned as a cell array (`false`). - When `'ErrorHandler', handler` is supplied the handler receives the error struct and the arguments that triggered the failure, letting you supply a fallback result.",
+    "behaviors": [
+        "Accepts function handles, builtin names (character vectors or string scalars), and closures.",
+        "Supports additional scalar parameters: `arrayfun(@(x,c) x + c, A, 5)` passes `5` to every call.",
+        "Honors the `'UniformOutput'` and `'ErrorHandler'` name-value pairs for MATLAB-compatible control flow.",
+        "Handles numeric, logical, character, and complex arrays. Unsupported types raise a descriptive error instructing you to use `cellfun` when appropriate.",
+        "Empty inputs return empty outputs whose shape matches the first array argument.",
+        "When any input is a `gpuArray`, numeric or logical uniform outputs are uploaded back to the GPU so downstream code retains GPU residency. Complex or character uniform outputs remain on the host until providers add the appropriate buffer support. The current implementation computes on the host and therefore inherits the host's floating-point behaviour."
+    ],
+    "examples": [
+        {
+            "description": "Squaring every element of a matrix",
+            "input": "A = [1 2 3; 4 5 6];\nB = arrayfun(@(x) x.^2, A)",
+            "output": "B =\n     1     4     9\n    16    25    36"
+        },
+        {
+            "description": "Passing additional scalar parameters",
+            "input": "A = [1 2 3];\noffset = 10;\nresult = arrayfun(@(x, c) x + c, A, offset)",
+            "output": "result =\n    11    12    13"
+        },
+        {
+            "description": "Returning cells with non-uniform outputs",
+            "input": "strings = [\"Run\" \"Matlab\" \"GPU\"];\nchars = arrayfun(@(s) sprintf(\"%d\", strlength(s)), strings, 'UniformOutput', false)",
+            "output": "chars =\n  1×3 cell array\n    {'3'}    {'6'}    {'3'}"
+        },
+        {
+            "description": "Handling errors with a custom error handler",
+            "input": "vals = [-1 0 1];\nhandler = @(err, x) err.identifier;\nsafe = arrayfun(@(x) sqrt(x), vals, 'ErrorHandler', handler, 'UniformOutput', false)",
+            "output": "safe =\n  1×3 cell array\n    {[0+1i]}    {[0]}    {[1]}"
+        },
+        {
+            "description": "Working with `gpuArray` inputs",
+            "input": "G = gpuArray(linspace(0, pi, 5));\nS = arrayfun(@sin, G);\nH = gather(S)",
+            "output": "H =\n         0    0.7071    1.0000    0.7071         0"
+        }
+    ],
+    "faqs": [
+        {
+            "question": "Do I have to call `gpuArray` before using `arrayfun`?",
+            "answer": "No. `arrayfun` participates in the same planner as other builtins, so the runtime migrates data to the GPU when it determines a benefit. Manual `gpuArray` calls remain useful for MATLAB compatibility or to force residency for custom workflows."
+        },
+        {
+            "question": "What happens when the callback returns mixed types?",
+            "answer": "Set `'UniformOutput', false` so the builtin returns a cell array. When `'UniformOutput'` is `true` every callback invocation must return a numeric, logical, or complex scalar."
+        },
+        {
+            "question": "Can `arrayfun` handle character inputs?",
+            "answer": "Yes. Each character element is passed to the callback as a single-character char array and the output follows the normal uniform/non-uniform rules."
+        },
+        {
+            "question": "Does `arrayfun` short-circuit on errors?",
+            "answer": "No. The builtin invokes the optional error handler when a callback fails. If no handler is provided the first error aborts the entire call with a MATLAB-compatible identifier/message pair."
+        },
+        {
+            "question": "How are logical outputs represented on the GPU?",
+            "answer": "Logical results use 0.0/1.0 buffers on the device. When you gather them RunMat converts the data back into a logical array automatically."
+        }
+    ],
+    "links": [
+        {
+            "label": "cellfun",
+            "url": "./cellfun"
+        },
+        {
+            "label": "gpuArray",
+            "url": "./gpuarray"
+        },
+        {
+            "label": "gather",
+            "url": "./gather"
+        },
+        {
+            "label": "gpuDevice",
+            "url": "./gpudevice"
+        },
+        {
+            "label": "gpuInfo",
+            "url": "./gpuinfo"
+        },
+        {
+            "label": "pagefun",
+            "url": "./pagefun"
+        }
+    ],
+    "source": {
+        "label": "`crates/runmat-runtime/src/builtins/acceleration/gpu/arrayfun.rs`",
+        "url": "https://github.com/runmat-org/runmat/blob/main/crates/runmat-runtime/src/builtins/acceleration/gpu/arrayfun.rs"
+    },
+    "gpu_residency": "No. RunMat's auto-offload logic moves tensors to the GPU when profitable. If you do call `gpuArray`, `arrayfun` keeps the result on the GPU for uniform numeric or logical outputs so later operations can continue without gathering. Non-uniform or complex/character results stay on the host until GPU representations are available.",
+    "gpu_behavior": [
+        "When every input is a `gpuArray`, `'UniformOutput'` is `true`, and the callback resolves to one of the supported builtins (`sin`, `cos`, `abs`, `exp`, `log`, `sqrt`, `plus`, `minus`, `times`, `rdivide`, or `ldivide`), RunMat bypasses the host path and dispatches directly to the active provider through the corresponding hooks (`unary_*` or `elem_*`). The builtin acts as a fusion barrier—the fusion planner lowers upstream producers before invoking `arrayfun` because the callback can evaluate arbitrary MATLAB code.\n\nAll other combinations—including closures, callbacks with extra scalar parameters, mixed residency, or `'UniformOutput', false`—gather inputs to the host, execute the callback element-wise, and then upload numeric or logical uniform results back to the GPU so later code continues with device residency. Complex and character uniform outputs remain host-resident until device representations are available. Cell outputs are always host-resident."
+    ],
+    "key": "arrayfun",
+    "slug": "arrayfun",
+    "categoryPath": [
+        "acceleration",
+        "gpu"
+    ]
+};
+export default builtinDoc;
+//# sourceMappingURL=arrayfun.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"arrayfun.js","sourceRoot":"","sources":["../../../src/generated/builtins/arrayfun.ts"],"names":[],"mappings":"AAAA,8CAA8C;AAC9C,uBAAuB;AAIvB,MAAM,UAAU,GAAe;IAC7B,OAAO,EAAE,UAAU;IACnB,UAAU,EAAE,kBAAkB;IAC9B,UAAU,EAAE;QACV,UAAU;QACV,UAAU;QACV,iBAAiB;QACjB,oBAAoB;QACpB,eAAe;KAChB;IACD,SAAS,EAAE,qGAAqG;IAChH,YAAY,EAAE;QACZ,iEAAiE;KAClE;IACD,aAAa,EAAE;QACb,aAAa,EAAE,IAAI;QACnB,WAAW,EAAE,KAAK;QAClB,YAAY,EAAE;YACZ,KAAK;YACL,KAAK;SACN;QACD,cAAc,EAAE,QAAQ;QACxB,OAAO,EAAE,sXAAsX;KAChY;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,8CAA8C;QACtD,aAAa,EAAE,sEAAsE;KACtF;IACD,aAAa,EAAE,smBAAsmB;IACrnB,WAAW,EAAE;QACX,8FAA8F;QAC9F,iGAAiG;QACjG,wGAAwG;QACxG,yJAAyJ;QACzJ,iFAAiF;QACjF,mWAAmW;KACpW;IACD,UAAU,EAAE;QACV;YACE,aAAa,EAAE,oCAAoC;YACnD,OAAO,EAAE,iDAAiD;YAC1D,QAAQ,EAAE,6CAA6C;SACxD;QACD;YACE,aAAa,EAAE,sCAAsC;YACrD,OAAO,EAAE,yEAAyE;YAClF,QAAQ,EAAE,8BAA8B;SACzC;QACD;YACE,aAAa,EAAE,0CAA0C;YACzD,OAAO,EAAE,gIAAgI;YACzI,QAAQ,EAAE,wDAAwD;SACnE;QACD;YACE,aAAa,EAAE,6CAA6C;YAC5D,OAAO,EAAE,6IAA6I;YACtJ,QAAQ,EAAE,0DAA0D;SACrE;QACD;YACE,aAAa,EAAE,gCAAgC;YAC/C,OAAO,EAAE,0EAA0E;YACnF,QAAQ,EAAE,yDAAyD;SACpE;KACF;IACD,MAAM,EAAE;QACN;YACE,UAAU,EAAE,uDAAuD;YACnE,QAAQ,EAAE,qPAAqP;SAChQ;QACD;YACE,UAAU,EAAE,qDAAqD;YACjE,QAAQ,EAAE,iLAAiL;SAC5L;QACD;YACE,UAAU,EAAE,yCAAyC;YACrD,QAAQ,EAAE,qJAAqJ;SAChK;QACD;YACE,UAAU,EAAE,0CAA0C;YACtD,QAAQ,EAAE,8LAA8L;SACzM;QACD;YACE,UAAU,EAAE,iDAAiD;YAC7D,QAAQ,EAAE,2IAA2I;SACtJ;KACF;IACD,OAAO,EAAE;QACP;YACE,OAAO,EAAE,SAAS;YAClB,KAAK,EAAE,WAAW;SACnB;QACD;YACE,OAAO,EAAE,UAAU;YACnB,KAAK,EAAE,YAAY;SACpB;QACD;YACE,OAAO,EAAE,QAAQ;YACjB,KAAK,EAAE,UAAU;SAClB;QACD;YACE,OAAO,EAAE,WAAW;YACpB,KAAK,EAAE,aAAa;SACrB;QACD;YACE,OAAO,EAAE,SAAS;YAClB,KAAK,EAAE,WAAW;SACnB;QACD;YACE,OAAO,EAAE,SAAS;YAClB,KAAK,EAAE,WAAW;SACnB;KACF;IACD,QAAQ,EAAE;QACR,OAAO,EAAE,mEAAmE;QAC5E,KAAK,EAAE,gHAAgH;KACxH;IACD,eAAe,EAAE,2UAA2U;IAC5V,cAAc,EAAE;QACd,w8BAAw8B;KACz8B;IACD,KAAK,EAAE,UAAU;IACjB,MAAM,EAAE,UAAU;IAClB,cAAc,EAAE;QACd,cAAc;QACd,KAAK;KACN;CACF,CAAC;AAEF,eAAe,UAAU,CAAC"}

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

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

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

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