runmat 0.3.6 → 0.4.0

package/dist/generated/builtins/cos.js

@@ -0,0 +1,180 @@
+// @generated by scripts/generate-builtins.cjs
+// Do not edit by hand.
+const builtinDoc = {
+    "title": "cos",
+    "category": "math/trigonometry",
+    "keywords": [
+        "cos",
+        "cosine",
+        "trigonometry",
+        "elementwise",
+        "gpu",
+        "like"
+    ],
+    "summary": "Cosine of scalars, vectors, matrices, complex numbers, or character arrays with MATLAB broadcasting and GPU acceleration.",
+    "references": [],
+    "gpu_support": {
+        "elementwise": true,
+        "reduction": false,
+        "precisions": [
+            "f32",
+            "f64"
+        ],
+        "broadcasting": "matlab",
+        "notes": "Prefers provider unary_cos hooks; falls back to the host path when a provider is unavailable or cannot service the operand type."
+    },
+    "fusion": {
+        "elementwise": true,
+        "reduction": false,
+        "max_inputs": 1,
+        "constants": "inline"
+    },
+    "requires_feature": null,
+    "tested": {
+        "unit": "builtins::math::trigonometry::cos::tests",
+        "integration": "builtins::math::trigonometry::cos::tests::cos_gpu_provider_roundtrip"
+    },
+    "description": "`y = cos(x)` evaluates the cosine of each element in `x`, interpreting angles in radians while preserving MATLAB’s column-major layout and broadcasting rules.",
+    "behaviors": [
+        "Operates on scalars, vectors, matrices, and N-D tensors with MATLAB-compatible implicit expansion.",
+        "Logical and integer inputs are promoted to double precision before evaluation so downstream arithmetic matches MATLAB’s numeric tower.",
+        "Complex values use the analytic extension `cos(a + bi) = cos(a)cosh(b) - i·sin(a)sinh(b)` while propagating `NaN`/`Inf` components independently.",
+        "Character arrays are interpreted through their Unicode code points and return dense double arrays that mirror MATLAB’s behaviour.",
+        "Appending `'like', prototype` mirrors the prototype’s class and residency (host or GPU), re-uploading the result when a device prototype is supplied.",
+        "Empty inputs and singleton dimensions are preserved without introducing extraneous allocations."
+    ],
+    "examples": [
+        {
+            "description": "Cosine of zero",
+            "input": "y = cos(0)",
+            "output": "y = 1"
+        },
+        {
+            "description": "Cosine of evenly spaced angles",
+            "input": "theta = linspace(0, 2*pi, 5);\nvalues = cos(theta)",
+            "output": "values = [1 0 -1 0 1]"
+        },
+        {
+            "description": "Cosine of complex data",
+            "input": "z = cos(1 + 2i)",
+            "output": "z = 2.0327 - 3.0519i"
+        },
+        {
+            "description": "Cosine on a GPU tensor without manual residency",
+            "input": "A = reshape(0:5, [3 2]);\nresult = cos(A)        % planner keeps the tensor on device when beneficial",
+            "output": "result =\n    1.0000   -0.9900\n    0.5403   -0.6536\n   -0.4161    0.2837"
+        },
+        {
+            "description": "Keeping results on the GPU with a `'like'` prototype",
+            "input": "proto = gpuArray.zeros(1, 1, 'single');\nangles = [0 pi/2 pi];\ndeviceResult = cos(angles, 'like', proto);\nresult = gather(deviceResult)",
+            "output": "result = [1 0 -1]"
+        },
+        {
+            "description": "Matching a host prototype while inputs live on the GPU",
+            "input": "G = gpuArray([0 1 2]);\nhostLike = cos(G, 'like', zeros(1, 'double'))",
+            "output": "hostLike = [1 0.5403 -0.4161]"
+        }
+    ],
+    "faqs": [
+        {
+            "question": "When should I use the `cos` function?",
+            "answer": "Use `cos` whenever you need the cosine of angles expressed in radians—whether those angles are scalars, vectors, matrices, or higher-dimensional tensors."
+        },
+        {
+            "question": "Does `cos` promote inputs to double precision?",
+            "answer": "Yes. Unless you request otherwise with `'like'`, RunMat promotes numeric inputs to double precision, matching MATLAB’s default behaviour."
+        },
+        {
+            "question": "How does `cos` handle complex inputs?",
+            "answer": "Complex numbers follow MATLAB’s analytic definition `cos(a + bi) = cos(a)cosh(b) - i·sin(a)sinh(b)` so both the real and imaginary parts are handled correctly."
+        },
+        {
+            "question": "What happens if the GPU provider lacks `unary_cos`?",
+            "answer": "RunMat gathers the tensor to the host, evaluates cosine with the CPU reference path, and then reapplies residency rules. If a `'like'` prototype targets the GPU, the result is uploaded back before returning."
+        },
+        {
+            "question": "Can I rely on MATLAB broadcasting rules?",
+            "answer": "Yes. Scalar and singleton dimensions implicitly expand just as they do in MATLAB."
+        },
+        {
+            "question": "Does `cos` work with character arrays?",
+            "answer": "Yes. Character arrays are converted to their Unicode code points before cosine is evaluated, and the result is returned as a dense double array of the same size."
+        }
+    ],
+    "links": [
+        {
+            "label": "sin",
+            "url": "./sin"
+        },
+        {
+            "label": "tan",
+            "url": "./tan"
+        },
+        {
+            "label": "gpuArray",
+            "url": "./gpuarray"
+        },
+        {
+            "label": "gather",
+            "url": "./gather"
+        },
+        {
+            "label": "acos",
+            "url": "./acos"
+        },
+        {
+            "label": "acosh",
+            "url": "./acosh"
+        },
+        {
+            "label": "asin",
+            "url": "./asin"
+        },
+        {
+            "label": "asinh",
+            "url": "./asinh"
+        },
+        {
+            "label": "atan",
+            "url": "./atan"
+        },
+        {
+            "label": "atan2",
+            "url": "./atan2"
+        },
+        {
+            "label": "atanh",
+            "url": "./atanh"
+        },
+        {
+            "label": "cosh",
+            "url": "./cosh"
+        },
+        {
+            "label": "sinh",
+            "url": "./sinh"
+        },
+        {
+            "label": "tanh",
+            "url": "./tanh"
+        }
+    ],
+    "source": {
+        "label": "`crates/runmat-runtime/src/builtins/math/trigonometry/cos.rs`",
+        "url": "https://github.com/runmat-org/runmat/blob/main/crates/runmat-runtime/src/builtins/math/trigonometry/cos.rs"
+    },
+    "gpu_residency": "```matlab:runnable\nA = reshape(0:5, [3 2]);\nresult = cos(A);        % planner keeps the tensor on device when beneficial\n```\n\nExpected output (after `gather(result)`):\n\n```matlab\nresult =\n    1.0000   -0.9899\n    0.5403   -0.6536\n   -0.4161    0.2837\n```",
+    "gpu_behavior": [
+        "With RunMat Accelerate active, tensors remain on the device and execute through the provider’s `unary_cos` hook (or fused elementwise kernels) without leaving GPU memory.",
+        "If the provider declines the operation—for example, when only CPU precision is available or the operand type is unsupported—RunMat transparently gathers to the host, computes the result, and reapplies the requested residency rules (including `'like'` prototypes).",
+        "Fusion planning keeps neighbouring elementwise operators grouped, reducing host↔device transfers even when an intermediate fallback occurs."
+    ],
+    "key": "cos",
+    "slug": "cos",
+    "categoryPath": [
+        "math",
+        "trigonometry"
+    ]
+};
+export default builtinDoc;
+//# sourceMappingURL=cos.js.map

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

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

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

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

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

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

