@mojir/lits 2.1.11 → 2.1.13

package/dist/reference/api.d.ts

@@ -1,13 +1,13 @@
 import type { Argument } from '.';
 export declare const api: {
-    readonly collection: readonly ["filter", "map", "reduce", "reduce-right", "reductions", "count", "get", "get-in", "contains?", "assoc", "assoc-in", "++", "not-empty", "every?", "not-every?", "any?", "not-any?", "update", "update-in"];
-    readonly array: readonly ["range", "repeat", "flatten", "mapcat"];
+    readonly collection: readonly ["filter", "filteri", "map", "mapi", "reduce", "reducei", "reduce-right", "reducei-right", "reductions", "reductionsi", "count", "get", "get-in", "contains?", "assoc", "assoc-in", "++", "not-empty", "every?", "not-every?", "any?", "not-any?", "update", "update-in"];
+    readonly array: readonly ["range", "repeat", "flatten", "mapcat", "moving-fn", "running-fn"];
     readonly sequence: readonly ["nth", "push", "pop", "unshift", "shift", "slice", "splice", "position", "index-of", "last-index-of", "some", "reverse", "first", "second", "last", "rest", "next", "take", "take-last", "take-while", "drop", "drop-last", "drop-while", "sort", "sort-by", "distinct", "remove", "remove-at", "split-at", "split-with", "frequencies", "group-by", "partition", "partition-all", "partition-by", "starts-with?", "ends-with?", "interleave", "interpose"];
     readonly math: readonly ["+", "-", "*", "/", "mod", "rem", "quot", "inc", "dec", "sqrt", "cbrt", "^", "round", "trunc", "floor", "ceil", "min", "max", "abs", "sign", "ln", "log2", "log10", "sin", "cos", "tan", "asin", "acos", "atan", "sinh", "cosh", "tanh", "asinh", "acosh", "atanh", "to-rad", "to-deg"];
     readonly functional: readonly ["|>", "apply", "identity", "comp", "constantly", "juxt", "complement", "every-pred", "some-pred", "fnull"];
     readonly misc: readonly ["≠", "=", "<", ">", "≤", "≥", "!", "write!", "iso-date->epoch", "epoch->iso-date", "boolean", "compare", "identical?", "json-parse", "json-stringify"];
     readonly object: readonly ["dissoc", "keys", "vals", "entries", "find", "merge", "merge-with", "zipmap", "select-keys"];
-    readonly predicate: readonly ["boolean?", "null?", "number?", "string?", "function?", "integer?", "array?", "object?", "coll?", "seq?", "regexp?", "zero?", "pos?", "neg?", "even?", "odd?", "finite?", "nan?", "negative-infinity?", "positive-infinity?", "false?", "true?", "empty?", "not-empty?", "vector?", "grid?", "matrix?"];
+    readonly predicate: readonly ["boolean?", "null?", "number?", "string?", "function?", "integer?", "array?", "object?", "coll?", "seq?", "regexp?", "zero?", "pos?", "neg?", "even?", "odd?", "finite?", "negative-infinity?", "positive-infinity?", "false?", "true?", "empty?", "not-empty?", "vector?", "grid?", "matrix?"];
     readonly regularExpression: readonly ["regexp", "match", "replace", "replace-all"];
     readonly string: readonly ["string-repeat", "str", "number", "lower-case", "upper-case", "trim", "trim-left", "trim-right", "pad-left", "pad-right", "split", "split-lines", "template", "to-char-code", "from-char-code", "encode-base64", "decode-base64", "encode-uri-component", "decode-uri-component", "join", "capitalize", "blank?"];
     readonly bitwise: readonly ["<<", ">>", ">>>", "bit-not", "&", "bit-and-not", "|", "xor", "bit-flip", "bit-clear", "bit-set", "bit-test"];
@@ -44,7 +44,7 @@ export type NormalExpressionName = CollectionApiName | ArrayApiName | SequenceAp
 export type FunctionName = NormalExpressionName | SpecialExpressionsApiName;
 export type ShorthandName = typeof api.shorthand[number];
 export type DatatypeName = typeof api.datatype[number];
-declare const apiNames: readonly ["filter", "map", "reduce", "reduce-right", "reductions", "count", "get", "get-in", "contains?", "assoc", "assoc-in", "++", "not-empty", "every?", "not-every?", "any?", "not-any?", "update", "update-in", "range", "repeat", "flatten", "mapcat", "nth", "push", "pop", "unshift", "shift", "slice", "splice", "position", "index-of", "last-index-of", "some", "reverse", "first", "second", "last", "rest", "next", "take", "take-last", "take-while", "drop", "drop-last", "drop-while", "sort", "sort-by", "distinct", "remove", "remove-at", "split-at", "split-with", "frequencies", "group-by", "partition", "partition-all", "partition-by", "starts-with?", "ends-with?", "interleave", "interpose", "+", "-", "*", "/", "mod", "rem", "quot", "inc", "dec", "sqrt", "cbrt", "^", "round", "trunc", "floor", "ceil", "min", "max", "abs", "sign", "ln", "log2", "log10", "sin", "cos", "tan", "asin", "acos", "atan", "sinh", "cosh", "tanh", "asinh", "acosh", "atanh", "to-rad", "to-deg", "|>", "apply", "identity", "comp", "constantly", "juxt", "complement", "every-pred", "some-pred", "fnull", "≠", "=", "<", ">", "≤", "≥", "!", "write!", "iso-date->epoch", "epoch->iso-date", "boolean", "compare", "identical?", "json-parse", "json-stringify", "dissoc", "keys", "vals", "entries", "find", "merge", "merge-with", "zipmap", "select-keys", "boolean?", "null?", "number?", "string?", "function?", "integer?", "array?", "object?", "coll?", "seq?", "regexp?", "zero?", "pos?", "neg?", "even?", "odd?", "finite?", "nan?", "negative-infinity?", "positive-infinity?", "false?", "true?", "empty?", "not-empty?", "vector?", "grid?", "matrix?", "regexp", "match", "replace", "replace-all", "string-repeat", "str", "number", "lower-case", "upper-case", "trim", "trim-left", "trim-right", "pad-left", "pad-right", "split", "split-lines", "template", "to-char-code", "from-char-code", "encode-base64", "decode-base64", "encode-uri-component", "decode-uri-component", "join", "capitalize", "blank?", "<<", ">>", ">>>", "bit-not", "&", "bit-and-not", "|", "xor", "bit-flip", "bit-clear", "bit-set", "bit-test", "assert", "assert=", "assert!=", "assert-gt", "assert-lt", "assert-gte", "assert-lte", "assert-true", "assert-false", "assert-truthy", "assert-falsy", "assert-null", "assert-throws", "assert-throws-error", "assert-not-throws", "mat:mul", "mat:det", "mat:inv", "mat:adj", "mat:cofactor", "mat:minor", "mat:trace", "mat:symmetric?", "mat:triangular?", "mat:upper-triangular?", "mat:lower-triangular?", "mat:diagonal?", "mat:square?", "mat:orthogonal?", "mat:identity?", "mat:invertible?", "mat:hilbert", "mat:vandermonde", "mat:band", "mat:banded?", "mat:rank", "mat:frobenius-norm", "mat:1-norm", "mat:inf-norm", "mat:max-norm", "vec:monotonic?", "vec:strictly-monotonic?", "vec:increasing?", "vec:decreasing?", "vec:strictly-increasing?", "vec:strictly-decreasing?", "vec:median", "vec:mode", "vec:min-index", "vec:max-index", "vec:sort-indices", "vec:count-values", "vec:linspace", "vec:ones", "vec:zeros", "vec:fill", "vec:generate", "vec:cumsum", "vec:cumprod", "vec:quartiles", "vec:percentile", "vec:quantile", "vec:histogram", "vec:ecdf", "vec:outliers?", "vec:outliers", "vec:bincount", "vec:winsorize", "vec:mse", "vec:mae", "vec:rmse", "vec:smape", "vec:mean", "vec:moving-mean", "vec:centered-moving-mean", "vec:running-mean", "vec:median", "vec:moving-median", "vec:centered-moving-median", "vec:running-median", "vec:variance", "vec:moving-variance", "vec:centered-moving-variance", "vec:running-variance", "vec:sample-variance", "vec:moving-sample-variance", "vec:centered-moving-sample-variance", "vec:running-sample-variance", "vec:sum", "vec:moving-sum", "vec:centered-moving-sum", "vec:running-sum", "vec:prod", "vec:moving-prod", "vec:centered-moving-prod", "vec:running-prod", "vec:min", "vec:moving-min", "vec:centered-moving-min", "vec:running-min", "vec:max", "vec:moving-max", "vec:centered-moving-max", "vec:running-max", "vec:stdev", "vec:moving-stdev", "vec:centered-moving-stdev", "vec:running-stdev", "vec:sample-stdev", "vec:moving-sample-stdev", "vec:centered-moving-sample-stdev", "vec:running-sample-stdev", "vec:iqr", "vec:moving-iqr", "vec:centered-moving-iqr", "vec:running-iqr", "vec:span", "vec:moving-span", "vec:centered-moving-span", "vec:running-span", "vec:geometric-mean", "vec:moving-geometric-mean", "vec:centered-moving-geometric-mean", "vec:running-geometric-mean", "vec:harmonic-mean", "vec:moving-harmonic-mean", "vec:centered-moving-harmonic-mean", "vec:running-harmonic-mean", "vec:skewness", "vec:moving-skewness", "vec:centered-moving-skewness", "vec:running-skewness", "vec:sample-skewness", "vec:moving-sample-skewness", "vec:centered-moving-sample-skewness", "vec:running-sample-skewness", "vec:kurtosis", "vec:moving-kurtosis", "vec:centered-moving-kurtosis", "vec:running-kurtosis", "vec:sample-kurtosis", "vec:moving-sample-kurtosis", "vec:centered-moving-sample-kurtosis", "vec:running-sample-kurtosis", "vec:excess-kurtosis", "vec:moving-excess-kurtosis", "vec:centered-moving-excess-kurtosis", "vec:running-excess-kurtosis", "vec:sample-excess-kurtosis", "vec:moving-sample-excess-kurtosis", "vec:centered-moving-sample-excess-kurtosis", "vec:running-sample-excess-kurtosis", "vec:rms", "vec:moving-rms", "vec:centered-moving-rms", "vec:running-rms", "vec:mad", "vec:moving-mad", "vec:centered-moving-mad", "vec:running-mad", "vec:medad", "vec:moving-medad", "vec:centered-moving-medad", "vec:running-medad", "vec:gini-coefficient", "vec:moving-gini-coefficient", "vec:centered-moving-gini-coefficient", "vec:running-gini-coefficient", "vec:entropy", "vec:moving-entropy", "vec:centered-moving-entropy", "vec:running-entropy", "vec:skewness", "vec:moving-skewness", "vec:centered-moving-skewness", "vec:running-skewness", "lin:reflect", "lin:refract", "lin:lerp", "lin:rotate2d", "lin:rotate3d", "lin:dot", "lin:cross", "lin:normalize-minmax", "lin:normalize-zscore", "lin:normalize-robust", "lin:normalize-l1", "lin:normalize-l2", "lin:normalize-log", "lin:angle", "lin:projection", "lin:orthogonal?", "lin:parallel?", "lin:collinear?", "lin:cosine-similarity", "lin:euclidean-distance", "lin:euclidean-norm", "lin:manhattan-distance", "lin:manhattan-norm", "lin:hamming-distance", "lin:hamming-norm", "lin:chebyshev-distance", "lin:chebyshev-norm", "lin:minkowski-distance", "lin:minkowski-norm", "lin:cov", "lin:corr", "lin:spearman-corr", "lin:pearson-corr", "lin:kendall-tau", "lin:autocorrelation", "lin:cross-correlation", "lin:rref", "lin:solve", "lin:to-polar", "lin:from-polar", "grid:every?", "grid:some?", "grid:every-row?", "grid:some-row?", "grid:every-col?", "grid:some-col?", "grid:row", "grid:col", "grid:shape", "grid:fill", "grid:generate", "grid:reshape", "grid:transpose", "grid:flip-h", "grid:flip-v", "grid:rotate", "grid:reverse-rows", "grid:reverse-cols", "grid:slice", "grid:slice-rows", "grid:slice-cols", "grid:splice-rows", "grid:splice-cols", "grid:concat-rows", "grid:concat-cols", "grid:map", "grid:mapi", "grid:reduce", "grid:reducei", "grid:push-rows", "grid:unshift-rows", "grid:pop-row", "grid:shift-row", "grid:push-cols", "grid:unshift-cols", "grid:pop-col", "grid:shift-col", "grid:from-array", "nth:abundant-seq", "nth:abundant-nth", "nth:abundant-take-while", "nth:abundant?", "nth:bell-seq", "nth:bell-nth", "nth:bell-take-while", "nth:bell?", "nth:catalan-seq", "nth:catalan-nth", "nth:catalan-take-while", "nth:catalan?", "nth:composite-seq", "nth:composite-nth", "nth:composite-take-while", "nth:composite?", "nth:factorial-seq", "nth:factorial-nth", "nth:factorial-take-while", "nth:factorial?", "nth:fibonacci-seq", "nth:fibonacci-nth", "nth:fibonacci-take-while", "nth:fibonacci?", "nth:geometric-seq", "nth:geometric-nth", "nth:geometric-take-while", "nth:geometric?", "nth:golomb-seq", "nth:golomb-nth", "nth:golomb-take-while", "nth:golomb?", "nth:happy-seq", "nth:happy-nth", "nth:happy-take-while", "nth:happy?", "nth:look-and-say-seq", "nth:look-and-say-nth", "nth:look-and-say-take-while", "nth:look-and-say?", "nth:lucas-seq", "nth:lucas-nth", "nth:lucas-take-while", "nth:lucas?", "nth:lucky-seq", "nth:lucky-nth", "nth:lucky-take-while", "nth:lucky?", "nth:mersenne-seq", "nth:mersenne-nth", "nth:mersenne-take-while", "nth:mersenne?", "nth:padovan-seq", "nth:padovan-nth", "nth:padovan-take-while", "nth:padovan?", "nth:partition-seq", "nth:partition-nth", "nth:partition-take-while", "nth:partition?", "nth:pell-seq", "nth:pell-nth", "nth:pell-take-while", "nth:pell?", "nth:perfect-seq", "nth:perfect-nth", "nth:perfect-take-while", "nth:perfect?", "nth:perfect-cube-seq", "nth:perfect-cube-nth", "nth:perfect-cube-take-while", "nth:perfect-cube?", "nth:perfect-power-seq", "nth:perfect-power-nth", "nth:perfect-power-take-while", "nth:perfect-power?", "nth:perfect-square-seq", "nth:perfect-square-nth", "nth:perfect-square-take-while", "nth:perfect-square?", "nth:polygonal-seq", "nth:polygonal-nth", "nth:polygonal-take-while", "nth:polygonal?", "nth:prime-seq", "nth:prime-nth", "nth:prime-take-while", "nth:prime?", "nth:recaman-seq", "nth:recaman-nth", "nth:recaman-take-while", "nth:recaman?", "nth:sylvester-seq", "nth:sylvester-nth", "nth:sylvester-take-while", "nth:sylvester?", "nth:thue-morse-seq", "nth:thue-morse-nth", "nth:thue-morse-take-while", "nth:thue-morse?", "nth:tribonacci-seq", "nth:tribonacci-nth", "nth:tribonacci-take-while", "nth:tribonacci?", "nth:collatz-seq", "nth:juggler-seq", "nth:bernoulli-seq", "nth:bernoulli-take-while", "nth:bernoulli-nth", "nth:combinations", "nth:count-combinations", "nth:derangements", "nth:count-derangements", "nth:divisors", "nth:count-divisors", "nth:proper-divisors", "nth:count-proper-divisors", "nth:prime-factors", "nth:count-prime-factors", "nth:distinct-prime-factors", "nth:count-distinct-prime-factors", "nth:factorial", "nth:partitions", "nth:count-partitions", "nth:permutations", "nth:count-permutations", "nth:power-set", "nth:count-power-set", "nth:coprime?", "nth:divisible-by?", "nth:gcd", "nth:lcm", "nth:multinomial", "nth:amicable?", "nth:euler-totient", "nth:mobius", "nth:mertens", "nth:sigma", "nth:carmichael-lambda", "nth:cartesian-product", "nth:perfect-power", "nth:mod-exp", "nth:mod-inv", "nth:extended-gcd", "nth:chinese-remainder", "nth:stirling-first", "nth:stirling-second", "!:random", "!:random-int", "!:random-int-inclusive", "!:random-float", "!:random-boolean", "!:random-item", "!:random-sample", "!:random-sample-unique", "!:shuffle", "!:random-normal", "!:random-exponential", "!:random-binomial", "!:random-poisson", "!:random-gamma", "!:random-pareto", "!:uuid", "!:random-char", "!:random-string", "!:random-id", "!:random-color", "-short-regexp", "-short-fn", "-type-number", "-type-string", "-type-object", "-type-array", "-type-vector", "-type-matrix", "-type-grid", "-type-boolean", "-type-function", "-type-integer", "-type-any", "-type-null", "-type-collection", "-type-sequence", "-type-regexp", "-type-never"];
+declare const apiNames: readonly ["filter", "filteri", "map", "mapi", "reduce", "reducei", "reduce-right", "reducei-right", "reductions", "reductionsi", "count", "get", "get-in", "contains?", "assoc", "assoc-in", "++", "not-empty", "every?", "not-every?", "any?", "not-any?", "update", "update-in", "range", "repeat", "flatten", "mapcat", "moving-fn", "running-fn", "nth", "push", "pop", "unshift", "shift", "slice", "splice", "position", "index-of", "last-index-of", "some", "reverse", "first", "second", "last", "rest", "next", "take", "take-last", "take-while", "drop", "drop-last", "drop-while", "sort", "sort-by", "distinct", "remove", "remove-at", "split-at", "split-with", "frequencies", "group-by", "partition", "partition-all", "partition-by", "starts-with?", "ends-with?", "interleave", "interpose", "+", "-", "*", "/", "mod", "rem", "quot", "inc", "dec", "sqrt", "cbrt", "^", "round", "trunc", "floor", "ceil", "min", "max", "abs", "sign", "ln", "log2", "log10", "sin", "cos", "tan", "asin", "acos", "atan", "sinh", "cosh", "tanh", "asinh", "acosh", "atanh", "to-rad", "to-deg", "|>", "apply", "identity", "comp", "constantly", "juxt", "complement", "every-pred", "some-pred", "fnull", "≠", "=", "<", ">", "≤", "≥", "!", "write!", "iso-date->epoch", "epoch->iso-date", "boolean", "compare", "identical?", "json-parse", "json-stringify", "dissoc", "keys", "vals", "entries", "find", "merge", "merge-with", "zipmap", "select-keys", "boolean?", "null?", "number?", "string?", "function?", "integer?", "array?", "object?", "coll?", "seq?", "regexp?", "zero?", "pos?", "neg?", "even?", "odd?", "finite?", "negative-infinity?", "positive-infinity?", "false?", "true?", "empty?", "not-empty?", "vector?", "grid?", "matrix?", "regexp", "match", "replace", "replace-all", "string-repeat", "str", "number", "lower-case", "upper-case", "trim", "trim-left", "trim-right", "pad-left", "pad-right", "split", "split-lines", "template", "to-char-code", "from-char-code", "encode-base64", "decode-base64", "encode-uri-component", "decode-uri-component", "join", "capitalize", "blank?", "<<", ">>", ">>>", "bit-not", "&", "bit-and-not", "|", "xor", "bit-flip", "bit-clear", "bit-set", "bit-test", "assert", "assert=", "assert!=", "assert-gt", "assert-lt", "assert-gte", "assert-lte", "assert-true", "assert-false", "assert-truthy", "assert-falsy", "assert-null", "assert-throws", "assert-throws-error", "assert-not-throws", "mat:mul", "mat:det", "mat:inv", "mat:adj", "mat:cofactor", "mat:minor", "mat:trace", "mat:symmetric?", "mat:triangular?", "mat:upper-triangular?", "mat:lower-triangular?", "mat:diagonal?", "mat:square?", "mat:orthogonal?", "mat:identity?", "mat:invertible?", "mat:hilbert", "mat:vandermonde", "mat:band", "mat:banded?", "mat:rank", "mat:frobenius-norm", "mat:1-norm", "mat:inf-norm", "mat:max-norm", "vec:monotonic?", "vec:strictly-monotonic?", "vec:increasing?", "vec:decreasing?", "vec:strictly-increasing?", "vec:strictly-decreasing?", "vec:median", "vec:mode", "vec:min-index", "vec:max-index", "vec:sort-indices", "vec:count-values", "vec:linspace", "vec:ones", "vec:zeros", "vec:fill", "vec:generate", "vec:cumsum", "vec:cumprod", "vec:quartiles", "vec:percentile", "vec:quantile", "vec:histogram", "vec:ecdf", "vec:outliers?", "vec:outliers", "vec:bincount", "vec:winsorize", "vec:mse", "vec:mae", "vec:rmse", "vec:smape", "vec:mean", "vec:moving-mean", "vec:centered-moving-mean", "vec:running-mean", "vec:median", "vec:moving-median", "vec:centered-moving-median", "vec:running-median", "vec:variance", "vec:moving-variance", "vec:centered-moving-variance", "vec:running-variance", "vec:sample-variance", "vec:moving-sample-variance", "vec:centered-moving-sample-variance", "vec:running-sample-variance", "vec:sum", "vec:moving-sum", "vec:centered-moving-sum", "vec:running-sum", "vec:prod", "vec:moving-prod", "vec:centered-moving-prod", "vec:running-prod", "vec:min", "vec:moving-min", "vec:centered-moving-min", "vec:running-min", "vec:max", "vec:moving-max", "vec:centered-moving-max", "vec:running-max", "vec:stdev", "vec:moving-stdev", "vec:centered-moving-stdev", "vec:running-stdev", "vec:sample-stdev", "vec:moving-sample-stdev", "vec:centered-moving-sample-stdev", "vec:running-sample-stdev", "vec:iqr", "vec:moving-iqr", "vec:centered-moving-iqr", "vec:running-iqr", "vec:span", "vec:moving-span", "vec:centered-moving-span", "vec:running-span", "vec:geometric-mean", "vec:moving-geometric-mean", "vec:centered-moving-geometric-mean", "vec:running-geometric-mean", "vec:harmonic-mean", "vec:moving-harmonic-mean", "vec:centered-moving-harmonic-mean", "vec:running-harmonic-mean", "vec:skewness", "vec:moving-skewness", "vec:centered-moving-skewness", "vec:running-skewness", "vec:sample-skewness", "vec:moving-sample-skewness", "vec:centered-moving-sample-skewness", "vec:running-sample-skewness", "vec:kurtosis", "vec:moving-kurtosis", "vec:centered-moving-kurtosis", "vec:running-kurtosis", "vec:sample-kurtosis", "vec:moving-sample-kurtosis", "vec:centered-moving-sample-kurtosis", "vec:running-sample-kurtosis", "vec:excess-kurtosis", "vec:moving-excess-kurtosis", "vec:centered-moving-excess-kurtosis", "vec:running-excess-kurtosis", "vec:sample-excess-kurtosis", "vec:moving-sample-excess-kurtosis", "vec:centered-moving-sample-excess-kurtosis", "vec:running-sample-excess-kurtosis", "vec:rms", "vec:moving-rms", "vec:centered-moving-rms", "vec:running-rms", "vec:mad", "vec:moving-mad", "vec:centered-moving-mad", "vec:running-mad", "vec:medad", "vec:moving-medad", "vec:centered-moving-medad", "vec:running-medad", "vec:gini-coefficient", "vec:moving-gini-coefficient", "vec:centered-moving-gini-coefficient", "vec:running-gini-coefficient", "vec:entropy", "vec:moving-entropy", "vec:centered-moving-entropy", "vec:running-entropy", "vec:skewness", "vec:moving-skewness", "vec:centered-moving-skewness", "vec:running-skewness", "lin:reflect", "lin:refract", "lin:lerp", "lin:rotate2d", "lin:rotate3d", "lin:dot", "lin:cross", "lin:normalize-minmax", "lin:normalize-zscore", "lin:normalize-robust", "lin:normalize-l1", "lin:normalize-l2", "lin:normalize-log", "lin:angle", "lin:projection", "lin:orthogonal?", "lin:parallel?", "lin:collinear?", "lin:cosine-similarity", "lin:euclidean-distance", "lin:euclidean-norm", "lin:manhattan-distance", "lin:manhattan-norm", "lin:hamming-distance", "lin:hamming-norm", "lin:chebyshev-distance", "lin:chebyshev-norm", "lin:minkowski-distance", "lin:minkowski-norm", "lin:cov", "lin:corr", "lin:spearman-corr", "lin:pearson-corr", "lin:kendall-tau", "lin:autocorrelation", "lin:cross-correlation", "lin:rref", "lin:solve", "lin:to-polar", "lin:from-polar", "grid:every?", "grid:some?", "grid:every-row?", "grid:some-row?", "grid:every-col?", "grid:some-col?", "grid:row", "grid:col", "grid:shape", "grid:fill", "grid:generate", "grid:reshape", "grid:transpose", "grid:flip-h", "grid:flip-v", "grid:rotate", "grid:reverse-rows", "grid:reverse-cols", "grid:slice", "grid:slice-rows", "grid:slice-cols", "grid:splice-rows", "grid:splice-cols", "grid:concat-rows", "grid:concat-cols", "grid:map", "grid:mapi", "grid:reduce", "grid:reducei", "grid:push-rows", "grid:unshift-rows", "grid:pop-row", "grid:shift-row", "grid:push-cols", "grid:unshift-cols", "grid:pop-col", "grid:shift-col", "grid:from-array", "nth:abundant-seq", "nth:abundant-nth", "nth:abundant-take-while", "nth:abundant?", "nth:bell-seq", "nth:bell-nth", "nth:bell-take-while", "nth:bell?", "nth:catalan-seq", "nth:catalan-nth", "nth:catalan-take-while", "nth:catalan?", "nth:composite-seq", "nth:composite-nth", "nth:composite-take-while", "nth:composite?", "nth:factorial-seq", "nth:factorial-nth", "nth:factorial-take-while", "nth:factorial?", "nth:fibonacci-seq", "nth:fibonacci-nth", "nth:fibonacci-take-while", "nth:fibonacci?", "nth:geometric-seq", "nth:geometric-nth", "nth:geometric-take-while", "nth:geometric?", "nth:golomb-seq", "nth:golomb-nth", "nth:golomb-take-while", "nth:golomb?", "nth:happy-seq", "nth:happy-nth", "nth:happy-take-while", "nth:happy?", "nth:look-and-say-seq", "nth:look-and-say-nth", "nth:look-and-say-take-while", "nth:look-and-say?", "nth:lucas-seq", "nth:lucas-nth", "nth:lucas-take-while", "nth:lucas?", "nth:lucky-seq", "nth:lucky-nth", "nth:lucky-take-while", "nth:lucky?", "nth:mersenne-seq", "nth:mersenne-nth", "nth:mersenne-take-while", "nth:mersenne?", "nth:padovan-seq", "nth:padovan-nth", "nth:padovan-take-while", "nth:padovan?", "nth:partition-seq", "nth:partition-nth", "nth:partition-take-while", "nth:partition?", "nth:pell-seq", "nth:pell-nth", "nth:pell-take-while", "nth:pell?", "nth:perfect-seq", "nth:perfect-nth", "nth:perfect-take-while", "nth:perfect?", "nth:perfect-cube-seq", "nth:perfect-cube-nth", "nth:perfect-cube-take-while", "nth:perfect-cube?", "nth:perfect-power-seq", "nth:perfect-power-nth", "nth:perfect-power-take-while", "nth:perfect-power?", "nth:perfect-square-seq", "nth:perfect-square-nth", "nth:perfect-square-take-while", "nth:perfect-square?", "nth:polygonal-seq", "nth:polygonal-nth", "nth:polygonal-take-while", "nth:polygonal?", "nth:prime-seq", "nth:prime-nth", "nth:prime-take-while", "nth:prime?", "nth:recaman-seq", "nth:recaman-nth", "nth:recaman-take-while", "nth:recaman?", "nth:sylvester-seq", "nth:sylvester-nth", "nth:sylvester-take-while", "nth:sylvester?", "nth:thue-morse-seq", "nth:thue-morse-nth", "nth:thue-morse-take-while", "nth:thue-morse?", "nth:tribonacci-seq", "nth:tribonacci-nth", "nth:tribonacci-take-while", "nth:tribonacci?", "nth:collatz-seq", "nth:juggler-seq", "nth:bernoulli-seq", "nth:bernoulli-take-while", "nth:bernoulli-nth", "nth:combinations", "nth:count-combinations", "nth:derangements", "nth:count-derangements", "nth:divisors", "nth:count-divisors", "nth:proper-divisors", "nth:count-proper-divisors", "nth:prime-factors", "nth:count-prime-factors", "nth:distinct-prime-factors", "nth:count-distinct-prime-factors", "nth:factorial", "nth:partitions", "nth:count-partitions", "nth:permutations", "nth:count-permutations", "nth:power-set", "nth:count-power-set", "nth:coprime?", "nth:divisible-by?", "nth:gcd", "nth:lcm", "nth:multinomial", "nth:amicable?", "nth:euler-totient", "nth:mobius", "nth:mertens", "nth:sigma", "nth:carmichael-lambda", "nth:cartesian-product", "nth:perfect-power", "nth:mod-exp", "nth:mod-inv", "nth:extended-gcd", "nth:chinese-remainder", "nth:stirling-first", "nth:stirling-second", "!:random", "!:random-int", "!:random-int-inclusive", "!:random-float", "!:random-boolean", "!:random-item", "!:random-sample", "!:random-sample-unique", "!:shuffle", "!:random-normal", "!:random-exponential", "!:random-binomial", "!:random-poisson", "!:random-gamma", "!:random-pareto", "!:uuid", "!:random-char", "!:random-string", "!:random-id", "!:random-color", "-short-regexp", "-short-fn", "-type-number", "-type-string", "-type-object", "-type-array", "-type-vector", "-type-matrix", "-type-grid", "-type-boolean", "-type-function", "-type-integer", "-type-any", "-type-null", "-type-collection", "-type-sequence", "-type-regexp", "-type-never"];
 export type ApiName = typeof apiNames[number];
 export declare function isApiName(arg: string): arg is ApiName;
 export declare const categoryRecord: {

package/dist/reference/index.d.ts

@@ -87,8 +87,13 @@ export declare const functionReference: {
     split: FunctionReference<"String" | "Array" | "Special expression" | "Predicate" | "Sequence" | "Collection" | "Object" | "Math" | "Functional" | "Regular expression" | "Bitwise" | "Misc" | "Assert" | "Vector" | "Linear Algebra" | "Matrix" | "Grid" | "Number Theory" | "Random" | "Shorthand" | "Datatype">;
     trim: FunctionReference<"String" | "Array" | "Special expression" | "Predicate" | "Sequence" | "Collection" | "Object" | "Math" | "Functional" | "Regular expression" | "Bitwise" | "Misc" | "Assert" | "Vector" | "Linear Algebra" | "Matrix" | "Grid" | "Number Theory" | "Random" | "Shorthand" | "Datatype">;
     repeat: FunctionReference<"String" | "Array" | "Special expression" | "Predicate" | "Sequence" | "Collection" | "Object" | "Math" | "Functional" | "Regular expression" | "Bitwise" | "Misc" | "Assert" | "Vector" | "Linear Algebra" | "Matrix" | "Grid" | "Number Theory" | "Random" | "Shorthand" | "Datatype">;
+    filteri: FunctionReference<"String" | "Array" | "Special expression" | "Predicate" | "Sequence" | "Collection" | "Object" | "Math" | "Functional" | "Regular expression" | "Bitwise" | "Misc" | "Assert" | "Vector" | "Linear Algebra" | "Matrix" | "Grid" | "Number Theory" | "Random" | "Shorthand" | "Datatype">;
+    mapi: FunctionReference<"String" | "Array" | "Special expression" | "Predicate" | "Sequence" | "Collection" | "Object" | "Math" | "Functional" | "Regular expression" | "Bitwise" | "Misc" | "Assert" | "Vector" | "Linear Algebra" | "Matrix" | "Grid" | "Number Theory" | "Random" | "Shorthand" | "Datatype">;
+    reducei: FunctionReference<"String" | "Array" | "Special expression" | "Predicate" | "Sequence" | "Collection" | "Object" | "Math" | "Functional" | "Regular expression" | "Bitwise" | "Misc" | "Assert" | "Vector" | "Linear Algebra" | "Matrix" | "Grid" | "Number Theory" | "Random" | "Shorthand" | "Datatype">;
     "reduce-right": FunctionReference<"String" | "Array" | "Special expression" | "Predicate" | "Sequence" | "Collection" | "Object" | "Math" | "Functional" | "Regular expression" | "Bitwise" | "Misc" | "Assert" | "Vector" | "Linear Algebra" | "Matrix" | "Grid" | "Number Theory" | "Random" | "Shorthand" | "Datatype">;
+    "reducei-right": FunctionReference<"String" | "Array" | "Special expression" | "Predicate" | "Sequence" | "Collection" | "Object" | "Math" | "Functional" | "Regular expression" | "Bitwise" | "Misc" | "Assert" | "Vector" | "Linear Algebra" | "Matrix" | "Grid" | "Number Theory" | "Random" | "Shorthand" | "Datatype">;
     reductions: FunctionReference<"String" | "Array" | "Special expression" | "Predicate" | "Sequence" | "Collection" | "Object" | "Math" | "Functional" | "Regular expression" | "Bitwise" | "Misc" | "Assert" | "Vector" | "Linear Algebra" | "Matrix" | "Grid" | "Number Theory" | "Random" | "Shorthand" | "Datatype">;
+    reductionsi: FunctionReference<"String" | "Array" | "Special expression" | "Predicate" | "Sequence" | "Collection" | "Object" | "Math" | "Functional" | "Regular expression" | "Bitwise" | "Misc" | "Assert" | "Vector" | "Linear Algebra" | "Matrix" | "Grid" | "Number Theory" | "Random" | "Shorthand" | "Datatype">;
     get: FunctionReference<"String" | "Array" | "Special expression" | "Predicate" | "Sequence" | "Collection" | "Object" | "Math" | "Functional" | "Regular expression" | "Bitwise" | "Misc" | "Assert" | "Vector" | "Linear Algebra" | "Matrix" | "Grid" | "Number Theory" | "Random" | "Shorthand" | "Datatype">;
     "get-in": FunctionReference<"String" | "Array" | "Special expression" | "Predicate" | "Sequence" | "Collection" | "Object" | "Math" | "Functional" | "Regular expression" | "Bitwise" | "Misc" | "Assert" | "Vector" | "Linear Algebra" | "Matrix" | "Grid" | "Number Theory" | "Random" | "Shorthand" | "Datatype">;
     "contains?": FunctionReference<"String" | "Array" | "Special expression" | "Predicate" | "Sequence" | "Collection" | "Object" | "Math" | "Functional" | "Regular expression" | "Bitwise" | "Misc" | "Assert" | "Vector" | "Linear Algebra" | "Matrix" | "Grid" | "Number Theory" | "Random" | "Shorthand" | "Datatype">;
@@ -105,6 +110,8 @@ export declare const functionReference: {
     range: FunctionReference<"String" | "Array" | "Special expression" | "Predicate" | "Sequence" | "Collection" | "Object" | "Math" | "Functional" | "Regular expression" | "Bitwise" | "Misc" | "Assert" | "Vector" | "Linear Algebra" | "Matrix" | "Grid" | "Number Theory" | "Random" | "Shorthand" | "Datatype">;
     flatten: FunctionReference<"String" | "Array" | "Special expression" | "Predicate" | "Sequence" | "Collection" | "Object" | "Math" | "Functional" | "Regular expression" | "Bitwise" | "Misc" | "Assert" | "Vector" | "Linear Algebra" | "Matrix" | "Grid" | "Number Theory" | "Random" | "Shorthand" | "Datatype">;
     mapcat: FunctionReference<"String" | "Array" | "Special expression" | "Predicate" | "Sequence" | "Collection" | "Object" | "Math" | "Functional" | "Regular expression" | "Bitwise" | "Misc" | "Assert" | "Vector" | "Linear Algebra" | "Matrix" | "Grid" | "Number Theory" | "Random" | "Shorthand" | "Datatype">;
+    "moving-fn": FunctionReference<"String" | "Array" | "Special expression" | "Predicate" | "Sequence" | "Collection" | "Object" | "Math" | "Functional" | "Regular expression" | "Bitwise" | "Misc" | "Assert" | "Vector" | "Linear Algebra" | "Matrix" | "Grid" | "Number Theory" | "Random" | "Shorthand" | "Datatype">;
+    "running-fn": FunctionReference<"String" | "Array" | "Special expression" | "Predicate" | "Sequence" | "Collection" | "Object" | "Math" | "Functional" | "Regular expression" | "Bitwise" | "Misc" | "Assert" | "Vector" | "Linear Algebra" | "Matrix" | "Grid" | "Number Theory" | "Random" | "Shorthand" | "Datatype">;
     second: FunctionReference<"String" | "Array" | "Special expression" | "Predicate" | "Sequence" | "Collection" | "Object" | "Math" | "Functional" | "Regular expression" | "Bitwise" | "Misc" | "Assert" | "Vector" | "Linear Algebra" | "Matrix" | "Grid" | "Number Theory" | "Random" | "Shorthand" | "Datatype">;
     nth: FunctionReference<"String" | "Array" | "Special expression" | "Predicate" | "Sequence" | "Collection" | "Object" | "Math" | "Functional" | "Regular expression" | "Bitwise" | "Misc" | "Assert" | "Vector" | "Linear Algebra" | "Matrix" | "Grid" | "Number Theory" | "Random" | "Shorthand" | "Datatype">;
     last: FunctionReference<"String" | "Array" | "Special expression" | "Predicate" | "Sequence" | "Collection" | "Object" | "Math" | "Functional" | "Regular expression" | "Bitwise" | "Misc" | "Assert" | "Vector" | "Linear Algebra" | "Matrix" | "Grid" | "Number Theory" | "Random" | "Shorthand" | "Datatype">;
@@ -221,7 +228,6 @@ export declare const functionReference: {
     "object?": FunctionReference<"String" | "Array" | "Special expression" | "Predicate" | "Sequence" | "Collection" | "Object" | "Math" | "Functional" | "Regular expression" | "Bitwise" | "Misc" | "Assert" | "Vector" | "Linear Algebra" | "Matrix" | "Grid" | "Number Theory" | "Random" | "Shorthand" | "Datatype">;
     "regexp?": FunctionReference<"String" | "Array" | "Special expression" | "Predicate" | "Sequence" | "Collection" | "Object" | "Math" | "Functional" | "Regular expression" | "Bitwise" | "Misc" | "Assert" | "Vector" | "Linear Algebra" | "Matrix" | "Grid" | "Number Theory" | "Random" | "Shorthand" | "Datatype">;
     "finite?": FunctionReference<"String" | "Array" | "Special expression" | "Predicate" | "Sequence" | "Collection" | "Object" | "Math" | "Functional" | "Regular expression" | "Bitwise" | "Misc" | "Assert" | "Vector" | "Linear Algebra" | "Matrix" | "Grid" | "Number Theory" | "Random" | "Shorthand" | "Datatype">;
-    "nan?": FunctionReference<"String" | "Array" | "Special expression" | "Predicate" | "Sequence" | "Collection" | "Object" | "Math" | "Functional" | "Regular expression" | "Bitwise" | "Misc" | "Assert" | "Vector" | "Linear Algebra" | "Matrix" | "Grid" | "Number Theory" | "Random" | "Shorthand" | "Datatype">;
     "positive-infinity?": FunctionReference<"String" | "Array" | "Special expression" | "Predicate" | "Sequence" | "Collection" | "Object" | "Math" | "Functional" | "Regular expression" | "Bitwise" | "Misc" | "Assert" | "Vector" | "Linear Algebra" | "Matrix" | "Grid" | "Number Theory" | "Random" | "Shorthand" | "Datatype">;
     "negative-infinity?": FunctionReference<"String" | "Array" | "Special expression" | "Predicate" | "Sequence" | "Collection" | "Object" | "Math" | "Functional" | "Regular expression" | "Bitwise" | "Misc" | "Assert" | "Vector" | "Linear Algebra" | "Matrix" | "Grid" | "Number Theory" | "Random" | "Shorthand" | "Datatype">;
     "true?": FunctionReference<"String" | "Array" | "Special expression" | "Predicate" | "Sequence" | "Collection" | "Object" | "Math" | "Functional" | "Regular expression" | "Bitwise" | "Misc" | "Assert" | "Vector" | "Linear Algebra" | "Matrix" | "Grid" | "Number Theory" | "Random" | "Shorthand" | "Datatype">;

package/dist/src/tokenizer/operators.d.ts

@@ -1,5 +1,5 @@
 declare const binaryOperators: readonly ["^", "*", "/", "%", "+", "-", "<<", ">>", ">>>", "++", "<", "<=", "≤", ">", ">=", "≥", "=", "!=", "≠", "&", "xor", "|", "&&", "||", "??", "|>"];
-declare const symbolicOperators: readonly ["^", "*", "/", "%", "+", "-", "<<", ">>", ">>>", "++", "<", "<=", "≤", ">", ">=", "≥", "=", "!=", "≠", "&", "xor", "|", "&&", "||", "??", "|>", "->", "...", ".", ",", ":=", ";"];
+declare const symbolicOperators: readonly ["^", "*", "/", "%", "+", "-", "<<", ">>", ">>>", "++", "<", "<=", "≤", ">", ">=", "≥", "=", "!=", "≠", "&", "xor", "|", "&&", "||", "??", "|>", "?", ":", "->", "...", ".", ",", ":=", ";"];
 export declare function isFunctionOperator(operator: string): boolean;
 export type SymbolicBinaryOperator = typeof binaryOperators[number];
 export type SymbolicOperator = typeof symbolicOperators[number];

package/dist/testFramework.esm.js

@@ -446,6 +446,8 @@ function isNumber(value, options) {
     if (options === void 0) { options = {}; }
     if (typeof value !== 'number')
         return false;
+    if (Number.isNaN(value))
+        return false;
     if (options.integer && !Number.isInteger(value))
         return false;
     if (options.finite && !Number.isFinite(value))
@@ -1066,6 +1068,35 @@ var collectionNormalExpression = {
         },
         paramCount: 2,
     },
+    'filteri': {
+        evaluate: function (_a, sourceCodeInfo, contextStack, _b) {
+            var _c = __read(_a, 2), coll = _c[0], fn = _c[1];
+            var executeFunction = _b.executeFunction;
+            assertColl(coll, sourceCodeInfo);
+            assertFunctionLike(fn, sourceCodeInfo);
+            if (Array.isArray(coll)) {
+                var result = coll.filter(function (elem, index) { return executeFunction(fn, [elem, index], contextStack, sourceCodeInfo); });
+                return result;
+            }
+            if (isString(coll)) {
+                return coll
+                    .split('')
+                    .filter(function (elem, index) { return executeFunction(fn, [elem, index], contextStack, sourceCodeInfo); })
+                    .join('');
+            }
+            return Object.entries(coll)
+                .filter(function (_a) {
+                var _b = __read(_a, 2), key = _b[0], value = _b[1];
+                return executeFunction(fn, [value, key], contextStack, sourceCodeInfo);
+            })
+                .reduce(function (result, _a) {
+                var _b = __read(_a, 2), key = _b[0], value = _b[1];
+                result[key] = value;
+                return result;
+            }, {});
+        },
+        paramCount: 2,
+    },
     'map': {
         evaluate: function (params, sourceCodeInfo, contextStack, _a) {
             var executeFunction = _a.executeFunction;
@@ -1108,6 +1139,30 @@ var collectionNormalExpression = {
         },
         paramCount: { min: 2 },
     },
+    'mapi': {
+        evaluate: function (_a, sourceCodeInfo, contextStack, _b) {
+            var _c = __read(_a, 2), coll = _c[0], fn = _c[1];
+            var executeFunction = _b.executeFunction;
+            assertColl(coll, sourceCodeInfo);
+            assertFunctionLike(fn, sourceCodeInfo);
+            if (Array.isArray(coll)) {
+                return coll.map(function (elem, index) { return executeFunction(fn, [elem, index], contextStack, sourceCodeInfo); });
+            }
+            if (isString(coll)) {
+                return coll
+                    .split('')
+                    .map(function (elem, index) { return executeFunction(fn, [elem, index], contextStack, sourceCodeInfo); })
+                    .join('');
+            }
+            return Object.entries(coll)
+                .reduce(function (acc, _a) {
+                var _b = __read(_a, 2), key = _b[0], value = _b[1];
+                acc[key] = executeFunction(fn, [value, key], contextStack, sourceCodeInfo);
+                return acc;
+            }, {});
+        },
+        paramCount: 2,
+    },
     'reduce': {
         evaluate: function (_a, sourceCodeInfo, contextStack, _b) {
             var _c = __read(_a, 3), coll = _c[0], fn = _c[1], initial = _c[2];
@@ -1141,6 +1196,39 @@ var collectionNormalExpression = {
         },
         paramCount: 3,
     },
+    'reducei': {
+        evaluate: function (_a, sourceCodeInfo, contextStack, _b) {
+            var _c = __read(_a, 3), coll = _c[0], fn = _c[1], initial = _c[2];
+            var executeFunction = _b.executeFunction;
+            assertColl(coll, sourceCodeInfo);
+            assertFunctionLike(fn, sourceCodeInfo);
+            assertAny(initial, sourceCodeInfo);
+            if (typeof coll === 'string') {
+                assertString(initial, sourceCodeInfo);
+                if (coll.length === 0)
+                    return initial;
+                return coll.split('').reduce(function (result, elem, index) {
+                    return executeFunction(fn, [result, elem, index], contextStack, sourceCodeInfo);
+                }, initial);
+            }
+            else if (Array.isArray(coll)) {
+                if (coll.length === 0)
+                    return initial;
+                return coll.reduce(function (result, elem, index) {
+                    return executeFunction(fn, [result, elem, index], contextStack, sourceCodeInfo);
+                }, initial);
+            }
+            else {
+                if (Object.keys(coll).length === 0)
+                    return initial;
+                return Object.entries(coll).reduce(function (result, _a) {
+                    var _b = __read(_a, 2), key = _b[0], elem = _b[1];
+                    return executeFunction(fn, [result, elem, key], contextStack, sourceCodeInfo);
+                }, initial);
+            }
+        },
+        paramCount: 3,
+    },
     'reduce-right': {
         evaluate: function (_a, sourceCodeInfo, contextStack, _b) {
             var _c = __read(_a, 3), coll = _c[0], fn = _c[1], initial = _c[2];
@@ -1173,6 +1261,38 @@ var collectionNormalExpression = {
         },
         paramCount: 3,
     },
+    'reducei-right': {
+        evaluate: function (_a, sourceCodeInfo, contextStack, _b) {
+            var _c = __read(_a, 3), coll = _c[0], fn = _c[1], initial = _c[2];
+            var executeFunction = _b.executeFunction;
+            assertColl(coll, sourceCodeInfo);
+            assertFunctionLike(fn, sourceCodeInfo);
+            assertAny(initial, sourceCodeInfo);
+            if (typeof coll === 'string') {
+                if (coll.length === 0)
+                    return initial;
+                return coll.split('').reduceRight(function (result, elem, index) {
+                    return executeFunction(fn, [result, elem, index], contextStack, sourceCodeInfo);
+                }, initial);
+            }
+            else if (Array.isArray(coll)) {
+                if (coll.length === 0)
+                    return initial;
+                return coll.reduceRight(function (result, elem, index) {
+                    return executeFunction(fn, [result, elem, index], contextStack, sourceCodeInfo);
+                }, initial);
+            }
+            else {
+                if (Object.keys(coll).length === 0)
+                    return initial;
+                return Object.entries(coll).reduceRight(function (result, _a) {
+                    var _b = __read(_a, 2), key = _b[0], elem = _b[1];
+                    return executeFunction(fn, [result, elem, key], contextStack, sourceCodeInfo);
+                }, initial);
+            }
+        },
+        paramCount: 3,
+    },
     'reductions': {
         evaluate: function (_a, sourceCodeInfo, contextStack, _b) {
             var _c = __read(_a, 3), coll = _c[0], fn = _c[1], initial = _c[2];
@@ -1219,6 +1339,52 @@ var collectionNormalExpression = {
         },
         paramCount: 3,
     },
+    'reductionsi': {
+        evaluate: function (_a, sourceCodeInfo, contextStack, _b) {
+            var _c = __read(_a, 3), coll = _c[0], fn = _c[1], initial = _c[2];
+            var executeFunction = _b.executeFunction;
+            assertColl(coll, sourceCodeInfo);
+            assertFunctionLike(fn, sourceCodeInfo);
+            assertAny(initial, sourceCodeInfo);
+            assertAny(initial, sourceCodeInfo);
+            if (typeof coll === 'string') {
+                assertString(initial, sourceCodeInfo);
+                if (coll.length === 0)
+                    return [initial];
+                var resultArray_4 = [initial];
+                coll.split('').reduce(function (result, elem, index) {
+                    var newVal = executeFunction(fn, [result, elem, index], contextStack, sourceCodeInfo);
+                    resultArray_4.push(newVal);
+                    return newVal;
+                }, initial);
+                return resultArray_4;
+            }
+            else if (Array.isArray(coll)) {
+                if (coll.length === 0)
+                    return [initial];
+                var resultArray_5 = [initial];
+                coll.reduce(function (result, elem, index) {
+                    var newVal = executeFunction(fn, [result, elem, index], contextStack, sourceCodeInfo);
+                    resultArray_5.push(newVal);
+                    return newVal;
+                }, initial);
+                return resultArray_5;
+            }
+            else {
+                if (Object.keys(coll).length === 0)
+                    return [initial];
+                var resultArray_6 = [initial];
+                Object.entries(coll).reduce(function (result, _a) {
+                    var _b = __read(_a, 2), key = _b[0], elem = _b[1];
+                    var newVal = executeFunction(fn, [result, elem, key], contextStack, sourceCodeInfo);
+                    resultArray_6.push(newVal);
+                    return newVal;
+                }, initial);
+                return resultArray_6;
+            }
+        },
+        paramCount: 3,
+    },
     'get': {
         evaluate: function (params, sourceCodeInfo) {
             var _a = __read(params, 2), coll = _a[0], key = _a[1];
@@ -1472,7 +1638,7 @@ var collectionNormalExpression = {
 };
 
 var arrayNormalExpression = {
-    range: {
+    'range': {
         evaluate: function (params, sourceCodeInfo) {
             var _a = __read(params, 3), first = _a[0], second = _a[1], third = _a[2];
             var from;
@@ -1510,7 +1676,7 @@ var arrayNormalExpression = {
         },
         paramCount: { min: 1, max: 3 },
     },
-    repeat: {
+    'repeat': {
         evaluate: function (_a, sourceCodeInfo) {
             var _b = __read(_a, 2), value = _b[0], count = _b[1];
             assertNumber(count, sourceCodeInfo, { integer: true, nonNegative: true });
@@ -1521,7 +1687,7 @@ var arrayNormalExpression = {
         },
         paramCount: 2,
     },
-    flatten: {
+    'flatten': {
         evaluate: function (_a, sourceCodeInfo) {
             var _b = __read(_a, 2), seq = _b[0], depth = _b[1];
             assertArray(seq, sourceCodeInfo);
@@ -1532,7 +1698,7 @@ var arrayNormalExpression = {
         },
         paramCount: { min: 1, max: 2 },
     },
-    mapcat: {
+    'mapcat': {
         evaluate: function (_a, sourceCodeInfo, contextStack, _b) {
             var _c = __read(_a, 2), arr = _c[0], fn = _c[1];
             var executeFunction = _b.executeFunction;
@@ -1542,6 +1708,38 @@ var arrayNormalExpression = {
         },
         paramCount: 2,
     },
+    'moving-fn': {
+        evaluate: function (_a, sourceCodeInfo, contextStack, _b) {
+            var _c = __read(_a, 3), arr = _c[0], windowSize = _c[1], fn = _c[2];
+            var executeFunction = _b.executeFunction;
+            assertArray(arr, sourceCodeInfo);
+            assertNumber(windowSize, sourceCodeInfo, { integer: true, lte: arr.length });
+            assertFunctionLike(fn, sourceCodeInfo);
+            var result = [];
+            for (var i = 0; i <= arr.length - windowSize; i++) {
+                var window_1 = arr.slice(i, i + windowSize);
+                var value = executeFunction(fn, [window_1], contextStack, sourceCodeInfo);
+                result.push(value);
+            }
+            return result;
+        },
+        paramCount: 3,
+    },
+    'running-fn': {
+        evaluate: function (_a, sourceCodeInfo, contextStack, _b) {
+            var _c = __read(_a, 2), arr = _c[0], fn = _c[1];
+            var executeFunction = _b.executeFunction;
+            assertArray(arr, sourceCodeInfo);
+            assertFunctionLike(fn, sourceCodeInfo);
+            var result = [];
+            for (var i = 0; i < arr.length; i += 1) {
+                var subArr = arr.slice(0, i + 1);
+                result.push(executeFunction(fn, [subArr], contextStack, sourceCodeInfo));
+            }
+            return result;
+        },
+        paramCount: 2,
+    },
 };
 
 var sequenceNormalExpression = {
@@ -2273,7 +2471,7 @@ function isVector(vector) {
     if (vectors.has(vector)) {
         return true;
     }
-    if (vector.every(function (elem) { return isNumber(elem, { finite: true }); })) {
+    if (vector.every(function (elem) { return isNumber(elem); })) {
         annotatedArrays.add(vector);
         vectors.add(vector);
         return true;
@@ -2382,7 +2580,7 @@ function isMatrix(matrix) {
             if (row.length !== nbrOfCols) {
                 return false;
             }
-            if (row.some(function (cell) { return !isNumber(cell, { finite: true }); })) {
+            if (row.some(function (cell) { return !isNumber(cell); })) {
                 return false;
             }
         }
@@ -3915,14 +4113,6 @@ var predicatesNormalExpression = {
         },
         paramCount: 1,
     },
-    'nan?': {
-        evaluate: function (_a, sourceCodeInfo) {
-            var _b = __read(_a, 1), value = _b[0];
-            assertNumber(value, sourceCodeInfo);
-            return Number.isNaN(value);
-        },
-        paramCount: 1,
-    },
     'positive-infinity?': {
         evaluate: function (_a, sourceCodeInfo) {
             var _b = __read(_a, 1), value = _b[0];
@@ -12484,8 +12674,13 @@ function evaluateNode(node, contextStack) {
             return contextStack.evaluateSymbol(node);
         case NodeTypes.ReservedSymbol:
             return evaluateReservedSymbol(node);
-        case NodeTypes.NormalExpression:
-            return annotate(evaluateNormalExpression(node, contextStack));
+        case NodeTypes.NormalExpression: {
+            var result = evaluateNormalExpression(node, contextStack);
+            if (typeof result === 'number' && Number.isNaN(result)) {
+                throw new LitsError('Number is NaN', node[2]);
+            }
+            return annotate(result);
+        }
         case NodeTypes.SpecialExpression:
             return annotate(evaluateSpecialExpression(node, contextStack));
         /* v8 ignore next 2 */
@@ -12877,6 +13072,8 @@ var binaryOperators = [
     '|>', // pipe
 ];
 var otherOperators = [
+    '?', // conditional operator
+    ':', // conditional operator
     '->', // lambda
     '...', // rest
     '.', // property accessor
@@ -12886,17 +13083,12 @@ var otherOperators = [
 ];
 var symbolicOperators = __spreadArray(__spreadArray([], __read(binaryOperators), false), __read(otherOperators), false);
 var nonFunctionOperators = [
-    '??',
-    '&&',
-    '||',
     'comment',
     'cond',
     'def',
     'defined?',
-    // 'defn',
     'do',
     'doseq',
-    // 'fn',
     'if',
     'let',
     'loop',
@@ -13474,8 +13666,9 @@ function untokenize(tokenStream) {
     }, '');
 }
 
-var exponentiationPrecedence = 11;
-var binaryFunctionalOperatorPrecedence = 2;
+var exponentiationPrecedence = 12;
+var binaryFunctionalOperatorPrecedence = 3;
+var conditionalOperatorPrecedence = 1;
 var placeholderRegexp = /^\$([1-9]\d?)?$/;
 function withSourceCodeInfo(node, sourceCodeInfo) {
     if (sourceCodeInfo) {
@@ -13490,38 +13683,39 @@ function getPrecedence(operatorSign, sourceCodeInfo) {
         case '*': // multiplication
         case '/': // division
         case '%': // remainder
-            return 10;
+            return 11;
         case '+': // addition
         case '-': // subtraction
-            return 9;
+            return 10;
         case '<<': // left shift
         case '>>': // signed right shift
         case '>>>': // unsigned right shift
-            return 8;
+            return 9;
         case '++': // string concatenation
-            return 7;
+            return 8;
         case '<': // less than
         case '<=': // less than or equal
         case '≤': // less than or equal
         case '>': // greater than
         case '>=': // greater than or equal
         case '≥': // greater than or equal
-            return 6;
+            return 7;
         case '=': // equal
         case '!=': // not equal
         case '≠': // not equal
-            return 5;
+            return 6;
         case '&': // bitwise AND
         case 'xor': // bitwise XOR
         case '|': // bitwise OR
-            return 4;
+            return 5;
         case '&&': // logical AND
         case '||': // logical OR
         case '??': // nullish coalescing
-            return 3;
+            return 4;
+        // leave room for binaryFunctionalOperatorPrecedence = 3
         case '|>': // pipe
-            return 1;
-        // leave room for binaryFunctionalOperatorPrecedence = 2
+            return 2;
+        // leave room for conditionalOperatorPrecedence = 1
         /* v8 ignore next 2 */
         default:
             throw new LitsError("Unknown binary operator: ".concat(operatorSign), sourceCodeInfo);
@@ -13569,13 +13763,15 @@ function fromBinaryOperatorToNode(operator, symbolNode, left, right, sourceCodeI
         case '||':
         case '??':
             return withSourceCodeInfo([NodeTypes.SpecialExpression, [specialExpressionTypes[operatorName], [left, right]]], sourceCodeInfo);
-        /* v8 ignore next 10 */
+        /* v8 ignore next 11 */
         case '.':
         case ';':
         case ':=':
         case ',':
         case '->':
         case '...':
+        case '?':
+        case ':':
             throw new LitsError("Unknown binary operator: ".concat(operatorName), sourceCodeInfo);
         default:
             throw new LitsError("Unknown binary operator: ".concat(operatorName), sourceCodeInfo);
@@ -13691,6 +13887,19 @@ var Parser = /** @class */ (function () {
                 }
                 left = createNamedNormalExpressionNode(operatorSymbol, [left, right], operator[2]);
             }
+            else if ((operator === null || operator === void 0 ? void 0 : operator[1]) === '?') {
+                if (conditionalOperatorPrecedence <= precedence) {
+                    break;
+                }
+                this.advance();
+                var trueNode = this.parseExpression();
+                if (!isOperatorToken(this.peek(), ':')) {
+                    throw new LitsError('Expected :', this.peekSourceCodeInfo());
+                }
+                this.advance();
+                var falseNode = this.parseExpression();
+                left = withSourceCodeInfo([NodeTypes.SpecialExpression, [specialExpressionTypes.if, [left, trueNode, falseNode]]], left[2]);
+            }
             else {
                 break;
             }