@@ -0,0 +1,180 @@
+// @generated by scripts/generate-builtins.cjs
+// Do not edit by hand.
+const builtinDoc = {
+    "title": "cosh",
+    "category": "math/trigonometry",
+    "keywords": [
+        "cosh",
+        "hyperbolic cosine",
+        "trigonometry",
+        "elementwise",
+        "gpu"
+    ],
+    "summary": "Hyperbolic cosine of scalars, vectors, matrices, complex numbers, or character arrays with MATLAB broadcasting and GPU acceleration.",
+    "references": [],
+    "gpu_support": {
+        "elementwise": true,
+        "reduction": false,
+        "precisions": [
+            "f32",
+            "f64"
+        ],
+        "broadcasting": "matlab",
+        "notes": "Prefers provider unary_cosh hooks; falls back to the host path when a provider is unavailable or cannot service the operand type."
+    },
+    "fusion": {
+        "elementwise": true,
+        "reduction": false,
+        "max_inputs": 1,
+        "constants": "inline"
+    },
+    "requires_feature": null,
+    "tested": {
+        "unit": "builtins::math::trigonometry::cosh::tests",
+        "integration": "builtins::math::trigonometry::cosh::tests::cosh_gpu_provider_roundtrip"
+    },
+    "description": "`Y = cosh(X)` computes the hyperbolic cosine of every element in `X`, extending naturally to complex values.",
+    "behaviors": [
+        "Works on scalars, vectors, matrices, and N-D tensors with MATLAB broadcasting semantics for scalar expansion.",
+        "Logical inputs are converted to double precision (`true → 1.0`, `false → 0.0`) before applying `cosh`.",
+        "Complex inputs follow the analytic rule `cosh(a + bi) = cosh(a)cos(b) + i·sinh(a)sin(b)`, propagating `NaN`/`Inf` components independently.",
+        "Character arrays are converted to their numeric code points prior to evaluation, with double-precision outputs that preserve the input shape.",
+        "Empty arrays return empty results that respect MATLAB’s shape semantics."
+    ],
+    "examples": [
+        {
+            "description": "Hyperbolic cosine of a scalar",
+            "input": "y = cosh(2)",
+            "output": "y = 3.7622"
+        },
+        {
+            "description": "Applying `cosh` elementwise to a vector",
+            "input": "x = linspace(-2, 2, 5);\ny = cosh(x)",
+            "output": "y = [3.7622 1.5431 1.0000 1.5431 3.7622]"
+        },
+        {
+            "description": "Evaluating `cosh` on a matrix",
+            "input": "A = [0 0.5; 1.0 1.5];\nB = cosh(A)",
+            "output": "B = [1.0000 1.1276; 1.5431 2.3524]"
+        },
+        {
+            "description": "Executing `cosh` on a GPU tensor",
+            "input": "G = gpuArray([0.25 0.75; 1.25 1.75]);\nresult_gpu = cosh(G);\nresult = gather(result_gpu)",
+            "output": "result = [1.0314 1.2947; 1.8884 2.9642]"
+        },
+        {
+            "description": "Working with complex inputs",
+            "input": "z = 1 + 2i;\nw = cosh(z)",
+            "output": "w = -0.6421 + 1.0686i"
+        },
+        {
+            "description": "Hyperbolic cosine for character codes",
+            "input": "chars = 'AZ';\ncodes = cosh(chars)",
+            "output": "codes = [8.4744e27 6.1020e38]"
+        }
+    ],
+    "faqs": [
+        {
+            "question": "When should I use `cosh`?",
+            "answer": "Use `cosh` for hyperbolic modelling, solving differential equations, or transforming signals where the hyperbolic cosine naturally appears."
+        },
+        {
+            "question": "Does `cosh` work with complex inputs?",
+            "answer": "Yes. Real and imaginary components are evaluated using the analytic continuation, matching MATLAB’s `cosh` semantics."
+        },
+        {
+            "question": "What happens if the GPU provider lacks `unary_cosh`?",
+            "answer": "RunMat falls back to the host implementation. Tensors are gathered to the CPU, evaluated, and left on the host unless later operations request GPU residency (`'like'`, planner decisions, etc.)."
+        },
+        {
+            "question": "Can `cosh` participate in fusion?",
+            "answer": "Yes. The fusion planner can inline `cosh` inside elementwise groups, generating WGSL kernels that execute directly on the GPU when supported."
+        },
+        {
+            "question": "Are integers preserved?",
+            "answer": "Inputs are promoted to double precision before evaluation, matching MATLAB behaviour. Cast back explicitly if you need integer outputs."
+        },
+        {
+            "question": "How does `cosh` handle NaN or Inf values?",
+            "answer": "`cosh` propagates `NaN` and `Inf` in the same way as MATLAB: each component is treated independently, and results mirror IEEE-754 expectations."
+        },
+        {
+            "question": "Is there a warmup penalty on first GPU use?",
+            "answer": "Providers may compile elementwise pipelines during initialization. If `unary_cosh` is unavailable, the CPU fallback avoids the warmup altogether."
+        }
+    ],
+    "links": [
+        {
+            "label": "cos",
+            "url": "./cos"
+        },
+        {
+            "label": "sinh",
+            "url": "./sinh"
+        },
+        {
+            "label": "tanh",
+            "url": "./tanh"
+        },
+        {
+            "label": "gpuArray",
+            "url": "./gpuarray"
+        },
+        {
+            "label": "gather",
+            "url": "./gather"
+        },
+        {
+            "label": "acos",
+            "url": "./acos"
+        },
+        {
+            "label": "acosh",
+            "url": "./acosh"
+        },
+        {
+            "label": "asin",
+            "url": "./asin"
+        },
+        {
+            "label": "asinh",
+            "url": "./asinh"
+        },
+        {
+            "label": "atan",
+            "url": "./atan"
+        },
+        {
+            "label": "atan2",
+            "url": "./atan2"
+        },
+        {
+            "label": "atanh",
+            "url": "./atanh"
+        },
+        {
+            "label": "sin",
+            "url": "./sin"
+        },
+        {
+            "label": "tan",
+            "url": "./tan"
+        }
+    ],
+    "source": {
+        "label": "`crates/runmat-runtime/src/builtins/math/trigonometry/cosh.rs`",
+        "url": "https://github.com/runmat-org/runmat/blob/main/crates/runmat-runtime/src/builtins/math/trigonometry/cosh.rs"
+    },
+    "gpu_residency": "You usually do **not** need to call `gpuArray` explicitly. The fusion planner keeps tensors on the GPU whenever the active provider exposes the required kernels (such as `unary_cosh`). Manual `gpuArray` / `gather` calls remain available for MATLAB compatibility or when you must control residency before interoperating with external code.",
+    "gpu_behavior": [
+        "When RunMat Accelerate is active, tensors that already reside on the GPU stay there. Providers implementing the optional `unary_cosh` hook execute the operation entirely on the device (and fused elementwise kernels can inline `cosh` alongside other operations). If the active provider lacks this hook, RunMat gathers the data back to the host, computes the reference result, and only re-uploads when downstream operations demand GPU residency."
+    ],
+    "key": "cosh",
+    "slug": "cosh",
+    "categoryPath": [
+        "math",
+        "trigonometry"
+    ]
+};
+export default builtinDoc;
+//# sourceMappingURL=cosh.js.map

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

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

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

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

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

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

package/dist/generated/builtins/cov.js

@@ -0,0 +1,139 @@
+// @generated by scripts/generate-builtins.cjs
+// Do not edit by hand.
+const builtinDoc = {
+    "title": "cov",
+    "category": "stats/summary",
+    "keywords": [
+        "cov",
+        "covariance",
+        "statistics",
+        "weighted covariance",
+        "gpu"
+    ],
+    "summary": "Compute covariance matrices for vectors, matrices, or paired data sets.",
+    "references": [
+        "https://www.mathworks.com/help/matlab/ref/cov.html"
+    ],
+    "gpu_support": {
+        "elementwise": false,
+        "reduction": false,
+        "precisions": [
+            "f32",
+            "f64"
+        ],
+        "broadcasting": "none",
+        "notes": "Runs on the GPU when rows='all' and no weight vector is supplied; other modes transparently fall back to the CPU reference path."
+    },
+    "fusion": {
+        "elementwise": false,
+        "reduction": false,
+        "max_inputs": 2,
+        "constants": "inline"
+    },
+    "requires_feature": null,
+    "tested": {
+        "unit": "builtins::stats::summary::cov::tests",
+        "integration": "builtins::stats::summary::cov::tests::cov_gpu_roundtrip"
+    },
+    "description": "`cov` returns covariance matrices for numeric data. Columns represent variables and rows are observations. You can pass in one matrix, two matching data sets, or supply observation weights and row-handling options that mirror MATLAB.",
+    "behaviors": [
+        "`cov(X)` treats each column of `X` as a variable and returns a square covariance matrix.",
+        "`cov(X, Y)` concatenates `X` and `Y` column-wise (they must have the same number of rows) before computing the covariance.",
+        "The second argument can be the normalization flag `0` (default) or `1`, matching MATLAB's unbiased and biased estimators.",
+        "You can pass a weight vector to obtain frequency-weighted covariance.",
+        "`'omitrows'` drops rows containing `NaN` or `Inf` before the covariance is computed.",
+        "`'partialrows'` performs pairwise deletion: each covariance entry uses only the rows that contain finite values for that column pair."
+    ],
+    "examples": [
+        {
+            "description": "Computing covariance of columns in a matrix",
+            "input": "X = [4.0 2.0 0.60;\n     4.2 2.1 0.59;\n     3.9 2.0 0.58;\n     4.3 2.1 0.62;\n     4.1 2.2 0.63];\nC = cov(X)",
+            "output": "C =\n    0.0250    0.0075    0.0018\n    0.0075    0.0070    0.0014\n    0.0018    0.0014    0.0004"
+        },
+        {
+            "description": "Covariance between two vectors",
+            "input": "x = [1 2 3 4]';\ny = [10 11 9 12]';\nC = cov(x, y)",
+            "output": "C =\n    1.6667    0.6667\n    0.6667    1.6667"
+        },
+        {
+            "description": "Weighted covariance with observation weights",
+            "input": "X = [4.0 2.0;\n     4.2 2.1;\n     3.9 2.0;\n     4.3 2.1;\n     4.1 2.2];\nw = [1 1 1 2 2];\nCw = cov(X, w)",
+            "output": "Cw =\n    0.0224    0.0050\n    0.0050    0.0067"
+        },
+        {
+            "description": "Ignoring rows that contain missing values",
+            "input": "X = [1   NaN 2;\n     3   4   5;\n     NaN 6   7;\n     8   9   10];\nC = cov(X, 'omitrows')",
+            "output": "C =\n   12.5000   12.5000   12.5000\n   12.5000   12.5000   12.5000\n   12.5000   12.5000   12.5000"
+        },
+        {
+            "description": "Pairwise covariance with staggered NaNs",
+            "input": "X = [ 1   2   NaN;\n      4   NaN 6;\n      7   8   9];\nC = cov(X, 'partialrows')",
+            "output": "C =\n    9.0000   18.0000    4.5000\n   18.0000   18.0000       NaN\n    4.5000       NaN    4.5000"
+        },
+        {
+            "description": "Running covariance on `gpuArray` inputs",
+            "input": "X = [4.0 2.0 0.60;\n     4.2 2.1 0.59;\n     3.9 2.0 0.58;\n     4.3 2.1 0.62;\n     4.1 2.2 0.63];\nG = gpuArray(X);\nCG = cov(G);\nCG_host = gather(CG)",
+            "output": "CG_host =\n    0.0250    0.0075    0.0018\n    0.0075    0.0070    0.0014\n    0.0018    0.0014    0.0004"
+        }
+    ],
+    "faqs": [
+        {
+            "question": "Does `cov` support biased and unbiased estimators?",
+            "answer": "Yes. The default is the unbiased estimator (divide by *N - 1*). Passing `1` as the second argument switches to the biased estimator (divide by *N*), matching MATLAB."
+        },
+        {
+            "question": "How do I provide observation weights?",
+            "answer": "Supply a weight vector whose length equals the number of observations. The covariance is frequency-weighted using the MATLAB formula. Weighted covariance currently falls back to the CPU implementation when running on the GPU."
+        },
+        {
+            "question": "What happens when columns contain constant values?",
+            "answer": "The diagonal entries become zero, and off-diagonal entries involving the constant column are zero. Any slight negative values caused by floating-point noise are clamped to zero."
+        },
+        {
+            "question": "How are `NaN` and `Inf` handled?",
+            "answer": "By default (`'all'`), non-finite values propagate `NaN` into the affected covariance entries. `'omitrows'` drops rows containing non-finite values, while `'partialrows'` recomputes each covariance entry using only rows that are finite for the relevant column pair."
+        },
+        {
+            "question": "Can I call `cov` on logical inputs?",
+            "answer": "Yes. Logical arrays are converted to double precision (`true → 1.0`, `false → 0.0`) before the covariance is computed, matching MATLAB's behaviour."
+        }
+    ],
+    "links": [
+        {
+            "label": "corrcoef",
+            "url": "./corrcoef"
+        },
+        {
+            "label": "mean",
+            "url": "./mean"
+        },
+        {
+            "label": "sum",
+            "url": "./sum"
+        },
+        {
+            "label": "gpuArray",
+            "url": "./gpuarray"
+        },
+        {
+            "label": "gather",
+            "url": "./gather"
+        }
+    ],
+    "source": {
+        "label": "`crates/runmat-runtime/src/builtins/stats/summary/cov.rs`",
+        "url": "https://github.com/runmat-org/runmat/blob/main/crates/runmat-runtime/src/builtins/stats/summary/cov.rs"
+    },
+    "gpu_residency": "You usually do **not** need to call `gpuArray`. Expressions such as `cov(sin(X))` keep temporary results on the GPU as long as the active provider handles the operation. The builtin gathers to the CPU only when weights, `'omitrows'`, or `'partialrows'` are requested, or when the provider does not implement the covariance hook. Explicitly calling `gpuArray` remains supported for MATLAB compatibility and to seed GPU residency when you are unsure about planner decisions.",
+    "gpu_behavior": [
+        "RunMat invokes provider-specific GPU kernels when:\n\n1. All inputs already reside on the GPU; 2. No weight vector is supplied; 3. The rows option is `'all'`; and 4. The active provider exposes the custom `covariance` hook.\n\nIf any of these conditions is not met, RunMat gathers the data to the host, evaluates the reference implementation, and returns a dense host tensor. This guarantees MATLAB-compatible behaviour regardless of GPU support."
+    ],
+    "key": "cov",
+    "slug": "cov",
+    "categoryPath": [
+        "stats",
+        "summary"
+    ]
+};
+export default builtinDoc;
+//# sourceMappingURL=cov.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"cov.js","sourceRoot":"","sources":["../../../src/generated/builtins/cov.ts"],"names":[],"mappings":"AAAA,8CAA8C;AAC9C,uBAAuB;AAIvB,MAAM,UAAU,GAAe;IAC7B,OAAO,EAAE,KAAK;IACd,UAAU,EAAE,eAAe;IAC3B,UAAU,EAAE;QACV,KAAK;QACL,YAAY;QACZ,YAAY;QACZ,qBAAqB;QACrB,KAAK;KACN;IACD,SAAS,EAAE,yEAAyE;IACpF,YAAY,EAAE;QACZ,oDAAoD;KACrD;IACD,aAAa,EAAE;QACb,aAAa,EAAE,KAAK;QACpB,WAAW,EAAE,KAAK;QAClB,YAAY,EAAE;YACZ,KAAK;YACL,KAAK;SACN;QACD,cAAc,EAAE,MAAM;QACtB,OAAO,EAAE,kIAAkI;KAC5I;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,sCAAsC;QAC9C,aAAa,EAAE,yDAAyD;KACzE;IACD,aAAa,EAAE,2OAA2O;IAC1P,WAAW,EAAE;QACX,0FAA0F;QAC1F,4HAA4H;QAC5H,2HAA2H;QAC3H,uEAAuE;QACvE,sFAAsF;QACtF,uIAAuI;KACxI;IACD,UAAU,EAAE;QACV;YACE,aAAa,EAAE,6CAA6C;YAC5D,OAAO,EAAE,iHAAiH;YAC1H,QAAQ,EAAE,qGAAqG;SAChH;QACD;YACE,aAAa,EAAE,gCAAgC;YAC/C,OAAO,EAAE,oDAAoD;YAC7D,QAAQ,EAAE,iDAAiD;SAC5D;QACD;YACE,aAAa,EAAE,8CAA8C;YAC7D,OAAO,EAAE,8GAA8G;YACvH,QAAQ,EAAE,kDAAkD;SAC7D;QACD;YACE,aAAa,EAAE,2CAA2C;YAC1D,OAAO,EAAE,8FAA8F;YACvG,QAAQ,EAAE,qGAAqG;SAChH;QACD;YACE,aAAa,EAAE,yCAAyC;YACxD,OAAO,EAAE,oFAAoF;YAC7F,QAAQ,EAAE,qGAAqG;SAChH;QACD;YACE,aAAa,EAAE,yCAAyC;YACxD,OAAO,EAAE,2JAA2J;YACpK,QAAQ,EAAE,2GAA2G;SACtH;KACF;IACD,MAAM,EAAE;QACN;YACE,UAAU,EAAE,oDAAoD;YAChE,QAAQ,EAAE,uKAAuK;SAClL;QACD;YACE,UAAU,EAAE,uCAAuC;YACnD,QAAQ,EAAE,mOAAmO;SAC9O;QACD;YACE,UAAU,EAAE,oDAAoD;YAChE,QAAQ,EAAE,mLAAmL;SAC9L;QACD;YACE,UAAU,EAAE,kCAAkC;YAC9C,QAAQ,EAAE,0QAA0Q;SACrR;QACD;YACE,UAAU,EAAE,qCAAqC;YACjD,QAAQ,EAAE,qJAAqJ;SAChK;KACF;IACD,OAAO,EAAE;QACP;YACE,OAAO,EAAE,UAAU;YACnB,KAAK,EAAE,YAAY;SACpB;QACD;YACE,OAAO,EAAE,MAAM;YACf,KAAK,EAAE,QAAQ;SAChB;QACD;YACE,OAAO,EAAE,KAAK;YACd,KAAK,EAAE,OAAO;SACf;QACD;YACE,OAAO,EAAE,UAAU;YACnB,KAAK,EAAE,YAAY;SACpB;QACD;YACE,OAAO,EAAE,QAAQ;YACjB,KAAK,EAAE,UAAU;SAClB;KACF;IACD,QAAQ,EAAE;QACR,OAAO,EAAE,2DAA2D;QACpE,KAAK,EAAE,wGAAwG;KAChH;IACD,eAAe,EAAE,0dAA0d;IAC3e,cAAc,EAAE;QACd,gcAAgc;KACjc;IACD,KAAK,EAAE,KAAK;IACZ,MAAM,EAAE,KAAK;IACb,cAAc,EAAE;QACd,OAAO;QACP,SAAS;KACV;CACF,CAAC;AAEF,eAAe,UAAU,CAAC"}

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

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

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

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