@nodef/extra-array.web 0.0.0-stage → 4.5.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
package/index.js.map ADDED
@@ -0,0 +1,7 @@
1
+ {
2
+ "version": 3,
3
+ "sources": ["https://jsr.io/@nodef/extra-function/1.4.1/index.ts", "https://jsr.io/@nodef/extra-number/2.6.0/index.ts", "../../index.ts"],
4
+ "sourcesContent": ["//#region TYPES\n/**\n * Unknown function type.\n * @params args arguments\n * @returns unknown value\n */\nexport type Function = (...args: unknown[]) => unknown;\n//#endregion\n\n\n\n\n//#region CONSTANTS\n/**\n * Do nothing.\n * @param _args arguments (ignored)\n * @example\n * ```javascript\n * xfunction.NOOP(1, 2);\n * // → undefined\n *\n * xfunction.NOOP('a', 'b');\n * // → undefined\n * ```\n */\nexport function NOOP(..._args: unknown[]): void {}\n// - https://lodash.com/docs/4.17.15#noop\n\n\n/**\n * Return false.\n * @param _args arguments (ignored)\n * @returns false.\n * @example\n * ```javascript\n * xfunction.FALSE();\n * // → false\n * ```\n */\nexport function FALSE(..._args: unknown[]): false {\n return false;\n}\n// - https://www.npmjs.com/package/boolbase\n\n\n/**\n * Return true.\n * @param _args arguments (ignored)\n * @returns true.\n * @example\n * ```javascript\n * xfunction.TRUE();\n * // → true\n * ```\n */\nexport function TRUE(..._args: unknown[]): true {\n return true;\n}\n// - https://www.npmjs.com/package/boolbase\n\n\n/**\n * Return the same (first) value.\n * @param v a value\n * @returns v\n * @example\n * ```javascript\n * xfunction.IDENTITY(1);\n * // → 1\n *\n * xfunction.IDENTITY('a');\n * // → 'a'\n * ```\n */\nexport function IDENTITY<T>(v: T): T {\n return v;\n}\n\n\n/**\n * Compare two values.\n * @param a a value\n * @param b another value\n * @returns a<b: -1, a=b: 0, a>b: 1\n * @example\n * ```javascript\n * xfunction.COMPARE(1, 2);\n * // → -1\n *\n * xfunction.COMPARE(2, 1);\n * // → 1\n *\n * xfunction.COMPARE(1, 1);\n * // → 0\n */\nexport function COMPARE<T>(a: T, b: T): number {\n return a<b? -1 : (a>b? 1 : 0);\n}\n\n\n/**\n * Return the arguments passed as a array.\n * @param args arguments\n * @returns [...args]\n * @example\n * ```javascript\n * xfunction.ARGUMENTS(1, 2);\n * // → [1, 2]\n *\n * xfunction.ARGUMENTS('a', 'b');\n * // → ['a', 'b']\n * ```\n */\nexport function ARGUMENTS(...args: unknown[]): unknown[] {\n return args;\n}\n//#endregion\n\n\n\n\n//#region METHODS (BUILTIN)\n//#region ABOUT\n/**\n * Get the name of a function.\n * @param x a function\n * @returns name\n * @example\n * ```javascript\n * import {delay, debounce} from \"jsr:@nodef/extra-function\";\n *\n * xfunction.name(delay);\n * // → 'delay'\n *\n * xfunction.name(debounce);\n * // → 'debounce'\n * ```\n */\nexport function name(x: Function): string {\n return x.name;\n}\n// - https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function/name\n// - https://www.npmjs.com/package/fn-name\n\n\n/**\n * Get the number of parameters of a function.\n * @param x a function\n * @returns |[p, q, ...]| | x(p, q, ...)\n * @example\n * ```javascript\n * xfunction.length(() => 0);\n * // → 0\n *\n * xfunction.length((x, y) => 0);\n * // → 2\n * ```\n */\nexport function length(x: Function): number {\n return x.length;\n}\nexport {length as arity};\n// - https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function/length\n//#endregion\n\n\n\n\n//#region BINDING\n/**\n * Bind this-object, and optional prefix arguments to a function.\n * @param x a function\n * @param ths this object to bind\n * @param prefix prefix arguments\n * @returns (...args) => this.x(...prefix, ...args)\n * @example\n * ```javascript\n * var array = [1];\n * var fn = xfunction.bind(Array.prototype.push, array);\n * fn(2, 3, 4); // push(2, 3, 4)\n * array;\n * // → [1, 2, 3, 4]\n *\n * var array = [1, 2, 3, 4];\n * var fn = xfunction.bind(Array.prototype.splice, array, 1);\n * fn(2); // splice(1, 2)\n * array;\n * // → [1, 4]\n * ```\n */\nexport function bind(x: Function, ths: unknown, ...prefix: unknown[]): Function {\n return x.bind(ths, ...prefix);\n}\n// - https://underscorejs.org/#bind\n// - https://lodash.com/docs/4.17.15#bind\n// - https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function/bind\n//#endregion\n\n\n\n\n//#region INVOCATION\n/**\n * Invoke a function with specified this-object, and arguments provided individually.\n * @param x a function\n * @param ths this object to invoke with\n * @param args arguments\n * @returns this.x(...args)\n * @example\n * ```javascript\n * var array = [1];\n * xfunction.call(Array.prototype.push, array, 2, 3, 4); // push(2, 3, 4)\n * array;\n * // → [1, 2, 3, 4]\n *\n * var array = [1, 2, 3, 4];\n * xfunction.call(Array.prototype.splice, array, 1, 2); // splice(1, 2)\n * array;\n * // → [1, 4]\n * ```\n */\nexport function call(x: Function, ths: unknown=null, ...args: unknown[]): unknown {\n return x.call(ths, ...args);\n}\n\n\n/**\n * Invoke a function with specified this-object, and arguments provided as an array.\n * @param x a function\n * @param ths this object to invoke with\n * @param args arguments array\n * @returns this.x(...args)\n * @example\n * ```javascript\n * var array = [1];\n * xfunction.apply(Array.prototype.push, array, [2, 3, 4]); // push(2, 3, 4)\n * array;\n * // → [1, 2, 3, 4]\n *\n * var array = [1, 2, 3, 4];\n * xfunction.apply(Array.prototype.splice, array, [1, 2]); // splice(1, 2)\n * array;\n * // → [1, 4]\n * ```\n */\nexport function apply(x: Function, ths: unknown=null, args: unknown[]): unknown {\n return x.apply(ths, args);\n}\n//#endregion\n//#endregion\n\n\n\n\n//#region METHODS (CUSTOM)\n//#region ABOUT\n/**\n * Check if value is a function.\n * @param v a value\n * @returns is function?\n * @example\n * ```javascript\n * xfunction.is(Object.keys);\n * // → true\n *\n * xfunction.is(() => 0);\n * // → true\n *\n * xfunction.is(async () => 0);\n * // → true\n *\n * xfunction.is(0);\n * // → false\n * ```\n */\nexport function is(v: unknown): v is Function {\n return typeof v===\"function\";\n}\n// - https://www.npmjs.com/package/is-function\n\n\n/**\n * Check if value is an async function.\n * @param v a value\n * @returns is async function?\n * @example\n * ```javascript\n * xfunction.isAsync(async () => 0);\n * // → true\n *\n * xfunction.isAsync(() => 0);\n * // → false\n * ```\n */\nexport function isAsync(v: unknown): boolean {\n const AsyncFunction = (async function () {}).constructor;\n return v instanceof AsyncFunction;\n}\n// - https://www.npmjs.com/package/is-async-function\n// - https://www.npmjs.com/package/is-callback-function\n// - https://davidwalsh.name/javascript-detect-async-function\n// - https://stackoverflow.com/questions/38508420/how-to-know-if-a-function-is-async\n// - https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/async_function\n// - https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/AsyncFunction\n\n\n/**\n * Check if value is a generator function.\n * @param v a value\n * @returns is generator function?\n * @example\n * ```javascript\n * function* naturalNumbers() {\n * for (var i=0;; ++i)\n * yield i;\n * }\n *\n * xfunction.isGenerator(naturalNumbers);\n * // → true\n *\n * xfunction.isGenerator(() => 0);\n * // → false\n * ```\n */\nexport function isGenerator(v: unknown): v is GeneratorFunction {\n const GeneratorFunction = (function* () {}).constructor;\n return v instanceof GeneratorFunction;\n}\n// - https://www.npmjs.com/package/is-generator\n// - https://www.npmjs.com/package/is-generator-fn\n// - https://www.npmjs.com/package/is-generator-function\n// - https://stackoverflow.com/questions/16754956/check-if-function-is-a-generator\n// - https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/function*\n// - https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Generator\n// - https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/GeneratorFunction\n//#endregion\n\n\n\n\n//#region CONTEXT\n/**\n * Contextify a function by accepting the first parameter as this-object.\n * @param x a function\n * @returns (...args) => x(this, ...args)\n * @example\n * ```javascript\n * function count(x, value) {\n * var a = 0;\n * for (var v of x)\n * if (v===value) ++a;\n * return a;\n * }\n *\n * var fn = xfunction.contextify(count);\n *\n * fn.call([6, 3, 4, 3], 3);\n * // → 2\n *\n * fn.call([6, 1, 4, 3], 3);\n * // → 1\n * ```\n */\nexport function contextify(x: Function): Function {\n return function(this: unknown, ...args: unknown[]) { return x(this, ...args); };\n}\n\n\n/**\n * Decontextify a function by accepting this-object as the first argument.\n * @param x a function\n * @returns (this, ...args) => this.x(...args)\n * @example\n * ```javascript\n * function count(value) {\n * var a = 0;\n * for (var v of this)\n * if (v===value) ++a;\n * return a;\n * }\n *\n * var fn = xfunction.decontextify(count);\n *\n * fn([6, 3, 4, 3], 3);\n * // → 2\n *\n * fn([6, 1, 4, 3], 3);\n * // → 1\n * ```\n */\nexport function decontextify(x: Function): Function {\n return (ths: unknown=null, ...args: unknown[]) => x.call(ths, ...args);\n}\n//#endregion\n\n\n\n\n//#region RESULT MANIPULATION\n/**\n * Generate a result-negated version of a function.\n * @param x a function\n * @returns (...args) => !x(...args)\n * @example\n * ```javascript\n * var fn = xfunction.negate(isFinite);\n * fn(Infinity)\n * // → true\n * fn(1)\n * // → false\n *\n * var fn = xfunction.negate(isNaN);\n * fn(1);\n * // → true\n * fn(NaN);\n * // → false\n * ```\n */\nexport function negate(x: Function): Function {\n return (...args: unknown[]) => !x(...args);\n}\n//#endregion\n\n\n\n\n//#region RESULT CACHING\n/**\n * Resolve arguments into a unique key.\n * @param args arguments\n * @returns unique key\n */\nexport type Resolver = (...args: unknown[]) => unknown;\n\n\n/**\n * Generate result-cached version of a function.\n * @param x a function\n * @param fr resolver ((...args) => unique key) [IDENTITY]\n * @param cache result cache [Map()]\n * @example\n * ```javascript\n * var calls = 0;\n *\n * function factorialRec(n: number) {\n * if (n<=1) return 1;\n * return n * factorialRec(n-1);\n * }\n *\n * function factorial(n: number) {\n * ++calls;\n * return factorialRec(n);\n * }\n *\n * var fn = xfunction.memoize(factorial);\n * fn(3);\n * // → 6\n * fn(4);\n * // → 24\n * fn(5);\n * // → 120\n * fn(3);\n * // → 6\n * fn(4);\n * // → 24\n * fn(5);\n * // → 120\n * calls;\n * // → 3\n *\n *\n * var calls = 0;\n *\n * function hypot(x: number, y: number) {\n * ++calls;\n * return Math.hypot(x, y);\n * }\n *\n * function resolver(x: number, y: number) {\n * return 4093*y + x; // a hash\n * }\n *\n * var fn = xfunction.memoize(hypot, resolver);\n * fn(3, 4);\n * // → 5\n * fn(6, 8);\n * // → 10\n * fn(5, 12);\n * // → 13\n * fn(3, 4);\n * // → 5\n * fn(6, 8);\n * // → 10\n * fn(5, 12);\n * // → 13\n * calls;\n * // → 3\n * ```\n */\nexport function memoize(x: Function, fr: Resolver | null=null, cache: Map<unknown, unknown> | null=null): Function {\n fr = fr || IDENTITY;\n cache = cache || new Map();\n return (...args: unknown[]) => {\n const k = fr(...args);\n if (cache.has(k)) return cache.get(k);\n const v = x(...args);\n cache.set(k, v);\n return v;\n };\n}\n// - https://www.npmjs.com/package/memoizee\n// - https://www.npmjs.com/package/memoizerific\n//#endregion\n\n\n\n\n//#region PARAMETER MANIPULATION\n/**\n * Generate a parameter-reversed version of a function.\n * @param x a function\n * @returns (p, q, ...) => x(..., q, p)\n * @example\n * ```javascript\n * function divide(x, y) {\n * return x/y;\n * }\n *\n * var fn = xfunction.reverse(divide);\n * fn(2, 4);\n * // → 2\n * fn(2, 6);\n * // → 3\n * fn(2, 8);\n * // → 4\n *\n *\n * var array = [1];\n *\n * function push(...args) {\n * array.push(...args);\n * }\n *\n * var fn = xfunction.reverse(push);\n * fn(2, 3, 4); // push(2, 3, 4) in reverse order\n * array;\n * // → [1, 4, 3, 2]\n * ```\n */\nexport function reverse(x: Function): Function {\n return (...args: unknown[]) => x(...args.reverse());\n}\nexport {reverse as flip};\n\n\n/**\n * Generate a (first) parameter-spreaded version of a function.\n * @param x a function\n * @returns (p, q, ...) => x([p, q, ...])\n * @example\n * ```javascript\n * function sum(x: number[]) {\n * var a = 0;\n * for (var v of x)\n * a += v;\n * return a;\n * }\n *\n * var fn = xfunction.spread(sum);\n * fn(1, 2, 3); // sum([1, 2, 3])\n * // → 6\n *\n *\n * var array = [1];\n *\n * function concat(x: number[]) {\n * return array.concat(x);\n * }\n *\n * var fn = xfunction.spread(concat);\n * fn(2, 3, 4); // concat([2, 3, 4])\n * // → [1, 2, 3, 4]\n * ```\n */\nexport function spread(x: Function): Function {\n return (...args: unknown[]) => x(args);\n}\n\n\n/**\n * Generate a (first) parameter-collapsed version of a function.\n * @param x a function\n * @returns ([p, q, ...]) => x(p, q, ...)\n * @example\n * ```javascript\n * var fn = xfunction.unspread(Math.min);\n * fn([7, 4, 9]); // Math.min(7, 4, 9)\n * // → 4\n *\n * var fn = xfunction.unspread((x, i, I) => x.slice(i, I));\n * fn([[1, 2, 3, 4], 2]); // [1, 2, 3, 4].slice(2)\n * // → [3, 4]\n * ```\n */\nexport function unspread(x: Function): Function {\n return (args: unknown) => x(...(args as unknown[]));\n}\n\n\n/**\n * Attach prefix arguments to leftmost parameters of a function.\n * @param x a function\n * @param prefix prefix arguments\n * @returns (...args) => x(...prefix, ...args)\n * @example\n * ```javascript\n * var fn = xfunction.attach(Math.min, 100);\n * fn(180, 130); // Math.min(100, 180, 130)\n * // → 100\n *\n * var array = [1];\n * var fn = xfunction.attach((...vs) => array.push(...vs), 10, 10);\n * fn(1, 2, 3); // array.push(10, 10, 1, 2, 3)\n * array;\n * // → [1, 10, 10, 1, 2, 3]\n * ```\n */\nexport function attach(x: Function, ...prefix: unknown[]): Function {\n return (...args: unknown[]) => x(...prefix, ...args);\n}\nexport {attach as partial};\n\n\n/**\n * Attach suffix arguments to rightmost parameters of a function.\n * @param x a function\n * @param suffix suffix arguments\n * @returns (...args) => x(...args, ...suffix)\n * @example\n * ```javascript\n * var fn = xfunction.attachRight(Math.min, 100);\n * fn(180, 130); // Math.min(180, 130, 100)\n * // → 100\n *\n * var array = [1];\n * var fn = xfunction.attachRight((...vs) => array.push(...vs), 10, 10);\n * fn(1, 2, 3); // array.push(1, 2, 3, 10, 10)\n * array;\n * // → [1, 1, 2, 3, 10, 10]\n * ```\n */\nexport function attachRight(x: Function, ...suffix: unknown[]): Function {\n return (...args: unknown[]) => x(...args, ...suffix);\n}\nexport {attachRight as partialRight};\n//#endregion\n\n\n\n\n//#region FUNCTIONAL BEHAVIOUR\n/**\n * Compose functions together, in applicative order.\n * @param xs functions (f, g)\n * @returns (f o g), or f(g(x))\n * @example\n * ```javascript\n * var fn = xfunction.compose(Math.sqrt, Math.abs);\n * fn(-64); // Math.sqrt(Math.abs(-64))\n * // → 8\n *\n * var fn = xfunction.compose(Math.sqrt, Math.min);\n * fn(22, 9); // Math.sqrt(Math.min(22, 9))\n * // → 3\n * ```\n */\nexport function compose(...xs: Function[]): Function {\n return composeRight(...xs.reverse());\n}\n// - https://en.wikipedia.org/wiki/Function_composition\n// - http://learnyouahaskell.com/higher-order-functions\n// - https://www.npmjs.com/package/compose-function\n\n\n/**\n * Compose functions together, such that result is piped forward.\n * @param xs functions (f, g)\n * @returns (f ▷ g), or g(f(x))\n * @example\n * ```javascript\n * var fn = xfunction.composeRight(Math.abs, Math.sqrt);\n * fn(-64); // Math.sqrt(Math.abs(-64))\n * // → 8\n *\n * var fn = xfunction.composeRight(Math.min, Math.sqrt);\n * fn(22, 9); // Math.sqrt(Math.min(22, 9))\n * // → 3\n * ```\n */\nexport function composeRight(...xs: Function[]): Function {\n return (...args: unknown[]) => {\n if (xs.length===0) return;\n let a = xs[0](...args);\n for (let i=1, I=xs.length; i<I; i++)\n a = xs[i](a);\n return a;\n };\n}\n// - https://stackoverflow.com/questions/1457140/haskell-composition-vs-fs-pipe-forward-operator\n// - https://www.npmjs.com/package/chain-function\n\n\n/**\n * Generate curried version of a function.\n * @param x a function\n * @param n number of parameters [all]\n * @returns (p)(q)(...) => x(p, q, ...)\n * @example\n * ```javascript\n * var sub = (x: number, y: number) => x - y;\n * var fn = xfunction.curry(sub);\n * fn(2)(3); // sub(2, 3)\n * // → -1\n *\n * var fn = xfunction.curry(Math.min, 3);\n * fn(5)(8)(3); // Math.min(5, 8, 3)\n * // → 3\n * ```\n */\nexport function curry(x: Function, n: number=x.length): Function {\n return (...args: unknown[]) => {\n if (args.length>=n) return x(...args);\n else return curry((...rest: unknown[]) => x(...args, ...rest), n-args.length);\n };\n}\n// - https://www.npmjs.com/package/@spudly/curry\n\n\n/**\n * Generate right-curried version of a function.\n * @param x a function\n * @param n number of parameters [all]\n * @returns (p)(q)(...) => x(..., q, p)\n * @example\n * ```javascript\n * var sub = (x: number, y: number) => x - y;\n * var fn = xfunction.curryRight(sub);\n * fn(2)(3); // sub(3, 2)\n * // → 1\n *\n * var array = [1];\n * var push2 = (x: number, y: number) => array.push(x, y);\n * var fn = xfunction.curryRight(push2, 2);\n * fn(2)(3); // push2(3, 2)\n * array;\n * // → [1, 3, 2]\n * ```\n */\nexport function curryRight(x: Function, n: number=x.length): Function {\n return curry(reverse(x), n);\n}\n// - https://www.npmjs.com/package/lodash.curryright\n//#endregion\n\n\n\n\n//#region TIME CONTROL\n/** Invocation control for time/rate-controlled functions. */\nexport interface InvocationControl {\n /** Disable invoking of target function. */\n clear: () => void;\n /** Immediately invoke target function. */\n flush: () => void;\n}\n\n\n/**\n * Generate deferred version of a function, that executes after the current stack has cleared.\n * @param x a function\n * @returns (...args) => invocation control\n * @example\n * ```javascript\n * var count = 0;\n * var fn = xfunction.defer(() => ++count);\n * fn();\n * fn();\n * // `count` incremented after 0s\n * // `count` incremented after 0s\n * ```\n */\nexport function defer(x: Function): Function {\n return (...args: unknown[]): InvocationControl => {\n let h: NodeJS.Timeout | number = setTimeout(flush, 0);\n function clear() { clearTimeout(h as number); h = 0; }\n function flush() { x(...args); clear(); }\n return {clear, flush};\n };\n}\n\n\n/**\n * Generate delayed version of a function.\n * @param x a function\n * @param t delay time (ms)\n * @returns (...args) => invocation control\n * @example\n * ```javascript\n * var count = 0;\n * var fn = xfunction.delay(() => ++count, 500);\n * setTimeout(fn, 0);\n * setTimeout(fn, 1000);\n * // `count` incremented after 0.5s\n * // `count` incremented after 1.5s\n *\n *\n * var count = 0;\n * var fn = xfunction.delay(() => ++count, 500);\n * setTimeout(fn, 0);\n * setTimeout(fn, 1000);\n * setTimeout(fn, 2000);\n * setTimeout(fn, 3000);\n * // `count` incremented after 0.5s\n * // `count` incremented after 1.5s\n * // `count` incremented after 2.5s\n * // `count` incremented after 3.5s\n * ```\n */\nexport function delay(x: Function, t: number): Function {\n return (...args: unknown[]): InvocationControl => {\n let h: NodeJS.Timeout | number = setTimeout(flush, t);\n function clear() { clearTimeout(h as number); h = 0; }\n function flush() { x(...args); clear(); }\n return {clear, flush};\n }\n}\n//#endregion\n\n\n\n\n//#region RATE CONTROL (COUNT)\n/**\n * Generate restricted-use version of a function.\n * @param x a function\n * @param start usable from\n * @param end usable till (excluding) [-1 ⇒ end]\n * @returns (...args) => x(...args) from [start:end] calls\n * @example\n * ```javascript\n * var sum = 0;\n * var add = (x: number) => sum += x;\n * var fn = xfunction.restrict(add, 0, 4);\n * for (var i=0; i<10; ++i)\n * fn(i);\n * sum; // 0 + 1 + 2 + 3\n * // → 6\n *\n *\n * var sum = 0;\n * var add = (x: number) => sum += x;\n * var fn = xfunction.restrict(add, 4, 8);\n * for (var i=0; i<10; ++i)\n * fn(i);\n * sum; // 4 + 5 + 6 + 7\n * // → 22\n * ```\n */\nexport function restrict(x: Function, start: number, end: number=-1): Function {\n let i = -1;\n return (...args: unknown[]) => {\n if ((++i<start)===(i<end || end<0)) return;\n return x(...args);\n };\n}\n// - https://www.npmjs.com/package/one-time\n// - https://www.npmjs.com/package/onetime\n// - https://www.npmjs.com/package/once\n// - https://lodash.com/docs/4.17.15#after\n// - https://lodash.com/docs/4.17.15#before\n\n\n/**\n * Restrict a function to be used only once.\n * @param x a function\n * @returns (...args) => x(...args) from [0:1] calls\n * @example\n * ```javascript\n * var count = 0;\n * var fn = xfunction.restrictOnce(x => ++count);\n * for (var i=0; i<10; ++i)\n * fn(i);\n * count;\n * // → 1\n * ```\n */\nexport function restrictOnce(x: Function): Function {\n return restrict(x, 0, 1);\n}\nexport {restrictOnce as once};\n// - https://www.npmjs.com/package/one-time\n// - https://www.npmjs.com/package/onetime\n// - https://www.npmjs.com/package/once\n\n\n/**\n * Restrict a function to be used only upto a certain number of calls.\n * @param x a function\n * @param n number of calls upto which it is usable\n * @returns (...args) => x(...args) from [0:n] calls\n * @example\n * ```javascript\n * var count = 0;\n * var fn = xfunction.restrictBefore(x => ++count, 3);\n * for (var i=0; i<10; ++i)\n * fn(i);\n * count;\n * // → 3\n * ```\n */\nexport function restrictBefore(x: Function, n: number): Function {\n return restrict(x, 0, n);\n}\nexport {restrictBefore as before};\n// - https://lodash.com/docs/4.17.15#before\n\n\n/**\n * Restrict a function to be used only after a certain number of calls.\n * @param x a function\n * @param n number of calls after which it is usable\n * @returns (...args) => x(...args) from [n:end] calls\n * @example\n * ```javascript\n * var count = 0;\n * var fn = xfunction.restrictAfter(x => ++count, 3);\n * for (var i=0; i<10; ++i)\n * fn(i);\n * count;\n * // → 7\n * ```\n */\nexport function restrictAfter(x: Function, n: number): Function {\n return restrict(x, n);\n}\nexport {restrictAfter as after};\n// - https://lodash.com/docs/4.17.15#after\n//#endregion\n\n\n\n\n//#region RATE CONTROL (TIME)\n/**\n * Generate debounced version of a function.\n * @param x a function\n * @param t delay time (ms)\n * @param T max delay time [-1 ⇒ none]\n * @returns (...args) => invocation control\n * @example\n * ```javascript\n * var count = 0;\n * var fn = xfunction.debounce(() => ++count, 1500);\n * setTimeout(fn, 0);\n * setTimeout(fn, 1000);\n * setTimeout(fn, 2000);\n * setTimeout(fn, 4000);\n * setTimeout(fn, 5000);\n * // `count` incremented after 3.5s\n * // `count` incremented after 6.5s\n *\n *\n * var count = 0;\n * var fn = xfunction.debounce(() => ++count, 1500);\n * setTimeout(fn, 0);\n * setTimeout(fn, 500);\n * setTimeout(fn, 1000);\n * setTimeout(fn, 1500);\n * setTimeout(fn, 2000);\n * setTimeout(fn, 4000);\n * setTimeout(fn, 4500);\n * setTimeout(fn, 5000);\n * // `count` incremented after 3.5s\n * // `count` incremented after 6.5s\n *\n *\n * var count = 0;\n * var fn = xfunction.debounce(() => ++count, 1500, 3500);\n * setTimeout(fn, 0);\n * setTimeout(fn, 1000);\n * setTimeout(fn, 2000);\n * setTimeout(fn, 3000);\n * setTimeout(fn, 4000);\n * setTimeout(fn, 6000);\n * // `count` incremented after 3.5s\n * // `count` incremented after 5.5s\n * // `count` incremented after 7.5s\n * ```\n */\nexport function debounce(x: Function, t: number, T: number=-1): Function {\n let savedArgs: unknown[];\n let h = 0 as NodeJS.Timeout | number, H = 0 as NodeJS.Timeout | number;\n function clear() {\n clearTimeout(h as number);\n clearTimeout(H as number);\n h = H = 0;\n }\n function flush() { x(...savedArgs); clear(); };\n return (...args: unknown[]): InvocationControl => {\n savedArgs = args;\n if (T>=0) H = H || setTimeout(flush, T);\n if (T<0 || t<T) { clearTimeout(h as number); h = setTimeout(flush, t); }\n return {clear, flush};\n };\n}\n// - https://github.com/lodash/lodash/blob/4.8.0-npm/debounce.js\n// - https://github.com/jashkenas/underscore/commit/9e3e067f5025dbe5e93ed784f93b233882ca0ffe\n// - https://css-tricks.com/debouncing-throttling-explained-examples/\n// - https://www.npmjs.com/package/debounce\n\n\n/**\n * Generate leading-edge debounced version of a function.\n * @param x a function\n * @param t delay time (ms)\n * @param T max delay time [-1 ⇒ none]\n * @returns (...args) => invocation control\n * @example\n * ```javascript\n * var count = 0;\n * var fn = xfunction.debounceEarly(() => ++count, 1500);\n * setTimeout(fn, 0);\n * setTimeout(fn, 1000);\n * setTimeout(fn, 2000);\n * setTimeout(fn, 4000);\n * setTimeout(fn, 5000);\n * // `count` incremented after 0s\n * // `count` incremented after 4s\n *\n *\n * var count = 0;\n * var fn = xfunction.debounceEarly(() => ++count, 1500);\n * setTimeout(fn, 0);\n * setTimeout(fn, 500);\n * setTimeout(fn, 1000);\n * setTimeout(fn, 1500);\n * setTimeout(fn, 2000);\n * setTimeout(fn, 4000);\n * setTimeout(fn, 4500);\n * setTimeout(fn, 5000);\n * // `count` incremented after 0s\n * // `count` incremented after 4s\n *\n *\n * var count = 0;\n * var fn = xfunction.debounceEarly(() => ++count, 1500, 3500);\n * setTimeout(fn, 0);\n * setTimeout(fn, 1000);\n * setTimeout(fn, 2000);\n * setTimeout(fn, 3000);\n * setTimeout(fn, 4000);\n * setTimeout(fn, 6000);\n * // `count` incremented after 0s\n * // `count` incremented after 4s\n * // `count` incremented after 6s\n * ```\n */\nexport function debounceEarly(x: Function, t: number, T: number=-1): Function {\n let h = 0 as NodeJS.Timeout | number, H = 0 as NodeJS.Timeout | number;\n function clear() { h = H = 0; }\n function flush() { clear(); }\n return (...args: unknown[]): InvocationControl => {\n if (!h && !H) x(...args);\n if (T>=0) H = H || setTimeout(flush, T);\n if (T<0 || t<T) { clearTimeout(h as number); h = setTimeout(flush, t); }\n return {clear, flush};\n };\n}\n// - https://github.com/lodash/lodash/blob/4.8.0-npm/debounce.js\n// - https://github.com/jashkenas/underscore/commit/9e3e067f5025dbe5e93ed784f93b233882ca0ffe\n// - https://css-tricks.com/debouncing-throttling-explained-examples/\n// - https://www.npmjs.com/package/debounce\n\n\n/**\n * Generate throttled version of a function.\n * @param x a function\n * @param t wait time (ms)\n * @returns (...args) => invocation control\n * @example\n * ```javascript\n * var count = 0;\n * var fn = xfunction.throttle(() => ++count, 2500);\n * setTimeout(fn, 0);\n * setTimeout(fn, 1000);\n * setTimeout(fn, 2000);\n * // `count` incremented after 2.5s\n *\n *\n * var count = 0;\n * var fn = xfunction.throttle(() => ++count, 2500);\n * setTimeout(fn, 0);\n * setTimeout(fn, 1000);\n * setTimeout(fn, 2000);\n * setTimeout(fn, 3000);\n * setTimeout(fn, 4000);\n * // `count` incremented after 2.5s\n * // `count` incremented after 5.5s\n * ```\n */\nexport function throttle(x: Function, t: number): Function {\n let savedArgs: unknown[];\n let h = 0 as NodeJS.Timeout | number;\n function clear() { h = 0; }\n function flush() { x(...savedArgs); clear(); }\n return (...args: unknown[]): InvocationControl => {\n savedArgs = args;\n h = h || setTimeout(flush, t);\n return {clear, flush};\n };\n}\n// - https://www.npmjs.com/package/throttle-debounce\n// - https://www.npmjs.com/package/throttleit\n\n\n/**\n * Generate leading-edge throttled version of a function.\n * @param x a function\n * @param t wait time (ms)\n * @returns (...args) => invocation control\n * @example\n * ```javascript\n * var count = 0;\n * var fn = xfunction.throttleEarly(() => ++count, 2500);\n * setTimeout(fn, 0);\n * setTimeout(fn, 1000);\n * setTimeout(fn, 2000);\n * // `count` incremented after 0s\n *\n *\n * var count = 0;\n * var fn = xfunction.throttleEarly(() => ++count, 2500);\n * setTimeout(fn, 0);\n * setTimeout(fn, 1000);\n * setTimeout(fn, 2000);\n * setTimeout(fn, 3000);\n * setTimeout(fn, 4000);\n * // `count` incremented after 0s\n * // `count` incremented after 3s\n * ```\n */\nexport function throttleEarly(x: Function, t: number): Function {\n let h = 0 as NodeJS.Timeout | number;\n function clear() { h = 0; }\n function flush() { clear(); }\n return (...args: unknown[]): InvocationControl => {\n if (!h) x(...args);\n h = h || setTimeout(flush, t);\n return {clear, flush};\n };\n}\n// - https://www.npmjs.com/package/throttle-debounce\n// - https://www.npmjs.com/package/throttleit\n\n\n// TODO: Is a generator function better for this?\n// function backoffRetryRec(x: Function, args: unknown[], err: unknown, n: number, N: number, t: number, T: number, tf: number): void {\n// if (N>=0 && n>=N) throw err;\n// if (T>=0 && t>=T) throw err;\n// try { return x(...args, err); }\n// catch(e) { setTimeout(() => backoffRetryRec(x, args, e, n+1, N, t*tf, T, tf), t); }\n// }\n\n//\n// TODO: Generate exponential-backoff-retried version of a function.\n// @param x a function\n// @param N maximum retries (-1 ⇒ unlimited)\n// @param t initial retry time (1 ms)\n// @param T maximum retry time [-1 ⇒ none]\n// @param tf retry time factor [2]\n//\n// function backoffRetry(x: Function, N: number, t: number, T: number=-1, tf: number=2): Function {\n// return (...args: unknown[]) => backoffRetryRec(x, args, null, 0, N, t, T, tf);\n// }\n// - TODO\n//#endregion\n//#endregion\n", "//#region TYPES\n/** Classification of floating point numbers. */\nexport enum FloatClass {\n /** Number is zero. */\n ZERO = 0x00,\n /** Number is subnormal (denormal). */\n SUBNORMAL = 0x10,\n /** Number is normal. */\n NORMAL = 0x20,\n /** Number is infinite. */\n INFINITE = 0x30,\n /** Number is NaN (not a number). */\n NAN = 0x40,\n}\n//#endregion\n\n\n\n\n//#region CONSTANTS\n/** Smallest normal (not subnormal) 64-bit floating point number. */\nexport const MIN_NORMAL = 2.2250738585072014e-308;\n/** Ratio of a circle's circumference to its diameter. */\nexport const TAU = 2 * Math.PI;\n//#endregion\n\n\n\n\n//#region ABOUT\n/**\n * Check if value is a number.\n * @param v a value\n * @returns is number?\n * @example\n * ```ts\n * xnumber.is(3.14);\n * // → true\n *\n * xnumber.is(NaN);\n * // → true (an unexpressable number)\n *\n * xnumber.is('3.14');\n * // → false\n *\n * xnumber.is({'value': 3.14});\n * // → false\n *\n * xnumber.is(null);\n * // → false\n * ```\n */\nexport function is(v: unknown): v is number {\n return typeof v === \"number\";\n}\n\n\n/**\n * Check if number is normal (not zero, subnormal, infinite, or NaN).\n * @param x a number\n * @returns is normal number?\n * @example\n * ```ts\n * xnumber.isNormal(3.14);\n * // → true\n *\n * xnumber.isNormal(0);\n * // → false\n *\n * xnumber.isNormal(1e-320);\n * // → false\n *\n * xnumber.isNormal(Infinity);\n * // → false\n */\nexport function isNormal(x: number): boolean {\n if (x === 0) return false;\n if (!Number.isFinite(x)) return false;\n if (Math.abs(x) < MIN_NORMAL) return false;\n return true;\n}\n\n\n/**\n * Classify a number into its floating point category.\n * @param x a number\n * @returns floating point class of `x`\n * @example\n * ```ts\n * xnumber.classify(0);\n * // → FloatClass.ZERO\n *\n * xnumber.classify(1e-320);\n * // → FloatClass.SUBNORMAL\n *\n * xnumber.classify(3.14);\n * // → FloatClass.NORMAL\n *\n * xnumber.classify(Infinity);\n * // → FloatClass.INFINITE\n *\n * xnumber.classify(NaN);\n * // → FloatClass.NAN\n */\nexport function classify(x: number): FloatClass {\n if (x === 0) return FloatClass.ZERO;\n if (Number.isNaN(x)) return FloatClass.NAN;\n if (!Number.isFinite(x)) return FloatClass.INFINITE;\n if (Math.abs(x) < MIN_NORMAL) return FloatClass.SUBNORMAL;\n return FloatClass.NORMAL;\n}\n\n\n/**\n * Examine if sum of divisors equals the number itself.\n * @param x a number\n * @returns sum of divisors(x) excluding x = x?\n * @example\n * ```ts\n * xnumber.isPerfect(6);\n * // → true (1+2+3=6)\n *\n * xnumber.isPerfect(28);\n * // → true (1+2+4+7+14=28)\n *\n * xnumber.isPerfect(12);\n * // → false (1+2+3+4+6=16)\n *\n * xnumber.isPerfect(1);\n * // → false (no proper divisors)\n * ```\n */\nexport function isPerfect(x: number): boolean {\n return aliquotSum(x) === x;\n}\n\n\n// TODO: isAlmostPerfect()?\n// TODO: isSemiPerfect()?\n// TODO: isQuasiPerfect()?\n// TODO: isWeird()?\n\n\n/**\n * Examine if sum of divisors exceeds the number itself.\n * @param x a number\n * @returns sum of divisors(x) excluding x > x?\n * @example\n * ```ts\n * xnumber.isAbundant(8);\n * // → false (1+2+4=7 < 8)\n *\n * xnumber.isAbundant(15);\n * // → false (1+3+5=9 < 15)\n *\n * xnumber.isAbundant(12);\n * // → true (1+2+3+4+6=16 > 12)\n *\n * xnumber.isAbundant(6);\n * // → false (1+2+3=6 = 6)\n * ```\n */\nexport function isAbundant(x: number): boolean {\n return aliquotSum(x) > x;\n}\nexport {isAbundant as isExcessive};\n\n\n// TODO: isPrimitiveAbundant()?\n// TODO: isSuperAbundant()?\n\n\n/**\n * Obtain the sum of divisors exceeding the number itself.\n * @param x a number\n * @returns sum of divisors(x) excluding x - x\n * @example\n * ```ts\n * xnumber.abundance(12);\n * // → 4 (1+2+3+4+6=16; 16-12=4)\n *\n * xnumber.abundance(15);\n * // → -6 (1+3+5=9; 9-15=-6)\n * ```\n */\nexport function abundance(x: number): number {\n return aliquotSum(x) - x;\n}\n\n\n/**\n * Obtain the ratio of sum of divisors to the number itself.\n * @param x a number\n * @returns (sum of divisors(x)) / x\n * @example\n * ```ts\n * xnumber.abundancyIndex(12);\n * // → 2.3333... (1+2+3+4+6+12=28; 28/12=7/3)\n *\n * xnumber.abundancyIndex(15);\n * // → 1.6 (1+3+5+15=24; 24/15=8/5)\n * ```\n */\nexport function abundancyIndex(x: number): number {\n return (aliquotSum(x) + x) / x;\n}\n\n\n// TODO: areAmicable()?\n// TODO: areFriendly()?\n\n\n/**\n * Count the number of significant digits in a number.\n * @param x a number\n * @returns |m - '.'| | x = m × 10ᵉ; m = mantissa, e = exponent\n * @example\n * ```ts\n * xnumber.significantDigits(0.0034);\n * // → 2\n *\n * xnumber.significantDigits(120.5e50);\n * // → 4\n *\n * xnumber.significantDigits(120.5e-50);\n * // → 4\n * ```\n */\nexport function significantDigits(x: number): number {\n const a = x.toExponential();\n return a.replace(/e[\\+\\-0-9]*$/, \"\").replace(/^0\\.?0*|\\./, \"\").length;\n}\n// - https://stackoverflow.com/questions/22884720/what-is-the-fastest-way-to-count-the-number-of-significant-digits-of-a-number\n//#endregion\n\n\n\n\n//#region COMPARE\n/**\n * Compare two numbers.\n * @param x a number\n * @param y another number\n * @returns x<y: -ve, x=y: 0, x>y: +ve\n * @example\n * ```ts\n * xnumber.compare(10, 12);\n * // → -2 (-ve)\n *\n * xnumber.compare(12, 12);\n * // → 0\n *\n * xnumber.compare(17, 12);\n * // → 5 (+ve)\n * ```\n */\nexport function compare(x: number, y: number): number {\n return x - y;\n}\n\n\n/**\n * Check if two numbers are unordered (NaN involved).\n * @param x a number\n * @param y another number\n * @returns x=NaN or y=NaN?\n * @example\n * ```ts\n * xnumber.isUnordered(10, NaN);\n * // → true\n *\n * xnumber.isUnordered(NaN, 12);\n * // → true\n *\n * xnumber.isUnordered(10, 12);\n * // → false\n *\n * xnumber.isUnordered(NaN, NaN);\n * // → true\n * ```\n */\nexport function isUnordered(x: number, y: number): boolean {\n return Number.isNaN(x) || Number.isNaN(y);\n}\n//#endregion\n\n\n\n\n//#region SIGN\n/**\n * Copy the sign of a number to another number.\n * @param mag number whose magnitude is to be copied\n * @param sgn sign of the number to copy\n * @returns `|mag|` with sign of `sgn`\n * @example\n * ```ts\n * xnumber.copySign(3.14, -1);\n * // → -3.14\n *\n * xnumber.copySign(-3.14, 1);\n * // → 3.14\n *\n * xnumber.copySign(-6.28, -1);\n * // → -6.28\n */\nexport function copySign(mag: number, sgn: number): number {\n return Math.sign(sgn) === Math.sign(mag) ? mag : -mag;\n}\n//#endregion\n\n\n\n\n//#region ROUND\n/**\n * Round down a number to specific precision.\n * @param x a number\n * @param pre to precision [1]\n * @example\n * ```ts\n * xnumber.floor(9.161, 1);\n * // → 9\n *\n * xnumber.floor(9.161, 0.01);\n * // → 9.16\n *\n * xnumber.floor(9.1617, 0.05);\n * // → 9.15\n * ```\n */\nexport function floor(x: number, pre: number = 1): number {\n return Math.floor(x/pre) * pre;\n}\n\n\n/**\n * Round up a number to specific precision.\n * @param x a number\n * @param pre to precision [1]\n * @example\n * ```ts\n * xnumber.ceil(9.121, 1);\n * // → 10\n *\n * xnumber.ceil(9.121, 0.01);\n * // → 9.13\n *\n * xnumber.ceil(9.1217, 0.05);\n * // → 9.15\n * ```\n */\nexport function ceil(x: number, pre: number = 1): number {\n return Math.ceil(x/pre) * pre;\n}\n\n\n/**\n * Round a number to specific precision.\n * @param x a number\n * @param pre to precision [1]\n * @example\n * ```ts\n * xnumber.round(9.135, 1);\n * // → 9\n *\n * xnumber.round(9.135, 1e-2);\n * // → 9.14\n *\n * xnumber.round(9.1357, 0.05);\n * // → 9.15\n *\n * 0.1 + 0.2\n * // → 0.30000000000000004 (why?)\n *\n * xnumber.round(0.1 + 0.2, 1e-12);\n * // → 0.3 (nice!)\n * ```\n */\nexport function round(x: number, pre: number = 1): number {\n return Math.round(x/pre) * pre;\n}\n\n\n/**\n * Perform floor-divison of two numbers.\n * @param x divisor\n * @param y dividend\n * @returns ⌊x/y⌋\n * @example\n * ```ts\n * xnumber.floorDiv(15, 4);\n * // → 3\n *\n * xnumber.floorDiv(2, 2);\n * // → 1\n *\n * xnumber.floorDiv(-15, 4);\n * // → -4\n * ```\n */\nexport function floorDiv(x: number, y: number): number {\n return Math.floor(x/y);\n}\n\n\n/**\n * Perform ceiling-divison of two numbers.\n * @param x divisor\n * @param y dividend\n * @returns ⌈x/y⌉\n * @example\n * ```ts\n * xnumber.ceilDiv(15, 4);\n * // → 4\n *\n * xnumber.ceilDiv(2, 2);\n * // → 1\n *\n * xnumber.ceilDiv(-15, 4);\n * // → -3\n * ```\n */\nexport function ceilDiv(x: number, y: number): number {\n return Math.ceil(x/y);\n}\n\n\n/**\n * Perform rounded-divison of two numbers.\n * @param x divisor\n * @param y dividend\n * @returns [x/y]\n * @example\n * ```ts\n * xnumber.roundDiv(15, 4);\n * // → 4\n *\n * xnumber.roundDiv(2, 2);\n * // → 1\n *\n * xnumber.roundDiv(-15, 4);\n * // → -4\n * ```\n */\nexport function roundDiv(x: number, y: number): number {\n return Math.round(x/y);\n}\n//#endregion\n\n\n\n\n//#region MODULO\n/**\n * Find the remainder of x/y with sign of x (truncated division).\n * @param x dividend\n * @param y divisor\n * @returns trunc(x % y)\n * @example\n * ```ts\n * xnumber.rem(1, 10);\n * // → 1\n *\n * xnumber.rem(-1, 10);\n * // → -1\n *\n * xnumber.rem(1, -10);\n * // → 1\n * ```\n */\nexport function rem(x: number, y: number): number {\n return x % y;\n}\n// - https://en.wikipedia.org/wiki/Modulo_operation\n\n\n/**\n * Find the remainder of x/y with sign of y (floored division).\n * @param x dividend\n * @param y divisor\n * @returns floor(x % y)\n * @example\n * ```ts\n * xnumber.mod(1, 10);\n * // → 1\n *\n * xnumber.mod(-1, 10);\n * // → 9\n *\n * xnumber.mod(1, -10);\n * // → -9\n * ```\n */\nexport function mod(x: number, y: number): number {\n return x - y * Math.floor(x/y);\n}\n// - https://en.wikipedia.org/wiki/Modulo_operation\n\n\n/**\n * Find the remainder of x/y with +ve sign (euclidean division).\n * @param x dividend\n * @param y divisor\n * @returns n>0: floor(x % y), n<0: ceil(x % y)\n * @example\n * ```ts\n * xnumber.modp(1, 10);\n * // → 1\n *\n * xnumber.modp(-1, 10);\n * // → 9\n *\n * xnumber.modp(1, -10);\n * // → 1\n * ```\n */\nexport function modp(x: number, y: number): number {\n return x - Math.abs(y) * Math.floor(x / Math.abs(y));\n}\n// - https://en.wikipedia.org/wiki/Modulo_operation\n//#endregion\n\n\n\n\n//#region RANGE CONTROL\n/**\n * Constrain a number within a minimum and a maximum value.\n * @param x a number\n * @param min minimum value\n * @param max maximum value\n * @returns x<min: min, x>max: max, x\n * @example\n * ```ts\n * xnumber.constrain(20, 0, 50);\n * // → 20\n *\n * xnumber.constrain(-10, 0, 100);\n * // → 0\n *\n * xnumber.constrain(120, 0, 100);\n * // → 100\n * ```\n */\nexport function constrain(x: number, min: number, max: number): number {\n return Math.min(Math.max(x, min), max);\n}\nexport {constrain as clamp};\n// - https://processing.org/reference/constrain_.html\n// - https://www.npmjs.com/package/clamp\n// - https://en.cppreference.com/w/cpp/algorithm/clamp\n// - https://dlang.org/library/std/algorithm/comparison/clamp.html\n// - https://www.rdocumentation.org/packages/raster/versions/3.0-12/topics/clamp\n// - https://docs.microsoft.com/en-us/dotnet/api/system.math.clamp?view=netcore-3.1\n// - https://docs.microsoft.com/en-us/windows/win32/direct3dhlsl/dx-graphics-hlsl-clamp\n// - https://www.khronos.org/registry/OpenGL-Refpages/gl4/html/clamp.xhtml\n// - https://docs.unity3d.com/ScriptReference/Mathf.Clamp.html\n// - https://en.wikipedia.org/wiki/Clamping_(graphics)\n\n\n/**\n * Normalize a number from its current range into a value between 0 and 1.\n * @param x a number\n * @param r lower bound of current range\n * @param R upper bound of current range\n * @returns ∈ [0, 1]\n * @example\n * ```ts\n * xnumber.normalize(20, 0, 50);\n * // → 0.4\n *\n * xnumber.normalize(-10, 0, 100);\n * // → -0.1\n * ```\n */\nexport function normalize(x: number, r: number, R: number): number {\n return (x - r) / (R - r);\n}\nexport {normalize as norm};\n// - https://processing.org/reference/norm_.html\n\n\n/**\n * Re-map a number from one range to another.\n * @param x a number\n * @param r lower bound of current range\n * @param R upper bound of current range\n * @param t lower bound of target range\n * @param T upper bound of target range\n * @returns ∈ [ymin, ymax]\n * @example\n * ```ts\n * xnumber.remap(25, 0, 100, 0, 1366);\n * // → 341.5\n *\n * xnumber.remap(110, 0, 100, -20, -10);\n * // → -9\n * ```\n */\nexport function remap(x: number, r: number, R: number, t: number, T: number): number {\n return t + ((x - r) / (R - r)) * (T - t);\n}\nexport {remap as map};\n// - https://processing.org/reference/map_.html\n\n\n/**\n * Linearly interpolate a number between two numbers.\n * @param x start number\n * @param y stop number\n * @param t interpolant ∈ [0, 1]\n * @returns ∈ [x, y]\n * @example\n * ```ts\n * xnumber.lerp(80, 320, 0.8);\n * // → 272\n *\n * xnumber.lerp(80, 320, 0.20);\n * // → 128\n *\n * xnumber.lerp(80, 320, 0.32);\n * // → 156.8\n * ```\n */\nexport function lerp(x: number, y: number, t: number): number {\n return x + t * (y - x);\n}\n// - https://processing.org/reference/lerp_.html\n// - https://docs.unity3d.com/ScriptReference/Vector3.Lerp.html\n//#endregion\n\n\n\n\n//#region FRACTIONAL\n/**\n * Make a number purely fractional, by shifting the decimal point.\n * @param x a number\n * @param n maximum number of digits to shift (-1: all) [20]\n * @returns fractional number\n * @example\n * ```ts\n * xnumber.fractionize(123);\n * // → 0.123\n *\n * xnumber.fractionize(-9876, 3);\n * // → -0.988\n *\n * xnumber.fractionize(0.001234, 3);\n * // → 0.001\n * ```\n */\nexport function fractionize(x: number, n: number = 20): number {\n const xp = Math.abs(x);\n const xdig = xp < 1? 0 : 1 + Math.floor(Math.log10(xp));\n if (n < 0) return x * Math.pow(10, -xdig);\n return Math.round(x * Math.pow(10, n - xdig)) * Math.pow(10, -n);\n}\n\n\n/**\n * Make a number purely integer, by shifting the decimal point.\n * @param x a number\n * @param n maximum number of digits to shift (-1: all) [20]\n * @returns integer number\n * @example\n * ```ts\n * xnumber.defractionize(0.123);\n * // → 123\n *\n * xnumber.defractionize(-0.988, 2);\n * // → -99\n *\n * xnumber.defractionize(12.345, 2);\n * // → 1235\n * ```\n */\nexport function defractionize(x: number, n: number = 20): number {\n let xp = Math.abs(x), i = 0;\n for (; n<0 || i<n;) {\n xp *= 10; ++i;\n if (xp % 1 === 0) break;\n }\n return Math.round(x * Math.pow(10, i));\n}\n//#endregion\n\n\n\n\n//#region ARITHMETIC\n/**\n * Check if a number is a power-of-n.\n * @param x a number\n * @param n base\n * @returns nⁱ = x? | i = +ve integer\n * @example\n * ```ts\n * xnumber.isPow(32, 2);\n * // → true\n *\n * xnumber.isPow(32, 4);\n * // → false\n *\n * xnumber.isPow(64, 4);\n * // → true\n * ```\n */\nexport function isPow(x: number, n: number): boolean {\n if (n === 0) return x === 0;\n const p = log(Math.abs(x), Math.abs(n));\n if (p !== Math.floor(p)) return false;\n return x < 0? (n < 0 && (p & 1) === 1) : (n > 0 || (p & 1) === 0);\n}\n\n\n/**\n * Find largest power-of-n less than or equal to given number.\n * @param x a number\n * @param n base\n * @returns nⁱ | nⁱ ≤ x and nⁱ > x/n\n * @example\n * ```ts\n * xnumber.prevPow(32, 2);\n * // → 32\n *\n * xnumber.prevPow(35, 2);\n * // → 32\n *\n * xnumber.prevPow(35, 3);\n * // → 27\n * ```\n */\nexport function prevPow(x: number, n: number): number {\n if (x <= 1) return 0;\n const p = Math.floor(Math.log(x) / Math.log(n));\n return Math.pow(n, p);\n}\n\n\n/**\n * Find smallest power-of-n greater than or equal to given number.\n * @param x a number\n * @param n base\n * @returns nⁱ | nⁱ ≥ x and nⁱ < n*x\n * @example\n * ```ts\n * xnumber.nextPow(32, 2);\n * // → 32\n *\n * xnumber.nextPow(29, 2);\n * // → 32\n *\n * xnumber.nextPow(29, 3);\n * // → 81\n * ```\n */\nexport function nextPow(x: number, n: number): number {\n if (x <= 0) return 1;\n const p = Math.ceil(Math.log(x) / Math.log(n));\n return Math.pow(n, p);\n}\n\n\n/**\n * Find the nth root of a number (ⁿ√).\n * @param x a number\n * @param n root\n * @returns ⁿ√x\n * @example\n * ```ts\n * xnumber.root(25, 2);\n * // → 5\n *\n * xnumber.root(-8, 3);\n * // → -2\n * ```\n */\nexport function root(x: number, n: number): number {\n if ((n & 1) === 0) return Math.pow(x, 1/n);\n return Math.sign(x) * Math.pow(Math.abs(x), 1/n);\n}\n// - https://github.com/alawatthe/MathLib/blob/master/src/Functn/functions/root.ts\n\n\n/**\n * Find the logarithm of a number with a given base.\n * @param x a number\n * @param b logarithm base [e]\n * @returns log_b (x)\n * @example\n * ```ts\n * xnumber.log(Math.E);\n * // → 1\n *\n * xnumber.log(10);\n * // → 2.302585092994046\n *\n * xnumber.log(243, 3);\n * // → 5\n *\n * xnumber.log(64, 2);\n * // → 6\n * ```\n */\nexport function log(x: number, b: number=Math.E): number {\n return Math.log(x) / Math.log(b);\n}\n// - https://en.wikipedia.org/wiki/Logarithm\n//#endregion\n\n\n\n\n//#region DIVISORS\n/**\n * List all divisors of a number, except itself.\n * @param x a number\n * @returns proper divisors (factors)\n * @example\n * ```ts\n * xnumber.properDivisors(6);\n * // → [1, 2, 3]\n *\n * xnumber.properDivisors(1);\n * // → []\n *\n * xnumber.properDivisors(0);\n * // → []\n *\n * xnumber.properDivisors(-24);\n * // → [1, 2, 3, 4, 6, 8, 12]\n * ```\n */\nexport function properDivisors(x: number): number[] {\n const a = []; x = Math.abs(x);\n for (let i=1; i<x; i++)\n if (x % i === 0) a.push(i);\n return a;\n}\nexport {properDivisors as aliquotParts};\n// - https://mathworld.wolfram.com/ProperDivisor.html\n// - https://en.wikipedia.org/wiki/Divisor#Further_notions_and_facts\n\n\n/**\n * Sum all proper divisors of a number.\n * @param x a number\n * @returns Σdᵢ | dᵢ is a divisor of x and ≠x\n * @example\n * ```ts\n * xnumber.aliquotSum(6);\n * // → 6 (1+2+3)\n *\n * xnumber.aliquotSum(1);\n * // → 0\n *\n * xnumber.aliquotSum(0);\n * // → 0\n *\n * xnumber.aliquotSum(-24);\n * // → 36 (1+2+3+4+6+8+12)\n * ```\n */\nexport function aliquotSum(x: number): number {\n let a = 0; x = Math.abs(x);\n for (let i=0; i<x; i++)\n if (x % i === 0) a += i;\n return a;\n}\n\n\n/**\n * Find the least prime number which divides a number.\n * @param x a number\n * @returns least prime factor\n * @example\n * ```ts\n * xnumber.minPrimeFactor(1);\n * // → 0\n *\n * xnumber.minPrimeFactor(3);\n * // → 3\n *\n * xnumber.minPrimeFactor(21);\n * // → 3\n *\n * xnumber.minPrimeFactor(55);\n * // → 5\n *\n * xnumber.minPrimeFactor(53);\n * // → 53\n * ```\n */\nexport function minPrimeFactor(x: number): number {\n x = Math.abs(x);\n // 1. LPF of 2, 3 is the number itself.\n if (x <= 1) return 0;\n if (x <= 3) return x;\n // 2. LPF for multiples of 2, 3.\n if (x % 2 === 0) return 2;\n if (x % 3 === 0) return 3;\n // 3. LPF can be 6k-1 or 6k+1.\n for (let i=6, I=Math.sqrt(x)+1; i<=I; i+=6) {\n if (x % (i-1) === 0) return i-1;\n if (x % (i+1) === 0) return i+1;\n }\n return x;\n}\nexport {minPrimeFactor as leastPrimeFactor};\n// - https://mathworld.wolfram.com/LeastPrimeFactor.html\n\n\n/**\n * Find the greatest prime number which divides a number.\n * @param x a number\n * @returns greatest prime factor\n * @example\n * ```ts\n * xnumber.maxPrimeFactor(1);\n * // → 0\n *\n * xnumber.maxPrimeFactor(3);\n * // → 3\n *\n * xnumber.maxPrimeFactor(21);\n * // → 7\n *\n * xnumber.maxPrimeFactor(55);\n * // → 11\n *\n * xnumber.maxPrimeFactor(53);\n * // → 53\n * ```\n */\nexport function maxPrimeFactor(x: number): number {\n let a = 0; x = Math.abs(x);\n // 1. GPF of 2, 3 is the number itself.\n if (x <= 1) return 0;\n if (x <= 3) return x;\n // 2. Remove factors 2, 3.\n for (; x % 2 === 0; a=2)\n x /= 2;\n for (; x % 3 === 0; a=3)\n x /= 3;\n // 3. Remove factors 6k-1, 6k+1.\n for (let i=6, I=Math.sqrt(x)+1; x>1 && i<=I; i+=6) {\n for (; x % (i-1) === 0; a=i-1)\n x /= i-1;\n for (; x % (i+1) === 0; a=i+1)\n x /= i+1;\n }\n if (x <= 1) return a;\n return x;\n}\nexport {maxPrimeFactor as greatestPrimeFactor};\n// - https://mathworld.wolfram.com/GreatestPrimeFactor.html\n// - https://www.geeksforgeeks.org/find-largest-prime-factor-number/\n\n\n/**\n * Find the prime factors of a number.\n * @param x a number\n * @returns [f₀, f₁, ...] | fᵢ divides x and is prime\n * @example\n * ```ts\n * xnumber.primeFactors(1);\n * // → []\n *\n * xnumber.primeFactors(3);\n * // → [3]\n *\n * xnumber.primeFactors(21);\n * // → [3, 7]\n *\n * xnumber.primeFactors(55);\n * // → [5, 11]\n *\n * xnumber.primeFactors(53);\n * // → [53]\n * ```\n */\nexport function primeFactors(x: number): number[] {\n const a: number[] = []; x = Math.abs(x);\n if (x <= 1) return [];\n if (x <= 3) return [x];\n // 2. Try factors 2, 3.\n x = pushPrimeFactorTo$(a, x, 2);\n x = pushPrimeFactorTo$(a, x, 3);\n // 3. Try factors 6k-1, 6k+1.\n for (let i=6, I=Math.sqrt(x)+1; x>1 && i<=I; i+=6) {\n x = pushPrimeFactorTo$(a, x, i-1);\n x = pushPrimeFactorTo$(a, x, i+1);\n }\n if (x > 1) a.push(x);\n return a;\n}\n\nfunction pushPrimeFactorTo$(a: number[], x: number, f: number): number {\n if (x % f !== 0) return x;\n do {\n x /= f;\n } while (x % f === 0);\n a.push(f);\n return x;\n}\n// - https://www.geeksforgeeks.org/prime-factors-big-number/\n// - https://mathworld.wolfram.com/PrimeFactor.html\n\n\n/**\n * Find the prime factors and respective exponents of a number.\n * @param x a number\n * @returns [[f₀, e₀], [f₁, e₁], ...] | fᵢ is a prime factor of x and eᵢ is its exponent\n * @example\n * ```ts\n * xnumber.primeExponentials(1);\n * // → []\n *\n * xnumber.primeExponentials(9);\n * // → [[3, 2]]\n *\n * xnumber.primeExponentials(63);\n * // → [[3, 2], [7, 1]]\n *\n * xnumber.primeExponentials(605);\n * // → [[5, 1], [11, 2]]\n *\n * xnumber.primeExponentials(53);\n * // → [[53, 1]]\n * ```\n */\nexport function primeExponentials(x: number): [number, number][] {\n const a: [number, number][] = []; x = Math.abs(x);\n if (x <= 1) return [];\n if (x <= 3) return [[x, 1]];\n // 2. Try factors 2, 3.\n x = pushPrimeExponentialTo$(a, x, 2);\n x = pushPrimeExponentialTo$(a, x, 3);\n // 3. Try factors 6k-1, 6k+1.\n for (let i=6, I=Math.sqrt(x)+1; x>1 && i<=I; i+=6) {\n x = pushPrimeExponentialTo$(a, x, i-1);\n x = pushPrimeExponentialTo$(a, x, i+1);\n }\n if (x > 1) a.push([x, 1]);\n return a;\n}\n\nfunction pushPrimeExponentialTo$(a: [number, number][], x: number, f: number): number {\n if (x % f !== 0) return x;\n let e = 0;\n do {\n x /= f; ++e;\n } while (x % f === 0);\n a.push([f, e]);\n return x;\n}\n// - https://www.geeksforgeeks.org/prime-factors-big-number/\n// - https://reference.wolfram.com/language/ref/FactorInteger.html\n// - https://mathworld.wolfram.com/PrimeFactorization.html\n// - https://mathworld.wolfram.com/PrimeFactor.html\n\n\n/**\n * Examine if number is prime.\n * @param x a number\n * @returns is divisible by 1 and itself only?\n * @example\n * ```ts\n * xnumber.isPrime(7);\n * // → true\n *\n * xnumber.isPrime(53);\n * // → true\n *\n * xnumber.isPrime(4);\n * // → false\n *\n * xnumber.isPrime(1);\n * // → false\n *\n * xnumber.isPrime(0);\n * // → false\n * ```\n */\nexport function isPrime(x: number): boolean {\n return x !== 0 && minPrimeFactor(x) === Math.abs(x);\n}\n\n\n/**\n * Find the greatest common divisor of numbers.\n * @param xs a list of numbers\n * @returns gcd(x₁, x₂, ...)\n * @example\n * ```ts\n * xnumber.gcd(6, 15);\n * // → 3\n *\n * xnumber.gcd(6, 15, 21);\n * // → 3\n *\n * xnumber.gcd(6, 15, 20);\n * // → 1\n * ```\n */\nexport function gcd(...xs: number[]): number {\n let a = xs[0] || 1;\n for (let i=1, I=xs.length; i<I; i++)\n a = gcdPair(a, xs[i]);\n return a;\n}\nexport {gcd as hcf};\n\n// Find the greatest common divisor of a pair of numbers.\nfunction gcdPair(x: number, y: number): number {\n while (y !== 0) {\n const t = y;\n y = x % y;\n x = t;\n }\n return x;\n}\n// - https://lemire.me/blog/2013/12/26/fastest-way-to-compute-the-greatest-common-divisor/\n// - https://en.wikipedia.org/wiki/Euclidean_algorithm\n\n\n/**\n * Find the least common multiple of numbers.\n * @param xs a list of numbers\n * @returns lcm(x₁, x₂, ...)\n * @example\n * ```ts\n * xnumber.lcm(2, 3);\n * // → 6\n *\n * xnumber.lcm(2, 3, 4);\n * // → 12\n *\n * xnumber.lcm(2, 3, 4, 5);\n * // → 60\n * ```\n */\nexport function lcm(...xs: number[]): number {\n let a = xs[0] || 1;\n for (let i=1, I=xs.length; i<I; i++)\n a = a*xs[i] / gcdPair(a, xs[i]);\n return a;\n}\n// - https://en.wikipedia.org/wiki/Least_common_multiple\n//#endregion\n\n\n\n\n//#region ARRANGEMENTS\n/**\n * Find the factorial of a number.\n * @param n a number\n * @param k denominator factorial [0]\n * @returns P(n, k); k=0: n!, k>0: n!/k!\n * @example\n * ```ts\n * xnumber.factorial(5);\n * // → 120\n *\n * xnumber.factorial(6);\n * // → 720\n *\n * xnumber.factorial(7);\n * // → 5040\n * ```\n */\nexport function factorial(n: number, k: number = 0): number {\n if (n < 0) return 0;\n let a = 1;\n for (let i=k+1; i<=n; i++)\n a *= i;\n return a;\n}\n// - https://github.com/alawatthe/MathLib/blob/master/src/Functn/functions/factorial.ts\n// - https://en.wikipedia.org/wiki/Permutation\n\n\n/**\n * Find the number of ways to choose k elements from a set of n elements.\n * @param n elements in source set\n * @param k elements in choose set\n * @returns C(n, k)\n * @example\n * ```ts\n * xnumber.binomial(4, 1);\n * // → 4\n *\n * xnumber.binomial(4, 2);\n * // → 6\n *\n * xnumber.binomial(4, 3);\n * // → 4\n * ```\n */\nexport function binomial(n: number, k: number): number {\n // 1. Generalization to negative integers\n if (k < 0 || k > Math.abs(n)) return 0;\n if (n < 0) return Math.pow(-1, k) * binomial(-n, k);\n // 2. Take advantage of symmetry\n k = k > n - k? n - k : k;\n let a = 1;\n for (let i=1; i<=k; i++, n--)\n a *= n/i;\n return a;\n}\n// - https://github.com/alawatthe/MathLib/blob/master/src/Functn/functions/binomial.ts\n// - https://en.wikipedia.org/wiki/Binomial_coefficient\n\n\n/**\n * Find the number of ways to put n objects in m bins (n=sum(kᵢ)).\n * @param ks objects per bin (kᵢ)\n * @returns n!/(k₁!k₂!...) | n=sum(kᵢ)\n * @example\n * ```ts\n * xnumber.multinomial(1, 2);\n * // → 3\n *\n * xnumber.multinomial(1, 2, 3);\n * // → 60\n *\n * xnumber.multinomial(1, 2, 3, 4);\n * // → 12600\n * ```\n */\nexport function multinomial(...ks: number[]): number {\n let n = sum(...ks), a = 1;\n for (let i=0, j=0, I=ks.length; i<I;) {\n if (j <= 0) j = ks[i++];\n else a *= n-- / j--;\n }\n return a;\n}\n// - https://en.wikipedia.org/wiki/Multinomial_distribution\n//#endregion\n\n\n\n\n//#region GEOMETRY\n/**\n * Convert radians to degrees.\n * @param x radians\n * @returns 2π → 360\n * @example\n * ```ts\n * xnumber.degrees(3);\n * // → 171.88733853924697\n *\n * xnumber.degrees(1);\n * // → 57.29577951308232\n * ```\n */\nexport function degrees(x: number): number {\n return x * (180 / Math.PI);\n}\n// - https://processing.org/reference/degrees_.html\n\n\n/**\n * Convert degrees to radians.\n * @param x degrees\n * @returns 360 → 2π\n * @example\n * ```ts\n * xnumber.radians(180);\n * // → 3.141592653589793\n *\n * xnumber.radians(60);\n * // → 1.0471975511965976\n * ```\n */\nexport function radians(x: number): number {\n return x * (Math.PI / 180);\n}\n// - https://processing.org/reference/radians_.html\n//#endregion\n\n\n\n\n//#region STATISTICS\n/**\n * Find the sum of numbers (Σ).\n * @param xs a list of numbers\n * @returns Σxᵢ\n * @example\n * ```ts\n * xnumber.sum(1, 2);\n * // → 3\n *\n * xnumber.sum(1, 2, 3);\n * // → 6\n *\n * xnumber.sum(1, 2, 3, 4);\n * // → 10\n * ```\n */\nexport function sum(...xs: number[]): number {\n let a = 0;\n for (const x of xs)\n a += x;\n return a;\n}\n\n\n/**\n * Find the product of numbers (∏).\n * @param xs a list of numbers\n * @returns ∏xᵢ\n * @example\n * ```ts\n * xnumber.product(1, 2);\n * // → 2\n *\n * xnumber.product(1, 2, 3);\n * // → 6\n *\n * xnumber.product(1, 2, 3, 4);\n * // → 24\n * ```\n */\nexport function product(...xs: number[]): number {\n let a = 1;\n for (const x of xs)\n a *= x;\n return a;\n}\n\n\n/**\n * Find the value separating the higher and lower halves of numbers.\n * @param xs a list of numbers\n * @returns xₘ | sort(xs) = [..., xₘ, ...]\n * @example\n * ```ts\n * xnumber.median(1, 7);\n * // → 4\n *\n * xnumber.median(1, 7, 8);\n * // → 7\n *\n * xnumber.median(1, 7, 8, 10);\n * // → 7.5\n * ```\n */\nexport function median(...xs: number[]): number {\n if (xs.length === 0) return 0;\n xs.sort((a, b) => a - b);\n const i = xs.length >> 1;\n if ((xs.length & 1) === 1) return xs[i];\n return (xs[i - 1] + xs[i]) / 2;\n}\n// - https://stackoverflow.com/questions/45309447/calculating-median-javascript\n// - https://en.wikipedia.org/wiki/Median\n\n\n/**\n * Find the values that appear most often.\n * @param xs a list of numbers\n * @returns [xₘ₁, xₘ₂, ...] | count(xₘᵢ) ≥ count(xᵢ) ∀ xᵢ ∈ xs\n * @example\n * ```ts\n * xnumber.modes(1, 2);\n * // → [1, 2]\n *\n * xnumber.modes(1, 2, 2);\n * // → [2]\n *\n * xnumber.modes(1, 2, 2, 3, 3);\n * // → [2, 3]\n * ```\n */\nexport function modes(...xs: number[]): number[] {\n xs.sort((a, b) => a - b);\n const r = maxRepeat(xs);\n return getRepeats(xs, r);\n}\n// - https://en.wikipedia.org/wiki/Mode_(statistics)\n\n// Get the maximum number of times any number has repeated in a sorted array.\nfunction maxRepeat(xs: number[]): number {\n let count = Math.min(xs.length, 1), max = count;\n for (let i=1, I=xs.length; i<I; i++) {\n if (xs[i-1] === xs[i]) count++;\n else { max = Math.max(max, count); count = 1; }\n }\n return Math.max(max, count);\n}\n\n// Get the numbers which have been repeated atleast given number of times.\nfunction getRepeats(xs: number[], r: number): number[] {\n const a: number[] = []; r--;\n for (let i=0, I=xs.length-r; i<I; i++)\n if (xs[i] === xs[i+r]) a.push(xs[i+=r]);\n return a;\n}\n\n\n/**\n * Find the smallest and largest values.\n * @param xs a list of numbers\n * @returns [min(xs), max(xs)]\n * @example\n * ```ts\n * xnumber.range(1, 7);\n * // → 6\n *\n * xnumber.range(1, 7, 6);\n * // → 6\n *\n * xnumber.range(1, 7, 8, 6);\n * // → 7\n * ```\n */\nexport function range(...xs: number[]): [number, number] {\n return [Math.min(...xs), Math.max(...xs)];\n}\n// - https://en.wikipedia.org/wiki/Range_(statistics)\n\n\n/**\n * Find the mean of squared deviation of numbers from its mean.\n * @param xs a list of numbers\n * @returns σ² = E[(xs - µ)²] | µ = mean(xs)\n * @example\n * ```ts\n * xnumber.variance(1, 2);\n * // → 0.25\n *\n * xnumber.variance(1, 2, 3);\n * // → 0.6666666666666666\n *\n * xnumber.variance(1, 2, 3, 4);\n * // → 1.25\n * ```\n */\nexport function variance(...xs: number[]): number {\n if (xs.length === 0) return 0;\n const m = arithmeticMean(...xs); let a = 0;\n for (const x of xs)\n a += (x - m) ** 2;\n return a / xs.length;\n}\n// - https://en.wikipedia.org/wiki/Variance\n//#endregion\n\n\n\n\n\n//#region MEAN (STATISTICS)\n/**\n * Find the average of numbers.\n * @param xs a list of numbers\n * @returns Σxᵢ/n | n = size(xs)\n * @example\n * ```ts\n * xnumber.arithmethicMean(1, 2);\n * // → 1.5\n *\n * xnumber.arithmethicMean(1, 2, 3);\n * // → 2\n *\n * xnumber.arithmethicMean(1, 2, 3, 4);\n * // → 2.5\n * ```\n */\nexport function arithmeticMean(...xs: number[]): number {\n if (xs.length === 0) return 0;\n return sum(...xs) / xs.length;\n}\nexport {arithmeticMean as mean};\n\n\n/**\n * Find the geometric mean of numbers.\n * @param xs a list of numbers\n * @returns ⁿ√(∏xᵢ) | n = size(xs)\n * @example\n * ```ts\n * xnumber.geometricMean(1, 2);\n * // → 1.4142135623730951 (Math.sqrt(2))\n *\n * xnumber.geometricMean(1, 2, 3);\n * // → 1.8171205928321397 (Math.cbrt(6))\n *\n * xnumber.geometricMean(1, 2, 3, 4);\n * // → 2.2133638394006434 (Math.pow(24, 1/4))\n * ```\n */\nexport function geometricMean(...xs: number[]): number {\n const n = xs.length;\n return root(product(...xs), n);\n}\n\n\n/**\n * Find the harmonic mean of numbers.\n * @param xs a list of numbers\n * @returns n/Σ(1/xᵢ) | n = size(xs)\n * @example\n * ```ts\n * xnumber.harmonicMean(1, 2);\n * // → 1.3333333333333333 (4/3)\n *\n * xnumber.harmonicMean(1, 2, 3);\n * // → 1.6363636363636365 (18/11)\n *\n * xnumber.harmonicMean(1, 2, 3, 4);\n * // → 1.92 (48/25)\n * ```\n */\nexport function harmonicMean(...xs: number[]): number {\n const n = xs.length;\n const p = product(...xs); let q = 0;\n for (const x of xs)\n q += p/x;\n return n * p/q;\n}\n\n\n/**\n * Find the quadriatic mean of numbers.\n * @param xs a list of numbers\n * @returns √(Σxᵢ²)/n | n = size(xs)\n * @example\n * ```ts\n * xnumber.quadriaticMean(1, 2);\n * // → 1.5811388300841898 (Math.sqrt(5/2))\n *\n * xnumber.quadriaticMean(1, 2, 3);\n * // → 2.160246899469287 (Math.sqrt(14/3))\n *\n * xnumber.quadriaticMean(1, 2, 3, 4);\n * // → 2.7386127875258306 (Math.sqrt(30/4))\n * ```\n */\nexport function quadriaticMean(...xs: number[]): number {\n const n = xs.length; let a = 0;\n for (const x of xs)\n a += x*x;\n return Math.sqrt(a/n);\n}\nexport {quadriaticMean as rootMeanSquare};\n\n\n/**\n * Find the cubic mean of numbers.\n * @param xs a list of numbers\n * @returns ³√(Σxᵢ³)/n | n = size(xs)\n * @example\n * ```ts\n * xnumber.cubicMean(1, 2);\n * // → 1.6509636244473134 (Math.cbrt(9/2))\n *\n * xnumber.cubicMean(1, 2, 3);\n * // → 2.2894284851066637 (Math.cbrt(36/3))\n *\n * xnumber.cubicMean(1, 2, 3, 4);\n * // → 2.924017738212866 (Math.cbrt(100/4))\n * ```\n */\nexport function cubicMean(...xs: number[]): number {\n const n = xs.length; let a = 0;\n for (const x of xs)\n a += x**3;\n return Math.cbrt(a/n);\n}\n//#endregion\n\n\n\n\n//#region ROMAN NUMERALS\n/** List of symbols in the Roman numeral system. */\nconst ROMAN_SYMBOLS = ['I', 'IV', 'V', 'IX', 'X', 'XL', 'L', 'XC', 'C', 'CD', 'D', 'CM', 'M'];\n/** Respective values in the Roman numeral system. */\nconst ROMAN_VALUES = [1, 4, 5, 9, 10, 40, 50, 90, 100, 400, 500, 900, 1000];\n/** Maximum power-of-10 representable in Roman numerals. */\nconst ROMAN_MAX_POW10 = 3;\n\n\n/**\n * Convert roman numerals to number.\n * @param txt roman numerals\n * @returns eg. XCV -> 95, IV.V -> 4.5, IXe+II -> 900\n * @example\n * ```ts\n * xnumber.fromRomanNumerals('XCV');\n * // → 95\n *\n * xnumber.fromRomanNumerals('IV.V');\n * // → 4.5\n *\n * xnumber.fromRomanNumerals('IXe+II');\n * // → 900\n * ```\n */\nexport function fromRomanNumerals(txt: string): number {\n const m = /^\\s*(-?[\\sIVXLCDM]+)\\s*(?:\\.([\\sIVXLCDM]+))?(?:E[-+]([\\sIVXLCDM]+))?\\s*$/i.exec(txt) || [];\n const aint = fromRomanInteger(m[1]);\n const afrc = m[2]? fromRomanInteger(m[2]) : 0;\n const aexp = m[3]? fromRomanInteger(m[3]) : 0;\n return Math.sign(aint) * (Math.abs(aint) + fractionize(afrc)) * Math.pow(10, aexp);\n}\nexport {fromRomanNumerals as fromRoman};\n\n\nfunction fromRomanInteger(txt: string): number {\n let s = ROMAN_SYMBOLS.length - 1;\n const n = txt.search(/^\\s*-/) >= 0; let a = 0;\n txt = txt.replace(/\\W/g, '').toUpperCase();\n for (let i=0, I=txt.length; i<I; i += ROMAN_SYMBOLS[s].length) {\n while (s >= 0 && txt.substring(i, i + ROMAN_SYMBOLS[s].length) !== ROMAN_SYMBOLS[s]) --s;\n if (s < 0) break;\n a += ROMAN_VALUES[s];\n }\n return n? -a : a;\n}\n\n\n/**\n * Convert number to roman numerals.\n * @param x a number\n * @param exp use exponential/scientific notation [false]\n * @returns eg. 95 -> XCV, 4.5 -> IV.V, 900 -> IXe+II (scientific = true)\n * @example\n * ```ts\n * xnumber.toRomanNumerals(95);\n * // → 'XCV'\n *\n * xnumber.toRomanNumerals(4.5);\n * // → 'IV.V'\n *\n * xnumber.toRomanNumerals(900, true);\n * // → 'IXe+II'\n * ```\n */\nexport function toRomanNumerals(x: number, exp: boolean = false): string {\n const xp = Math.abs(x);\n // Let's get the exponent and mantissa.\n const xexp = Math.floor(Math.log10(xp));\n const dexp = exp || (xexp > ROMAN_MAX_POW10)? xexp : 0;\n const dman = xp * Math.pow(10, -dexp);\n const dfrc = defractionize(dman % 1, ROMAN_MAX_POW10);\n const dint = Math.sign(x) * Math.floor(dman);\n // Now, convert to roman numerals.\n const aman = toRomanInteger(dint) + (dfrc? '.' + toRomanInteger(dfrc) : '');\n const aexp = dexp !== 0? 'e' + (dexp > 0? '+' : '') + toRomanInteger(dexp) : '';\n return aman + aexp;\n}\nexport {toRomanNumerals as toRoman};\n\n\nexport function toRomanInteger(x: number): string {\n let a = x < 0? '-' : '';\n x = Math.abs(x);\n for (let s=ROMAN_SYMBOLS.length-1; s>=0; --s)\n while (x >= ROMAN_VALUES[s]) {\n x -= ROMAN_VALUES[s];\n a += ROMAN_SYMBOLS[s];\n }\n return a;\n}\n//#endregion\n\n\n// export {default as fromScientific} from './_fromScientific';\n// export {default as toScientific} from './_toScientific';\n", "import {IDENTITY, COMPARE} from \"@nodef/extra-function\";\nimport {mod} from \"@nodef/extra-math\";\n\n\n\n\n// #region TYPES\n// =============\n\n/** Entries is an array of index-value pairs, with unique indices. */\nexport type Entries<T> = [number, T][];\n/** IEntries is a list of index-value pairs, with unique indices. */\nexport type IEntries<T> = Iterable<[number, T]>;\n\n\n/** Lists is a pair of index array and value array, with unique indices. */\nexport type Lists<T> = [number[], T[]];\n/** ILists is a pair of index iterable list and value iterable list, with unique indices. */\nexport type ILists<T> = [Iterable<number>, Iterable<T>];\n\n\n/**\n * Handle reading of a single value.\n * @returns value\n */\nexport type ReadFunction<T> = () => T;\n\n\n/**\n * Handle combining of two values.\n * @param a a value\n * @param b another value\n * @returns combined value\n */\nexport type CombineFunction<T> = (a: T, b: T) => T;\n\n\n/**\n * Handle comparison of two values.\n * @param a a value\n * @param b another value\n * @returns a<b: -ve, a=b: 0, a>b: +ve\n */\nexport type CompareFunction<T> = (a: T, b: T) => number;\n\n\n/**\n * Handle processing of values in an array.\n * @param v value in array\n * @param i index of value in array\n * @param x array containing the value\n */\nexport type ProcessFunction<T> = (v: T, i: number, x: T[] | null) => void;\n\n\n/**\n * Handle selection of values in an array.\n * @param v value in array\n * @param i index of value in array\n * @param x array containing the value\n * @returns selected?\n */\nexport type TestFunction<T> = (v: T, i: number, x: T[] | null) => boolean;\n\n\n/**\n * Handle transformation of a value to another.\n * @param v value in array\n * @param i index of value in array\n * @param x array containing the value\n * @returns transformed value\n */\nexport type MapFunction<T, U> = (v: T, i: number, x: T[] | null) => U;\n\n\n/**\n * Handle reduction of multiple values into a single value.\n * @param acc accumulator (temporary result)\n * @param v value in array\n * @param i index of value in array\n * @param x array containing the value\n * @returns reduced value\n */\nexport type ReduceFunction<T, U> = (acc: U, v: T, i: number, x: T[] | null) => U;\n\n\n/**\n * Handle ending of a combined array.\n * @param dones iᵗʰ array done?\n * @returns combined array done?\n */\nexport type EndFunction = (dones: boolean[]) => boolean;\n\n\n/**\n * Handle swapping of two values in an array.\n * @param x an array (updated!)\n * @param i an index\n * @param j another index\n * @returns x | x[i] ⇔ x[j]\n */\nexport type SwapFunction<T> = (x: T[], i: number, j: number) => T[];\n// #endregion\n\n\n\n\n// #region METHODS\n// ===============\n\n// #region HELPERS\n// ---------------\n\n/** Convert an iterable to set. */\nfunction toSet<T, U=T>(x: T[], fm: MapFunction<T, U> | null=null): Set<T|U> {\n if (!fm) return new Set(x);\n const a = new Set<U>(); let i = -1;\n for (const v of x)\n a.add(fm(v, ++i, x));\n return a;\n}\n// #endregion\n\n\n\n\n// #region GENERATE\n// ----------------\n\n/**\n * Generate array from given number range.\n * @param v start number\n * @param V end number, excluding\n * @param dv step size [1]\n * @returns [v, v+dv, v+2dv, ...]\n */\nexport function fromRange(v: number, V: number, dv: number=1): number[] {\n const n = (V - v)/dv, a = [];\n for (let i=0; i<n; ++i, v+=dv)\n a.push(v);\n return a;\n}\n\n\n/**\n * Generate array from repeated function invocation.\n * @param fn function\n * @param n number of values\n * @returns [fn(), fn(), ...]\n */\nexport function fromInvocation<T>(fn: () => T, n: number): T[] {\n const a = [];\n for (let i=0; i<n; ++i)\n a.push(fn());\n return a;\n}\nexport {fromInvocation as fromCall};\n\n\n/**\n * Generate array from repeated function application.\n * @param fm map function (v, i)\n * @param v start value\n * @param n number of values\n * @returns [v, fm(v), fm(fm(v)), ...]\n */\nexport function fromApplication<T>(fm: MapFunction<T, T>, v: T, n: number): T[] {\n const a = [];\n if (n!==0) a.push(v);\n for (let i=1; i!==n; ++i)\n a.push(v = fm(v, i, null));\n return a;\n}\nexport {fromApplication as fromApply};\n\n\n/**\n * Convert an iterable to array.\n * @param x an iterable\n * @returns x as array\n */\nexport function fromIterable<T>(x: Iterable<T>): T[] {\n return [...x];\n}\nexport {fromIterable as from};\n\n\n/**\n * Convert an iterable to array!\n * @param x an iterable (updatable if array!)\n * @returns x as array\n */\nexport function fromIterable$<T>(x: Iterable<T>): T[] {\n return Array.isArray(x)? x : [...x];\n}\nexport {fromIterable$ as from$};\n// #endregion\n\n\n\n\n// #region CLONE\n// -------------\n\n/**\n * Shallow clone an array.\n * @param x an array\n * @returns shallow clone of x\n */\nexport function shallowClone<T>(x: T[]): T[] {\n return x.slice();\n}\nexport {shallowClone as clone};\n\n\n/**\n * Deep clone an array.\n * @param x an array\n * @returns deep clone of x\n */\nexport function deepClone<T>(x: T[]): T[] {\n return structuredClone(x);\n}\n// #endregion\n\n\n\n\n// #region ABOUT\n// -------------\n\n/**\n * Check if value is an array.\n * @param v a value\n * @returns v is an array?\n */\nexport function is(v: unknown): v is unknown[] {\n return Array.isArray(v);\n}\n\n\n/**\n * Obtain all indices.\n * @param x an array\n * @returns [0, 1, ..., |x|-1]\n */\nexport function keys<T>(x: T[]): number[] {\n return [...x.keys()];\n}\n\n\n/**\n * List all indices.\n * @param x an array\n * @returns 0, 1, ..., |x|-1\n */\nexport function ikeys<T>(x: T[]): IterableIterator<number> {\n return x.keys();\n}\n\n\n/**\n * Get all values.\n * @param x an array\n * @returns [v₀, v₁, ...] | vᵢ = x[i]\n */\nexport function values<T>(x: T[]): T[] {\n return x.slice();\n}\n\n\n/**\n * List all values.\n * @param x an array\n * @returns v₀, v₁, ... | vᵢ = x[i]\n */\nexport function ivalues<T>(x: T[]): IterableIterator<T> {\n return x.values();\n}\n\n\n/**\n * Obtain all index-value pairs.\n * @param x an array\n * @returns [[0, v₀], [1, v₁], ...] | vᵢ = x[i]\n */\nexport function entries<T>(x: T[]): Entries<T> {\n return [...x.entries()];\n}\n\n\n/**\n * List all index-value pairs.\n * @param x an array\n * @returns [0, v₀], [1, v₁], ... | vᵢ = x[i]\n */\nexport function ientries<T>(x: T[]): IEntries<T> {\n return x.entries();\n}\n// #endregion\n\n\n\n\n// #region INDEX\n// -------------\n\n/**\n * Get zero-based index for an element in array.\n * @param x an array\n * @param i ±index\n * @returns i' | x[i'] = x[i]; i' ∈ [0, |x|]\n */\nexport function index<T>(x: T[], i: number): number {\n const X = x.length;\n return i>=0? Math.min(i, X) : Math.max(X+i, 0);\n}\n\n\n/**\n * Get zero-based index range for part of array.\n * @param x an array\n * @param i begin ±index [0]\n * @param I end ±index (exclusive) [|x|]\n * @returns [i', I'] | i' ≤ I'; i', I' ∈ [0, |x|]\n */\nexport function indexRange<T>(x: T[], i: number=0, I: number=x.length): [number, number] {\n const X = x.length;\n i = i>=0? Math.min(i, X) : Math.max(X+i, 0);\n I = I>=0? Math.min(I, X) : Math.max(X+I, 0);\n return [i, Math.max(i, I)];\n}\n// #endregion\n\n\n\n\n// #region LENGTH\n// --------------\n\n/**\n * Check if an array is empty.\n * @param x an array\n * @returns |x| = 0?\n */\nexport function isEmpty<T>(x: T[]): boolean {\n return x.length===0;\n}\n\n\n/**\n * Find the length of an array.\n * @param x an array\n * @param i begin ±index [0]\n * @param I end ±index (exclusive) [X]\n * @returns |x[i..I]|\n */\nexport function length<T>(x: T[], i: number=0, I: number=x.length): number {\n [i, I] = indexRange(x, i, I);\n return I-i;\n}\nexport {length as size};\n\n\n/**\n * Resize an array to given length!\n * @param x an array\n * @param n new length\n * @param vd default value\n * @returns resized x\n */\nexport function resize$<T>(x: T[], n: number, vd: T): T[] {\n const X = x.length; x.length = n;\n if (n>X) x.fill(vd, X);\n return x;\n}\n\n\n/**\n * Remove all elements from an array!\n * @param x an array (updated!)\n * @returns cleared x\n */\nexport function clear$<T>(x: T[]): T[] {\n x.length = 0;\n return x;\n}\n// #endregion\n\n\n\n\n// #region GET/SET\n// ---------------\n\n/**\n * Get value at index.\n * @param x an array\n * @param i index\n * @returns x[i]\n */\nexport function get<T>(x: T[], i: number): T {\n return x[index(x, i)];\n}\nexport {get as at};\n\n\n// Get values at index range.\n// export {slice as getRange};\n\n\n/**\n * Get values at indices.\n * @param x an array\n * @param is indices\n * @returns [x[i₀], x[i₁], ...] | [i₀, i₁, ...] = is\n */\nexport function getAll<T>(x: T[], is: number[]): T[] {\n return is.map(i => get(x, i));\n}\n\n\n/**\n * Get value at path in a nested array.\n * @param x a nested array\n * @param p path\n * @returns x[i₀][i₁][...] | [i₀, i₁, ...] = p\n */\nexport function getPath(x: unknown[], p: number[]): unknown {\n let a: unknown | undefined = x;\n for (const i of p)\n a = is(a)? get(a, i) : undefined;\n return a;\n}\n\n\n/**\n * Check if nested array has a path.\n * @param x a nested array\n * @param p path\n * @returns x[i₀][i₁][...] exists? | [i₀, i₁, ...] = p\n */\nexport function hasPath(x: unknown[], p: number[]): boolean {\n let a: unknown | undefined = x;\n for (const i of p) {\n if (!is(a)) return false;\n a = get(a, i);\n }\n return true;\n}\n\n\n/**\n * Set value at index.\n * @param x an array\n * @param i index\n * @param v value\n * @returns x' | x' = x; x'[i] = v\n */\nexport function set<T>(x: T[], i: number, v: T): T[] {\n return set$(x.slice(), i, v);\n}\nexport {set as with};\n\n\n/**\n * Set value at index!\n * @param x an array (updated!)\n * @param i index\n * @param v value\n * @returns x | x[i] = v\n */\nexport function set$<T>(x: T[], i: number, v: T): T[] {\n x[index(x, i)] = v;\n return x;\n}\n\n\n// TODO: setRange$()\n// TODO: setAll$()\n\n\n/**\n * Set value at path in a nested array!\n * @param x a nested array (updated!)\n * @param p path\n * @param v value\n * @returns x | x[i₀][i₁][...] = v; [i₀, i₁, ...] = p\n */\nexport function setPath$(x: unknown[], p: number[], v: unknown): unknown[] {\n const y = getPath(x, p.slice(0, -1));\n if (is(y)) set$(y, last(p) as number, v);\n return x;\n}\n\n\n/**\n * Exchange two values.\n * @param x an array\n * @param i an index\n * @param j another index\n * @returns x' | x' = x; x'[i] = x[j]; x'[j] = x[i]\n */\nexport function swap<T>(x: T[], i: number, j: number): T[] {\n return swap$(x.slice(), i, j);\n}\n\n\n/**\n * Exchange two values!\n * @param x an array (updated!)\n * @param i an index\n * @param j another index\n * @returns x | x[i] ⇔ x[j]\n */\nexport function swap$<T>(x: T[], i: number, j: number): T[] {\n i = index(x, i); j = index(x, j);\n const t = x[i]; x[i] = x[j]; x[j] = t;\n return x;\n}\n\n\n/**\n * Exchange two values!\n * @param x an array (updated!)\n * @param i an +ve index\n * @param j another +ve index\n * @returns x | x[i] ⇔ x[j]\n */\nfunction swapRaw$<T>(x: T[], i: number, j: number): T[] {\n const t = x[i]; x[i] = x[j]; x[j] = t;\n return x;\n}\n// NOTE: May also be called swapUnchecked$().\n\n\n/**\n * Exchange two ranges of values.\n * @param x an array\n * @param i begin index of first range\n * @param I end index of first range (exclusive)\n * @param j begin index of second range\n * @param J end index of second range (exclusive)\n * @returns x' | x' = x; x'[i..I] = x[j..J]; x'[j..J] = x[i..I]\n */\nexport function swapRanges<T>(x: T[], i: number, I: number, j: number, J: number): T[] {\n [i, I] = indexRange(x, i, I);\n [j, J] = indexRange(x, j, J);\n if (j<i) [i, I, j, J] = [j, J, i, I];\n if (j<I) return x.slice(); // Skip if ranges overlap!\n return x.slice(0, i).concat(x.slice(j, J), x.slice(i, j), x.slice(I));\n}\n\n\n/**\n * Exchange two ranges of values!\n * @param x an array (updated!)\n * @param i begin index of first range\n * @param I end index of first range (exclusive)\n * @param j begin index of second range\n * @param J end index of second range (exclusive)\n * @returns x | x[i..I] ⇔ x[j..J]\n */\nexport function swapRanges$<T>(x: T[], i: number, I: number, j: number, J: number): T[] {\n [i, I] = indexRange(x, i, I);\n [j, J] = indexRange(x, j, J);\n if (j<i) [i, I, j, J] = [j, J, i, I];\n if (j<I) return x; // Skip if ranges overlap!\n const t = x.slice(i, I);\n x.splice(i, I-i, ...x.slice(j, J));\n x.splice(j, J-j, ...t);\n return x;\n}\n// TODO: swapAll$()\n\n\n/**\n * Remove value at index.\n * @param x an array\n * @param i index\n * @returns x[0..i] ⧺ x[i+1..]\n */\nexport function remove<T>(x: T[], i: number): T[] {\n i = index(x, i);\n return x.slice(0, i).concat(x.slice(i+1));\n}\n\n\n/**\n * Remove value at index!\n * @param x an array (updated!)\n * @param i index\n * @returns x \\\\: [i]\n */\nexport function remove$<T>(x: T[], i: number): T[] {\n x.splice(i, 1);\n return x;\n}\n\n\n/**\n * Remove value at path in a nested array!\n * @param x a nested array (updated!)\n * @param p path\n * @returns x \\\\: [i₀][i₁][...] | [i₀, i₁, ...] = p\n */\nexport function removePath$(x: unknown[], p: number[]): unknown[] {\n const y = getPath(x, p.slice(0, -1));\n if (is(y)) y.splice(last(p) as number, 1);\n return x;\n}\n// #endregion\n\n\n\n\n// #region SORT\n// ------------\n\n/**\n * Examine if array is sorted.\n * @param x an array\n * @param fc compare function (a, b)\n * @param fm map function (v, i, x)\n * @returns x is sorted?\n */\nexport function isSorted<T, U=T>(x: T[], fc: CompareFunction<T|U> | null=null, fm: MapFunction<T, T|U> | null=null): boolean {\n return searchUnsortedValue(x, fc, fm) === -1;\n}\n\n\n/**\n * Examine if array has an unsorted value.\n * @param x an array\n * @param fc compare function (a, b)\n * @param fm map function (v, i, x)\n * @returns x is not sorted?\n */\nexport function hasUnsortedValue<T, U=T>(x: T[], fc: CompareFunction<T|U> | null=null, fm: MapFunction<T, T|U> | null=null): boolean {\n return searchUnsortedValue(x, fc, fm) >= 0;\n}\n\n\n/**\n * Find first index of an unsorted value.\n * @param x an array\n * @param fc compare function (a, b)\n * @param fm map function (v, i, x)\n * @returns index of first unsorted value, -1 if sorted\n */\nexport function searchUnsortedValue<T, U=T>(x: T[], fc: CompareFunction<T|U> | null=null, fm: MapFunction<T, T|U> | null=null): number {\n fc = fc || COMPARE;\n fm = fm || IDENTITY;\n const X = x.length;\n if (X<=1) return -1;\n let w0 = fm(x[0], 0, x);\n for (let i=1; i<X; ++i) {\n const w = fm(x[i], i, x);\n if (fc(w0, w)>0) return i;\n w0 = w;\n }\n return -1;\n}\n\n\n/**\n * Arrange values in order.\n * @param x an array\n * @param fc compare function (a, b)\n * @param fm map function (v, i, x)\n * @param fs swap function (x, i, j)\n * @returns x' | x' = x; x'[i] ≤ x'[j] ∀ i ≤ j\n */\nexport function sort<T, U=T>(x: T[], fc: CompareFunction<T|U> | null=null, fm: MapFunction<T, T|U> | null=null, fs: SwapFunction<T> | null=null): T[] {\n return sort$(x.slice(), fc, fm, fs);\n}\nexport {sort as toSorted};\n\n\n/**\n * Arrange values in order!\n * @param x an array (updated!)\n * @param fc compare function (a, b)\n * @param fm map function (v, i, x)\n * @param fs swap function (x, i, j)\n * @returns x | x[i] ≤ x[j] ∀ i ≤ j\n */\nexport function sort$<T, U=T>(x: T[], fc: CompareFunction<T|U> | null=null, fm: MapFunction<T, T|U> | null=null, fs: SwapFunction<T> | null=null): T[] {\n fc = fc || COMPARE;\n if (!fm && !fs) return x.sort(fc);\n const X = x.length;\n fm = fm || IDENTITY;\n fs = fs || swapRaw$;\n return rangedPartialIntroSort$(x, 0, X, X, fc, fm, fs);\n}\n\n\n/**\n * Arrange a range of values in order.\n * @param x an array\n * @param i begin index\n * @param I end index (exclusive)\n * @param fc compare function (a, b)\n * @param fm map function (v, i, x)\n * @param fs swap function (x, i, j)\n * @returns x' | x' = x; x'[i] ≤ x'[j] ∀ i ≤ j\n */\nexport function rangedSort<T, U=T>(x: T[], i: number, I: number, fc: CompareFunction<T|U> | null=null, fm: MapFunction<T, T|U> | null=null, fs: SwapFunction<T> | null=null): T[] {\n return rangedSort$(x.slice(), i, I, fc, fm, fs);\n}\n\n\n/**\n * Arrange a range of values in order!\n * @param x an array (updated!)\n * @param i begin index\n * @param I end index (exclusive)\n * @param fc compare function (a, b)\n * @param fm map function (v, i, x)\n * @param fs swap function (x, i, j)\n * @returns x | x[i] ≤ x[j] ∀ i ≤ j\n */\nexport function rangedSort$<T, U=T>(x: T[], i: number, I: number, fc: CompareFunction<T|U> | null=null, fm: MapFunction<T, T|U> | null=null, fs: SwapFunction<T> | null=null): T[] {\n fc = fc || COMPARE;\n fm = fm || IDENTITY;\n fs = fs || swapRaw$;\n [i, I] = indexRange(x, i, I);\n return rangedPartialIntroSort$(x, i, I, I-i, fc, fm, fs);\n}\n\n\n/**\n * Partially arrange values in order.\n * @param x an array\n * @param n minimum number of values to sort\n * @param fc compare function (a, b)\n * @param fm map function (v, i, x)\n * @param fs swap function (x, i, j)\n * @returns x' | x' = x; x'[i] ≤ x'[j] ∀ i ≤ j\n */\nexport function partialSort<T, U=T>(x: T[], n: number, fc: CompareFunction<T|U> | null=null, fm: MapFunction<T, T|U> | null=null, fs: SwapFunction<T> | null=null): T[] {\n return partialSort$(x.slice(), n, fc, fm, fs);\n}\n\n\n/**\n * Partially arrange values in order!\n * @param x an array (updated!)\n * @param n minimum number of values to sort\n * @param fc compare function (a, b)\n * @param fm map function (v, i, x)\n * @param fs swap function (x, i, j)\n * @returns x | x[i] ≤ x[j] ∀ i ≤ j\n */\nexport function partialSort$<T, U=T>(x: T[], n: number, fc: CompareFunction<T|U> | null=null, fm: MapFunction<T, T|U> | null=null, fs: SwapFunction<T> | null=null): T[] {\n return rangedPartialSort$(x, 0, x.length, n, fc, fm, fs);\n}\n\n\n/**\n * Partially arrange a range of values in order.\n * @param x an array\n * @param i begin index\n * @param I end index (exclusive)\n * @param n minimum number of values to sort\n * @param fc compare function (a, b)\n * @param fm map function (v, i, x)\n * @param fs swap function (x, i, j)\n * @returns x' | x' = x; x'[i] ≤ x'[j] ∀ i ≤ j\n */\nexport function rangedPartialSort<T, U=T>(x: T[], i: number, I: number, n: number, fc: CompareFunction<T|U> | null=null, fm: MapFunction<T, T|U> | null=null, fs: SwapFunction<T> | null=null): T[] {\n return rangedPartialSort$(x.slice(), i, I, n, fc, fm, fs);\n}\n\n\n/**\n * Partially arrange a range of values in order!\n * @param x an array (updated!)\n * @param i begin index\n * @param I end index (exclusive)\n * @param n minimum number of values to sort\n * @param fc compare function (a, b)\n * @param fm map function (v, i, x)\n * @param fs swap function (x, i, j)\n * @returns x | x[i] ≤ x[j] ∀ i ≤ j\n */\nexport function rangedPartialSort$<T, U=T>(x: T[], i: number, I: number, n: number, fc: CompareFunction<T|U> | null=null, fm: MapFunction<T, T|U> | null=null, fs: SwapFunction<T> | null=null): T[] {\n fc = fc || COMPARE;\n fm = fm || IDENTITY;\n fs = fs || swapRaw$;\n [i, I] = indexRange(x, i, I);\n return rangedPartialIntroSort$(x, i, I, n, fc, fm, fs);\n}\n\n\n/**\n * Partially arrange values in order!\n * @param x an array (updated!)\n * @param i begin index\n * @param I end index (exclusive)\n * @param n minimum number of values to sort\n * @param fc compare function (a, b)\n * @param fm map function (v, i, x)\n * @param fs swap function (x, i, j)\n * @returns x | x[i] ≤ x[j] ∀ i ≤ j\n */\nfunction rangedPartialIntroSort$<T, U=T>(x: T[], i: number, I: number, n: number, fc: CompareFunction<T|U>, fm: MapFunction<T, T|U>, fs: SwapFunction<T>): T[] {\n const d = Math.floor(Math.log2(I-i)*2); // Maximum depth of recursion\n const s = 16; // When to switch to insertion sort\n return rangedPartialIntroSortDo$(x, i, I, d, s, n, fc, fm, fs);\n}\n\n\n// Partially arrange a range of values in order with hybrid quick sort, heap sort, and insertion sort.\nfunction rangedPartialIntroSortDo$<T, U=T>(x: T[], i: number, I: number, d: number, s: number, n: number, fc: CompareFunction<T|U>, fm: MapFunction<T, T|U>, fs: SwapFunction<T>): T[] {\n if (n<=0 || I-i<=1) return x; // Nothing to sort\n if (I-i<=s) return rangedPartialInsertionSort$(x, i, I, n, fc, fm, fs); // Insertion sort\n if (d<=0) return rangedPartialHeapSort$(x, i, I, n, fc, fm, fs); // Heap sort\n let p = i + Math.floor((I-i)*Math.random()); // Choose pivot\n p = rangedQuickSortPartition$(x, i, I, p, fc, fm, fs); // Partition array\n rangedPartialIntroSortDo$(x, i, p, d, s, Math.min(p-i, n), fc, fm, fs); // Sort left part\n rangedPartialIntroSortDo$(x, p+1, I, d, s, Math.min(I-p-1, n), fc, fm, fs); // Sort right part\n return x;\n}\n\n\n/**\n * Partially arrange a range of values in order!\n * @param x an array (updated!)\n * @param i begin index\n * @param I end index (exclusive)\n * @param n minimum number of values to sort\n * @param fc compare function (a, b)\n * @param fm map function (v, i, x)\n * @param fs swap function (x, i, j)\n * @returns x | x[i] ≤ x[j] ∀ i ≤ j\n */\nfunction _rangedPartialQuickSort$<T, U=T>(x: T[], i: number, I: number, n: number, fc: CompareFunction<T|U>, fm: MapFunction<T, T|U>, fs: SwapFunction<T>): T[] {\n if (n<=0 || I-i<=1) return x; // Nothing to sort\n let p = i + Math.floor((I-i)*Math.random()); // Choose pivot\n p = rangedQuickSortPartition$(x, i, I, p, fc, fm, fs); // Partition array\n _rangedPartialQuickSort$(x, i, p, Math.min(p-i, n), fc, fm, fs); // Sort left part\n _rangedPartialQuickSort$(x, p+1, I, Math.min(I-p-1, n), fc, fm, fs); // Sort right part\n return x;\n}\n\n\n// TODO: Make this a generic function.\n// Partition the array into two parts, such that values in the first part are less than values in the second part.\nfunction rangedQuickSortPartition$<T, U=T>(x: T[], i: number, I: number, p: number, fc: CompareFunction<T|U>, fm: MapFunction<T, T|U>, fs: SwapFunction<T>): number {\n const wp = fm(x[p], p, x); // Pivot value\n let j = i-1; // Last index of values ≤ pivot\n fs(x, p, I-1); // Move pivot to end\n for (let k=i; k<I-1; ++k) {\n const wk = fm(x[k], k, x);\n if (fc(wk, wp) > 0) continue;\n fs(x, ++j, k); // Move value ≤ pivot to left\n }\n fs(x, ++j, I-1); // Move pivot to middle\n return j; // Return pivot index\n}\n\n\n/**\n * Partially arrange a range of values in order!\n * @param x an array (updated!)\n * @param i begin index\n * @param I end index (exclusive)\n * @param n minimum number of values to sort\n * @param fc compare function (a, b)\n * @param fm map function (v, i, x)\n * @param fs swap function (x, i, j)\n * @returns x | x[i] ≤ x[j] ∀ i ≤ j\n */\nfunction rangedPartialHeapSort$<T, U=T>(x: T[], i: number, I: number, n: number, fc: CompareFunction<T|U>, fm: MapFunction<T, T|U>, fs: SwapFunction<T>): T[] {\n rangedBuildReverseMinHeap$(x, i, I, fc, fm, fs);\n for (const r=I-1; n>0 && i<I; ++i, --n) {\n fs(x, i, r); // Move root to the beginning\n rangedReverseMinHeapify$(x, i+1, I, r, fc, fm, fs); // Rebuild heap\n }\n return x;\n}\n\n\n// Build a reverse min-heap from a range of values, where root node is the smallest and placed at the end.\nfunction rangedBuildReverseMinHeap$<T, U=T>(x: T[], i: number, I: number, fc: CompareFunction<T|U>, fm: MapFunction<T, T|U>, fs: SwapFunction<T>): void {\n for (let r=I-Math.floor((I-i)/2); r<I; ++r) // Reverse of r = X/2-1 .. 0\n rangedReverseMinHeapify$(x, i, I, r, fc, fm, fs);\n}\n\n\n/**\n * Reverse min-heapify a range of values, such that root node is the smallest and placed at the end.\n * @param x an array (updated!)\n * @param i begin index\n * @param I end index (exclusive)\n * @param r root index\n * @param fc compare function (a, b)\n * @param fm map function (v, i, x)\n * @param fs swap function (x, i, j)\n */\nfunction rangedReverseMinHeapify$<T, U=T>(x: T[], i: number, I: number, r: number, fc: CompareFunction<T|U>, fm: MapFunction<T, T|U>, fs: SwapFunction<T>): void {\n let s = r; // Index of smallest value\n const lt = 2*r - I; // Left child, reverse of lt = 2*r+1\n const rt = lt - 1; // Right child, reverse of rt = 2*r+2\n if (lt>=i && fc(fm(x[lt], lt, x), fm(x[s], s, x)) < 0) s = lt; // Left child is smaller?\n if (rt>=i && fc(fm(x[rt], rt, x), fm(x[s], s, x)) < 0) s = rt; // Right child is smaller?\n if (s !== r) { // Smallest is not root?\n fs(x, s, r); // Swap root with smallest\n rangedReverseMinHeapify$(x, i, I, s, fc, fm, fs); // Rebuild heap\n }\n}\n\n\n// Build a max-heap from a range of values, where root node is the smallest and placed at the beginning.\nfunction rangedBuildMaxHeap$<T, U=T>(x: T[], i: number, I: number, fc: CompareFunction<T|U>, fm: MapFunction<T, T|U>, fs: SwapFunction<T>): void {\n for (let r=i+Math.floor((I-i)/2)-1; r>=i; --r)\n rangedMaxHeapify$(x, i, I, r, fc, fm, fs);\n}\n\n\n/**\n * Max-heapify a range of values, such that root node is the largest and placed at the beginning.\n * @param x an array (updated!)\n * @param i begin index\n * @param I end index (exclusive)\n * @param r root index\n * @param fc compare function (a, b)\n * @param fm map function (v, i, x)\n * @param fs swap function (x, i, j)\n */\nfunction rangedMaxHeapify$<T, U=T>(x: T[], i: number, I: number, r: number, fc: CompareFunction<T|U>, fm: MapFunction<T, T|U>, fs: SwapFunction<T>): void {\n let s = r; // Index of largest value\n const lt = 2*r - i + 1; // Left child, like lt = 2*r+1\n const rt = lt + 1; // Right child, like rt = 2*r+2\n if (lt<I && fc(fm(x[lt], lt, x), fm(x[s], s, x)) > 0) s = lt; // Left child is larger?\n if (rt<I && fc(fm(x[rt], rt, x), fm(x[s], s, x)) > 0) s = rt; // Right child is larger?\n if (s !== r) { // Largest is not root?\n fs(x, s, r); // Swap root with largest\n rangedMaxHeapify$(x, i, I, s, fc, fm, fs); // Rebuild heap\n }\n}\n\n\n/**\n * Partially arrange a range of values in order!\n * @param x an array (updated!)\n * @param i begin index\n * @param I end index (exclusive)\n * @param n minimum number of values to sort (ignored)\n * @param fc compare function (a, b)\n * @param fm map function (v, i, x)\n * @param fs swap function (x, i, j)\n * @returns x | x[i] ≤ x[j] ∀ i ≤ j\n */\nfunction rangedPartialInsertionSort$<T, U=T>(x: T[], i: number, I: number, n: number, fc: CompareFunction<T|U>, fm: MapFunction<T, T|U>, fs: SwapFunction<T>): T[] {\n // NOTE: Insertion sort does not support partial sorting, so we ignore n.\n if (fs===swapRaw$) return rangedPartialInsertionSortSwapless$(x, i, I, n, fc, fm, fs);\n else return rangedPartialInsertionSortSwap$ (x, i, I, n, fc, fm, fs);\n}\n\n\n// Sort a range of values in order with swap-enabled version of insertion sort.\nfunction rangedPartialInsertionSortSwap$<T, U=T>(x: T[], i: number, I: number, _n: number, fc: CompareFunction<T|U>, fm: MapFunction<T, T|U>, fs: SwapFunction<T>): T[] {\n for (let j=i+1; j<I; ++j) {\n const key = x[j];\n const wkey = fm(key, j, x);\n for (let k=j-1; k>=i && fc(fm(x[k], k, x), wkey)>0; --k)\n fs(x, k, k+1);\n }\n return x;\n}\n\n\n// Sort a range of values in order with swapless version of insertion sort.\nfunction rangedPartialInsertionSortSwapless$<T, U=T>(x: T[], i: number, I: number, _n: number, fc: CompareFunction<T|U>, fm: MapFunction<T, T|U>, _fs: SwapFunction<T>): T[] {\n for (let j=i+1; j<I; ++j) {\n const key = x[j];\n const wkey = fm(key, j, x);\n let k = j-1;\n for (; k>=i && fc(fm(x[k], k, x), wkey)>0; --k)\n x[k+1] = x[k];\n x[k+1] = key;\n }\n return x;\n}\n\n\n/**\n * Partially arrange a range of values in order!\n * @param x an array (updated!)\n * @param i begin index\n * @param I end index (exclusive)\n * @param n minimum number of values to sort\n * @param fc compare function (a, b)\n * @param fm map function (v, i, x)\n * @param fs swap function (x, i, j)\n * @returns x | x[i] ≤ x[j] ∀ i ≤ j\n */\nfunction _rangedPartialSelectionSort$<T, U=T>(x: T[], i: number, I: number, n: number, fc: CompareFunction<T|U>, fm: MapFunction<T, T|U>, fs: SwapFunction<T>): T[] {\n for (let j=i; n>0 && j<I; ++j, --n) {\n let l = j;\n let wl = fm(x[l], l, x);\n for (let k=j+1; k<I; ++k) {\n const wk = fm(x[k], k, x);\n if (fc(wl, wk) > 0) { l = k; wl = wk; }\n }\n fs(x, j, l);\n }\n return x;\n}\n// #endregion\n\n\n\n\n// #region MINIMUM/MAXIMUM\n// -----------------------\n\n/**\n * Find first smallest value.\n * @param x an array\n * @param fc compare function (a, b)\n * @param fm map function (v, i, x)\n * @returns v | v ≤ vᵢ; vᵢ ∈ x\n */\nexport function minimum<T, U=T>(x: T[], fc: CompareFunction<T|U> | null=null, fm: MapFunction<T, T|U> | null=null): T {\n const i = searchMinimumValue(x, fc, fm);\n return x[i];\n}\nexport {minimum as min};\n\n\n/**\n * Find first smallest entry.\n * @param x an array\n * @param fc compare function (a, b)\n * @param fm map function (v, i, x)\n * @returns [min_index, min_value]\n */\nexport function minimumEntry<T, U=T>(x: T[], fc: CompareFunction<T|U> | null=null, fm: MapFunction<T, T|U> | null=null): [number, T] {\n const i = searchMinimumValue(x, fc, fm);\n return [i, x[i]];\n}\nexport {minimumEntry as minEntry};\n\n\n/**\n * Find first largest value.\n * @param x an array\n * @param fc compare function (a, b)\n * @param fm map function (v, i, x)\n * @returns v | v ≥ vᵢ; vᵢ ∈ x\n */\nexport function maximum<T, U=T>(x: T[], fc: CompareFunction<T|U> | null=null, fm: MapFunction<T, T|U> | null=null): T {\n const i = searchMaximumValue(x, fc, fm);\n return x[i];\n}\nexport {maximum as max};\n\n\n/**\n * Find first largest entry.\n * @param x an array\n * @param fc compare function (a, b)\n * @param fm map function (v, i, x)\n * @returns [max_index, max_value]\n */\nexport function maximumEntry<T, U=T>(x: T[], fc: CompareFunction<T|U> | null=null, fm: MapFunction<T, T|U> | null=null): [number, T] {\n const i = searchMaximumValue(x, fc, fm);\n return [i, x[i]];\n}\nexport {maximumEntry as maxEntry};\n\n\n/**\n * Find smallest and largest values.\n * @param x an array\n * @param fc compare function (a, b)\n * @param fm map function (v, i, x)\n * @returns [min_value, max_value]\n */\nexport function range<T, U=T>(x: T[], fc: CompareFunction<T|U> | null=null, fm: MapFunction<T, T|U> | null=null): [T | undefined, T | undefined] {\n const [a, b] = rangeEntries(x, fc, fm);\n return [a[1], b[1]];\n}\n\n\n/**\n * Find smallest and largest entries.\n * @param x an array\n * @param fc compare function (a, b)\n * @param fm map function (v, i, x)\n * @returns [min_entry, max_entry]\n */\nexport function rangeEntries<T, U=T>(x: T[], fc: CompareFunction<T|U> | null=null, fm: MapFunction<T, T|U> | null=null): [[number, T | undefined], [number, T | undefined]] {\n fc = fc || COMPARE;\n fm = fm || IDENTITY;\n const X = x.length;\n if (X===0) return [[-1, undefined], [-1, undefined]];\n let v = x[0], w = fm(v, 0, x);\n let mi = 0, mv = v, mw = w;\n let ni = 0, nv = v, nw = w;\n for (let i=1; i<X; ++i) {\n v = x[i]; w = fm(v, i, x);\n if (fc(w, mw)<0) { mi = i; mv = v; mw = w; }\n if (fc(w, nw)>0) { ni = i; nv = v; nw = w; }\n }\n return [[mi, mv], [ni, nv]];\n}\n\n\n/**\n * Find smallest values.\n * @param x an array\n * @param n number of values\n * @param fc compare function (a, b)\n * @param fm map function (v, i, x)\n * @returns n smallest values in ascending order\n */\nexport function minimums<T, U=T>(x: T[], n: number, fc: CompareFunction<number|T|U> | null=null, fm: MapFunction<T, T|U> | null=null): T[] {\n const is = searchMinimumValues(x, n, fc, fm);\n return is.map(i => x[i]);\n}\n\n\n/**\n * Find smallest entries.\n * @param x an array\n * @param n number of values\n * @param fc compare function (a, b)\n * @param fm map function (v, i, x)\n * @returns n smallest entries in ascending order\n */\nexport function minimumEntries<T, U=T>(x: T[], n: number, fc: CompareFunction<number|T|U> | null=null, fm: MapFunction<T, T|U> | null=null): [number, T][] {\n const is = searchMinimumValues(x, n, fc, fm);\n return is.map(i => [i, x[i]]);\n}\n\n\n/**\n * Find largest values.\n * @param x an array\n * @param n number of values\n * @param fc compare function (a, b)\n * @param fm map function (v, i, x)\n * @returns n largest values in descending order\n */\nexport function maximums<T, U=T>(x: T[], n: number, fc: CompareFunction<number|T|U> | null=null, fm: MapFunction<T, T|U> | null=null): T[] {\n const is = searchMaximumValues(x, n, fc, fm);\n return is.map(i => x[i]);\n}\n\n\n/**\n * Find largest entries.\n * @param x an array\n * @param n number of values\n * @param fc compare function (a, b)\n * @param fm map function (v, i, x)\n * @returns n largest entries in descending order\n */\nexport function maximumEntries<T, U=T>(x: T[], n: number, fc: CompareFunction<number|T|U> | null=null, fm: MapFunction<T, T|U> | null=null): [number, T][] {\n const is = searchMaximumValues(x, n, fc, fm);\n return is.map(i => [i, x[i]]);\n}\n\n\n/**\n * Find first index of minimum value.\n * @param x an array\n * @param fc compare function (a, b)\n * @param fm map function (v, i, x)\n * @returns first index of minimum value, -1 if empty\n */\nexport function searchMinimumValue<T, U=T>(x: T[], fc: CompareFunction<T|U> | null=null, fm: MapFunction<T, T|U> | null=null): number {\n fc = fc || COMPARE;\n fm = fm || IDENTITY;\n const X = x.length;\n if (X===0) return -1;\n let mi = 0, mw = fm(x[0], 0, x);\n for (let i=1; i<X; ++i) {\n const w = fm(x[i], i, x);\n if (fc(w, mw)<0) { mi = i; mw = w; }\n }\n return mi;\n}\n\n\n/**\n * Find first index of maximum value.\n * @param x an array\n * @param fc compare function (a, b)\n * @param fm map function (v, i, x)\n * @returns first index of maximum value, -1 if empty\n */\nexport function searchMaximumValue<T, U=T>(x: T[], fc: CompareFunction<T|U> | null=null, fm: MapFunction<T, T|U> | null=null): number {\n fc = fc || COMPARE;\n fm = fm || IDENTITY;\n const X = x.length;\n if (X===0) return -1;\n let ni = 0, nw = fm(x[0], 0, x);\n for (let i=1; i<X; ++i) {\n const w = fm(x[i], i, x);\n if (fc(w, nw)>0) { ni = i; nw = w; }\n }\n return ni;\n}\n\n\n/**\n * Find indices of minimum values.\n * @param x an array\n * @param n number of values\n * @param fc compare function (a, b)\n * @param fm map function (v, i, x)\n * @returns indices of minimum values in ascending order\n */\nexport function searchMinimumValues<T, U=T>(x: T[], n: number, fc: CompareFunction<number|T|U> | null=null, fm: MapFunction<T, T|U> | null=null): number[] {\n fc = fc || COMPARE;\n fm = fm || IDENTITY;\n const X = x.length;\n // Create a max heap of indices.\n const IH = Math.min(n, X);\n const ih = fromRange(0, IH);\n rangedBuildMaxHeap$(ih, 0, IH, fc, i => fm(x[i], i, x), swapRaw$);\n let wr = fm(x[ih[0]], ih[0], x);\n // Search for minimum values, and update heap.\n for (let i=n; i<X; ++i) {\n const w = fm(x[i], i, x);\n if (fc(w, wr) >= 0) continue;\n ih[0] = i;\n rangedMaxHeapify$(ih, 0, IH, 0, fc, i => fm(x[i], i, x), swapRaw$);\n wr = fm(x[ih[0]], ih[0], x);\n }\n // Sort max heap in ascending order.\n ih.sort((i, j) => fc(fm(x[i], i, x), fm(x[j], j, x)));\n return ih;\n}\n\n\n/**\n * Find indices of maximum values.\n * @param x an array\n * @param n number of values\n * @param fc compare function (a, b)\n * @param fm map function (v, i, x)\n * @returns indices of maximum values in descending order\n */\nexport function searchMaximumValues<T, U=T>(x: T[], n: number, fc: CompareFunction<number|T|U> | null=null, fm: MapFunction<T, T|U> | null=null): number[] {\n fc = fc || COMPARE;\n const fd = (a: number|T|U, b: number|T|U) => -fc(a, b);\n return searchMinimumValues(x, n, fd, fm);\n}\n// #endregion\n\n\n\n\n// #region COMPARE\n// ---------------\n\n/**\n * Examine if two arrays are equal.\n * @param x an array\n * @param y another array\n * @param fc compare function (a, b)\n * @param fm map function (v, i, x)\n * @returns x = y?\n */\nexport function isEqual<T, U=T>(x: T[], y: T[], fc: CompareFunction<T|U> | null=null, fm: MapFunction<T, T|U> | null=null): boolean {\n const X = x.length, Y = y.length;\n return X===Y && compare(x, y, fc, fm)===0;\n}\n\n\n/**\n * Compare two arrays (lexicographically).\n * @param x an array\n * @param y another array\n * @param fc compare function (a, b)\n * @param fm map function (v, i, x)\n * @returns x<y: -ve, x=y: 0, x>y: +ve\n */\nexport function compare<T, U=T>(x: T[], y: T[], fc: CompareFunction<T|U> | null=null, fm: MapFunction<T, T|U> | null=null): number {\n fc = fc || COMPARE;\n fm = fm || IDENTITY;\n const X = x.length;\n const Y = y.length;\n for (let i=0, I=Math.min(X, Y); i<I; ++i) {\n const wx = fm(x[i], i, x);\n const wy = fm(y[i], i, y);\n const c = fc(wx, wy);\n if (c!==0) return c;\n }\n return Math.sign(X-Y);\n}\n// #endregion\n\n\n\n\n// #region PART\n// ------------\n\n/**\n * Get first value.\n * @param x an array\n * @param vd default value\n * @returns x[0] || vd\n */\nexport function head<T>(x: T[], vd?: T): T | undefined {\n return x.length>0? x[0] : vd;\n}\nexport {head as front};\nexport {head as first};\n\n\n/**\n * Get values except first.\n * @param x an array\n * @returns x[1..|x|]\n */\nexport function tail<T>(x: T[]): T[] {\n return x.slice(1);\n}\n\n\n/**\n * Get values except last.\n * @param x an array\n * @returns x[0..|x|-1]\n */\nexport function init<T>(x: T[]): T[] {\n return x.slice(0, -1);\n}\n\n\n/**\n * Get last value.\n * @param x an array\n * @param vd default value\n * @returns x[|x|-1] || vd\n */\nexport function last<T>(x: T[], vd?: T): T | undefined {\n return x.length>0? x[x.length-1] : vd;\n}\nexport {last as back};\n\n\n/**\n * Get values from middle.\n * @param x an array\n * @param i begin index\n * @param n number of values [1]\n * @returns x[i..i+n]\n */\nexport function middle<T>(x: T[], i: number, n: number=1): T[] {\n i = index(x, i);\n n = Math.max(n, 0);\n return x.slice(i, i+n);\n}\n\n\n/**\n * Get part of an array.\n * @param x an array\n * @param i begin index [0]\n * @param I end index [|x|]\n * @returns x[i..I]\n */\nexport function slice<T>(x: T[], i: number=0, I: number=x.length): T[] {\n return x.slice(i, I);\n}\n\n\n/**\n * Get part of an array!\n * @param x an array (updated!)\n * @param i begin index [0]\n * @param I end index [|x|]\n * @returns x = x[i..I]\n */\nexport function slice$<T>(x: T[], i: number=0, I: number=x.length): T[] {\n x.copyWithin(0, i, I);\n x.length = length(x, i, I);\n return x;\n}\n// #endregion\n\n\n\n\n// #region SEARCH VALUE\n// --------------------\n\n/**\n * Check if array has a value.\n * @param x an array\n * @param v search value\n * @param i begin index [0]\n * @returns v ∈ x[i..]?\n */\nexport function includes<T>(x: T[], v: T, i: number=0): boolean {\n return x.includes(v, i);\n}\n\n\n/**\n * Examine if array has a value.\n * @param x an array\n * @param v search value\n * @param fc compare function (a, b)\n * @param fm map function (v, i, x)\n * @returns v ∈ x?\n */\nexport function hasValue<T, U=T>(x: T[], v: T, fc: CompareFunction<T|U> | null=null, fm: MapFunction<T, T|U> | null=null): boolean {\n return searchValue(x, v, fc, fm) >= 0;\n}\n\n\n/**\n * Find first index of a value.\n * @param x an array\n * @param v search value\n * @param fc compare function (a, b)\n * @param fm map function (v, i, x)\n * @returns first index of value, -1 if not found\n */\nexport function searchValue<T, U=T>(x: T[], v: T, fc: CompareFunction<T|U> | null=null, fm: MapFunction<T, T|U> | null=null): number {\n fc = fc || COMPARE;\n fm = fm || IDENTITY;\n const w = fm(v, 0, null); let i = -1;\n for (const vx of x) {\n const wx = fm(vx, ++i, x);\n if (fc(wx, w)===0) return i;\n }\n return -1;\n}\n\n\n/**\n * Find last index of a value.\n * @param x an array\n * @param v search value\n * @param fc compare function (a, b)\n * @param fm map function (v, i, x)\n * @returns last index of value, -1 if not found\n */\nexport function searchValueRight<T, U=T>(x: T[], v: T, fc: CompareFunction<T|U> | null=null, fm: MapFunction<T, T|U> | null=null): number {\n fc = fc || COMPARE;\n fm = fm || IDENTITY;\n const w = fm(v, 0, null);\n for (let i=x.length-1; i>=0; --i) {\n const wx = fm(x[i], i, x);\n if (fc(wx, w)===0) return i;\n }\n return -1;\n}\n\n\n/**\n * Find indices of value.\n * @param x an array\n * @param v search value\n * @param fc compare function (a, b)\n * @param fm map function (v, i, x)\n * @returns indices of value\n */\nexport function searchValueAll<T, U=T>(x: T[], v: T, fc: CompareFunction<T|U> | null=null, fm: MapFunction<T, T|U> | null=null): number[] {\n fc = fc || COMPARE;\n fm = fm || IDENTITY;\n const w = fm(v, 0, null);\n let i = -1; const a = [];\n for (const vx of x) {\n const wx = fm(vx, ++i, x);\n if (fc(wx, w)===0) a.push(i);\n }\n return a;\n}\n\n\n/**\n * Find first index of an adjacent duplicate value.\n * @param x an array\n * @param fc compare function (a, b)\n * @param fm map function (v, i, x)\n * @returns index of first adjacent duplicate value, -1 if none\n */\nexport function searchAdjacentDuplicateValue<T, U=T>(x: T[], fc: CompareFunction<T|U> | null=null, fm: MapFunction<T, T|U> | null=null): number {\n fc = fc || COMPARE;\n fm = fm || IDENTITY;\n const X = x.length;\n if (X<=1) return -1;\n let w0 = fm(x[0], 0, x);\n for (let i=1; i<X; ++i) {\n const w = fm(x[i], i, x);\n if (fc(w0, w)===0) return i;\n w0 = w;\n }\n return -1;\n}\nexport {searchAdjacentDuplicateValue as searchAdjacentDuplicate};\n\n\n/**\n * Find first index where two arrays differ.\n * @param x an array\n * @param y another array\n * @param fc compare function (a, b)\n * @param fm map function (v, i, x)\n * @returns first index where x[i] ≠ y[i], or -1\n */\nexport function searchMismatchedValue<T, U=T>(x: T[], y: T[], fc: CompareFunction<T|U> | null=null, fm: MapFunction<T, T|U> | null=null): number {\n fc = fc || COMPARE;\n fm = fm || IDENTITY;\n const X = x.length;\n const Y = y.length;\n const I = Math.min(X, Y);\n for (let i=0; i<I; ++i) {\n const wx = fm(x[i], i, x);\n const wy = fm(y[i], i, y);\n if (fc(wx, wy)!==0) return i;\n }\n return X===Y? -1 : I;\n}\nexport {searchMismatchedValue as searchMismatch};\n// #endregion\n\n\n\n\n// #region ARRANGEMENTS\n// --------------------\n\n/**\n * Examine if array starts with a prefix.\n * @param x an array\n * @param y search prefix\n * @param fc compare function (a, b)\n * @param fm map function (v, i, x)\n * @returns x[0..|y|] = y?\n */\nexport function hasPrefix<T, U=T>(x: T[], y: T[], fc: CompareFunction<T|U> | null=null, fm: MapFunction<T, T|U> | null=null): boolean {\n const Y = y.length;\n return Y===0 || compare(x.slice(0, Y), y, fc, fm)===0;\n}\nexport {hasPrefix as startsWith};\n\n\n/**\n * Examine if array ends with a suffix.\n * @param x an array\n * @param y search suffix\n * @param fc compare function (a, b)\n * @param fm map function (v, i, x)\n * @returns x[|x|-|y|..] = y?\n */\nexport function hasSuffix<T, U=T>(x: T[], y: T[], fc: CompareFunction<T|U> | null=null, fm: MapFunction<T, T|U> | null=null): boolean {\n const Y = y.length;\n return Y===0 || compare(x.slice(-Y), y, fc, fm)===0;\n}\nexport {hasSuffix as endsWith};\n\n\n/**\n * Examine if array contains an infix.\n * @param x an array\n * @param y search infix\n * @param fc compare function (a, b)\n * @param fm map function (v, i, x)\n * @returns x[i..I] = y for some i, I?\n */\nexport function hasInfix<T, U=T>(x: T[], y: T[], fc: CompareFunction<T|U> | null=null, fm: MapFunction<T, T|U> | null=null): boolean {\n return searchInfix(x, y, fc, fm) >= 0;\n}\n\n\n/**\n * Examine if array has a subsequence.\n * @param x an array\n * @param y search subsequence\n * @param fc compare function (a, b)\n * @param fm map function (v, i, x)\n * @returns x[i₀] ⧺ x[i₁] ⧺ ... = y, for some i₀, i₁, ...? | i₀ < i₁ < ...\n */\nexport function hasSubsequence<T, U=T>(x: T[], y: T[], fc: CompareFunction<T|U> | null=null, fm: MapFunction<T, T|U> | null=null): boolean {\n return searchSubsequence(x, y, fc, fm) >= 0;\n}\n\n\n/**\n * Examine if array has a permutation.\n * @param x an array\n * @param y search permutation\n * @param fc map function (v, i, x)\n * @param fm compare function (a, b)\n * @returns x contains a shuffled version of y?\n */\nexport function hasPermutation<T, U=T>(x: T[], y: T[], fc: CompareFunction<T|U> | null=null, fm: MapFunction<T, T|U> | null=null): boolean {\n const x1 = fm? x.map(fm) : x.slice();\n const y1 = fm? y.map(fm) : y.slice();\n return hasSubsequence<T|U>(x1.sort(), y1.sort(), fc);\n // return hasSubsequence<T|U>(x1.sort(), y1.sort(), fc, fm);\n}\n\n\n/**\n * Obtain all possible prefixes.\n * @param x an array\n * @param n number of values [-1 ⇒ any]\n * @returns [[], x[..1], x[..2], ...] if n<0; [x[..n]] otherwise\n */\nexport function prefixes<T>(x: T[], n: number=-1): T[][] {\n return [...iprefixes(x, n)];\n}\n\n\n/**\n * List all possible prefixes.\n * @param x an array\n * @param n number of values [-1 ⇒ any]\n * @returns [], x[..1], x[..2], ... if n<0; x[..n] otherwise\n */\nexport function* iprefixes<T>(x: T[], n: number=-1): IterableIterator<T[]> {\n const X = x.length;\n if (n>X) return;\n if (n>=0) { yield x.slice(0, n); return; }\n for (let i=0; i<=X; ++i)\n yield x.slice(0, i);\n}\n\n\n/**\n * Obtain all possible suffixes.\n * @param x an array\n * @param n number of values [-1 ⇒ any]\n * @returns [x[0..], x[1..], x[2..], ...] if n<0; [x[-n..]] otherwise\n */\nexport function suffixes<T>(x: T[], n: number=-1): T[][] {\n return [...isuffixes(x, n)];\n}\n\n\n/**\n * List all possible suffixes.\n * @param x an array\n * @param n number of values [-1 ⇒ any]\n * @returns x[0..], x[1..], x[2..], ... if n<0; x[-n..] otherwise\n */\nexport function* isuffixes<T>(x: T[], n: number=-1): IterableIterator<T[]> {\n const X = x.length;\n if (n>X) return;\n if (n>=0) { yield x.slice(x.length - n); return; }\n for (let i=0; i<=X; ++i)\n yield x.slice(i);\n}\n\n\n/**\n * Obtain all possible infixes.\n * @param x an array\n * @param n number of values [-1 ⇒ any]\n * @returns [[], x[0..1], x[0..2], ..., x[1..2], ...] if n<0; [only of length n] otherwise\n */\nexport function infixes<T>(x: T[], n: number=-1): T[][] {\n return [...iinfixes(x, n)];\n}\n\n\n/**\n * List all possible infixes.\n * @param x an array\n * @param n number of values [-1 ⇒ any]\n * @returns [], x[0..1], x[0..2], ..., x[1..2], ... if n<0; only of length n otherwise\n */\nexport function iinfixes<T>(x: T[], n: number=-1): IterableIterator<T[]> {\n if (n>=0) return infixesFixed(x, n);\n else return infixesAll(x);\n}\n\nfunction* infixesFixed<T>(x: T[], n: number): IterableIterator<T[]> {\n const X = x.length;\n if (n>X) return;\n if (n===0) { yield []; return; }\n for (let i=0, I=X-n+1; i<I; ++i)\n yield x.slice(i, i+n);\n}\n\nfunction* infixesAll<T>(x: T[]): IterableIterator<T[]> {\n const X = x.length; yield [];\n for (let i=0; i<X; ++i) {\n for (let j=i+1; j<=X; ++j)\n yield x.slice(i, j);\n }\n}\n\n\n/**\n * Obtain all possible subsequences.\n * @param x an array\n * @param n number of values [-1 ⇒ any]\n * @returns [elements selected by bit from 0..2^|x|] if n<0; [only of length n] otherwise\n */\nexport function subsequences<T>(x: T[], n: number=-1): T[][] {\n return [...isubsequences(x, n)];\n}\n\n\n/**\n * List all possible subsequences.\n * @param x an array\n * @param n number of values [-1 ⇒ any]\n * @returns elements selected by bit from 0..2^|x| if n<0; only of length n otherwise\n */\nexport function* isubsequences<T>(x: T[], n: number=-1): IterableIterator<T[]> {\n const X = x.length;\n if (n>X) return;\n if (n===X) { yield x; return; }\n if (n===0 || X===0) { yield []; return; }\n const y = x.slice(0, -1);\n yield* isubsequences(y, n);\n for (const s of isubsequences(y, n-1)) {\n s.push(x[X-1]);\n yield s;\n }\n}\n\n\n/**\n * Obtain all possible permutations.\n * @param x an array\n * @param n number of values [-1 ⇒ any]\n * @returns [[], arrangements of length 1, of length 2, ...] if n<0; [only of length n] otherwise\n */\nexport function permutations<T>(x: T[], n: number=-1): T[][] {\n return [...ipermutations(x, n)];\n}\n\n\n/**\n * List all possible permutations.\n * @param x an array\n * @param n number of values [-1 ⇒ any]\n * @returns [], arrangements of length 1, of length 2, ... if n<0; only of length n otherwise\n */\nexport function* ipermutations<T>(x: T[], n: number=-1): IterableIterator<T[]> {\n const X = x.length;\n if (n>X) return;\n let i = n<0? 0 : n;\n const I = n<0? X : n\n for (; i<=I; ++i)\n yield* ipermutationsFixed(x, i);\n}\n\nfunction* ipermutationsFixed<T>(x: T[], n: number): IterableIterator<T[]> {\n const X = x.length;\n if (X===0 || n===0) { yield []; return; }\n for (let i=0; i<X; ++i) {\n const y = splice(x, i, 1);\n for (const p of ipermutationsFixed(y, n-1))\n yield [x[i], ...p];\n }\n}\n\n\n/**\n * Find first index of an infix.\n * @param x an array\n * @param y search infix\n * @param fc compare function (a, b)\n * @param fm map function (v, i, x)\n * @returns first i | x[i..i+|y|] = y else -1\n */\nexport function searchInfix<T, U=T>(x: T[], y: T[], fc: CompareFunction<T|U> | null=null, fm: MapFunction<T, T|U> | null=null): number {\n fc = fc || COMPARE;\n fm = fm || IDENTITY;\n const X = x.length, Y = y.length;\n for (let i=0; i<=X-Y; ++i)\n if (isInfixAt(x, y, i, fc, fm)) return i;\n return -1;\n}\n\n\n/**\n * Find last index of an infix.\n * @param x an array\n * @param y search infix\n * @param fc compare function (a, b)\n * @param fm map function (v, i, x)\n * @returns first i | x[i..i+|y|] = y else -1\n */\nexport function searchInfixRight<T, U=T>(x: T[], y: T[], fc: CompareFunction<T|U> | null=null, fm: MapFunction<T, T|U> | null=null): number {\n fc = fc || COMPARE;\n fm = fm || IDENTITY;\n const X = x.length, Y = y.length;\n for (let i=X-Y; i>=0; --i)\n if (isInfixAt(x, y, i, fc, fm)) return i;\n return -1;\n}\n\n\n/**\n * Find indices of an infix.\n * @param x an array\n * @param y search infix\n * @param fc compare function (a, b)\n * @param fm map function (v, i, x)\n * @returns i₀, i₁, ... | x[j..j+|y|] = y; j ∈ [i₀, i₁, ...]\n */\nexport function searchInfixAll<T, U=T>(x: T[], y: T[], fc: CompareFunction<T|U> | null=null, fm: MapFunction<T, T|U> | null=null): number[] {\n fc = fc || COMPARE;\n fm = fm || IDENTITY;\n const X = x.length, Y = y.length, a = [];\n for (let i=0; i<=X-Y; ++i)\n if (isInfixAt(x, y, i, fc, fm)) a.push(i);\n return a;\n}\n\n\nfunction isInfixAt<T, U=T>(x: T[], y: T[], i: number, fc: CompareFunction<T|U>, fm: MapFunction<T, T|U>): boolean {\n const Y = y.length;\n for (let j=0; j<Y; ++j) {\n const wx = fm(x[i+j], i+j, x);\n const wy = fm(y[j], j, y);\n if (fc(wx, wy)!==0) return false;\n }\n return true;\n}\n\n\n/**\n * Find first index of a subsequence.\n * @param x an array\n * @param y search subsequence\n * @param fc compare function (a, b)\n * @param fm map function (v, i, x)\n * @returns begin index of subsequence, -1 if not found\n */\nexport function searchSubsequence<T, U=T>(x: T[], y: T[], fc: CompareFunction<T|U> | null=null, fm: MapFunction<T, T|U> | null=null): number {\n fc = fc || COMPARE;\n fm = fm || IDENTITY;\n const y1 = [...y].map(fm), Y = y1.length;\n let a = -1, i = -1, j = 0;\n for (const vx of x) {\n const wx = fm(vx, ++i, x);\n if (fc(wx, y1[j])!==0) continue;\n if (a<0) a = i;\n if (++j>=Y) return a;\n }\n return -1;\n}\n// #endregion\n\n\n\n\n// #region RANDOM ARRANGEMENTS\n// ---------------------------\n\n/**\n * Pick an arbitrary value.\n * @param x an array\n * @param fr random number generator ([0, 1))\n * @returns x[i] | i ∈ 0..|x|\n */\nexport function randomValue<T>(x: T[], fr: ReadFunction<number> | null=Math.random): T {\n fr = fr || Math.random;\n const i = Math.floor(fr() * x.length);\n return x[i];\n}\nexport {randomValue as value}; // DEPRECATED\n\n\n/**\n * Pick an arbitrary prefix.\n * @param x an array\n * @param n number of values [-1 ⇒ any]\n * @param fr random number generator ([0, 1))\n * @returns x[..i] if n<0; x[..n] otherwise | i ∈ 0..|x|\n */\nexport function randomPrefix<T>(x: T[], n: number=-1, fr: ReadFunction<number> | null=Math.random): T[] | null {\n fr = fr || Math.random;\n const X = x.length;\n if (n>X) return null;\n n = n>=0? n : Math.floor((X+1)*fr());\n return x.slice(0, n);\n}\nexport {randomPrefix as prefix}; // DEPRECATED\n\n\n/**\n * Pick an arbitrary suffix.\n * @param x an array\n * @param n number of values [-1 ⇒ any]\n * @param fr random number generator ([0, 1))\n * @returns x[|x|-i..] if n<0; x[|x|-n..] otherwise | i ∈ 0..|x|\n */\nexport function randomSuffix<T>(x: T[], n: number=-1, fr: ReadFunction<number> | null=Math.random): T[] | null {\n const X = x.length;\n if (n>X) return null;\n n = n>=0? n : Math.floor((X+1)*(fr as ReadFunction<number>)());\n return x.slice(X-n);\n}\nexport {randomSuffix as suffix}; // DEPRECATED\n\n\n/**\n * Pick an arbitrary infix.\n * @param x an array\n * @param n number of values [-1 ⇒ any]\n * @param fr random number generator ([0, 1))\n * @returns x[i..j] if n<0; x[i..i+n] otherwise | i, j ∈ 0..|x|\n */\nexport function randomInfix<T>(x: T[], n: number=-1, fr: ReadFunction<number> | null=Math.random): T[] | null {\n const X = x.length;\n if (n>X) return null;\n n = n>=0? n : randomInfixLength(X, (fr as ReadFunction<number>)());\n const i = Math.floor((X+1-n)*(fr as ReadFunction<number>)());\n return x.slice(i, i+n);\n}\nexport {randomInfix as infix}; // DEPRECATED\n\n// Not all infix lengths are equally proable.\nfunction randomInfixLength(X: number, r: number): number {\n const C = 0.5 * X*(X+1) + 1;\n const n = 0.5 * Math.sqrt(1 + 8*r*C) - 0.5;\n return X+1 - Math.floor(n+1);\n}\n\n\n/**\n * Pick an arbitrary subsequence.\n * @param x an array\n * @param n number of values [-1 ⇒ any]\n * @param fr random number generator ([0, 1))\n * @returns x[i, j, ...] | [i, j, ...] = is; |is| = |x| if n<0 else n\n */\nexport function randomSubsequence<T>(x: T[], n: number=-1, fr: ReadFunction<number> | null=Math.random): T[] | null {\n const X = x.length;\n if (n>X) return null;\n if (n>=0) return randomSubsequenceFixed(x, n, fr as ReadFunction<number>);\n else return randomSubsequenceAll(x, fr as ReadFunction<number>);\n}\nexport {randomSubsequence as subsequence}; // DEPRECATED\n\nfunction randomSubsequenceFixed<T>(x: T[], n: number, fr: ReadFunction<number>): T[] {\n const is = fromRange(0, x.length);\n randomPermutation$(is, n, fr).sort();\n return getAll(x, is);\n}\n\nfunction randomSubsequenceAll<T>(x: T[], fr: ReadFunction<number>): T[] {\n const a: T[] = [];\n for (const v of x)\n if (fr()<0.5) a.push(v);\n return a;\n}\n\n\n/**\n * Pick an arbitrary permutation.\n * @param x an array\n * @param n number of values [-1 ⇒ any]\n * @param fr random number generator ([0, 1))\n * @returns x' | x' = x; values are randomly shuffled\n */\nexport function randomPermutation<T>(x: T[], n: number=-1, fr: ReadFunction<number> | null=Math.random): T[] | null {\n const X = x.length;\n if (n>X) return null;\n return randomPermutation$(x.slice(), n, fr);\n}\nexport {randomPermutation as permutation}; // DEPRECATED\n\n\n/**\n * Pick an arbitrary permutation!\n * @param x an array (updated!)\n * @param n number of values [-1 ⇒ any]\n * @param fr random number generator ([0, 1))\n * @returns x | values are randomly shuffled\n */\nexport function randomPermutation$<T>(x: T[], n: number=-1, fr: ReadFunction<number> | null=Math.random): T[] {\n fr = fr || Math.random;\n const X = x.length;\n if (n>X) return x;\n n = n>=0? n : Math.floor((X+1)*fr());\n for (let i=0; i<n; ++i) {\n const j = i + Math.floor((X-i)*fr());\n const t = x[i]; x[i] = x[j]; x[j] = t;\n }\n x.length = n;\n return x;\n}\nexport {randomPermutation$ as permutation$}; // DEPRECATED\nexport {randomPermutation$ as permute$};\nexport {randomPermutation$ as shuffle$};\n// - https://en.wikipedia.org/wiki/Fisher–Yates_shuffle\n// #endregion\n\n\n\n\n// #region FIND\n// ------------\n\n/**\n * Find first value passing a test.\n * @param x an array\n * @param ft test function (v, i, x)\n * @returns first v | ft(v) = true; v ∈ x\n */\nexport function find<T>(x: T[], ft: TestFunction<T>): T {\n return x.find(ft) as T;\n}\n\n\n/**\n * Find last value passing a test.\n * @param x an array\n * @param ft test function (v, i, x)\n * @returns last v | ft(v) = true; v ∈ x\n */\nexport function findRight<T>(x: T[], ft: TestFunction<T>): T {\n for (let i=x.length-1; i>=0; --i)\n if (ft(x[i], i, x)) return x[i];\n return undefined as unknown as T;\n}\n// #endregion\n\n\n\n\n// #region TAKE/DROP\n// -----------------\n\n/**\n * Keep first n values only.\n * @param x an array\n * @param n number of values [1]\n * @returns x[0..n]\n */\nexport function take<T>(x: T[], n: number=1): T[] {\n n = Math.max(n, 0);\n return x.slice(0, n);\n}\nexport {take as left};\n\n\n/**\n * Keep last n values only.\n * @param x an array\n * @param n number of values [1]\n * @returns x[0..n]\n */\nexport function takeRight<T>(x: T[], n: number=1): T[] {\n const X = x.length;\n n = Math.min(Math.max(n, 0), X);\n return x.slice(X-n);\n}\nexport {takeRight as right};\n\n\n/**\n * Keep values from left, while a test passes.\n * @param x an array\n * @param ft test function (v, i, x)\n * @returns x[0..T-1] | ft(x[i]) = true ∀ i ∈ [0, T-1] & ft(x[T]) = false\n */\nexport function takeWhile<T>(x: T[], ft: TestFunction<T>): T[] {\n return x.slice(0, scanWhile(x, ft));\n}\n\n\n/**\n * Keep values from right, while a test passes.\n * @param x an array\n * @param ft test function (v, i, x)\n * @returns x[T..] | ft(x[i]) = true ∀ i ∈ [T, |x|-1] & ft(x[T-1]) = false\n */\nexport function takeWhileRight<T>(x: T[], ft: TestFunction<T>): T[] {\n return x.slice(scanWhileRight(x, ft));\n}\n\n\n/**\n * Discard first n values only.\n * @param x an array\n * @param n number of values [1]\n * @returns x[n..]\n */\nexport function drop<T>(x: T[], n: number=1): T[] {\n n = Math.max(n, 0);\n return x.slice(n);\n}\n\n\n/**\n * Discard last n values only.\n * @param x an array\n * @param n number of values [1]\n * @returns x[0..-n]\n */\nexport function dropRight<T>(x: T[], n: number=1): T[] {\n const X = x.length;\n n = Math.min(Math.max(n, 0), X);\n return x.slice(0, X-n);\n}\n\n\n/**\n * Discard values from left, while a test passes.\n * @param x an array\n * @param ft test function (v, i, x)\n * @returns x[T..] | ft(x[i]) = true ∀ i ∈ [0, T-1] & ft(x[T]) = false\n */\nexport function dropWhile<T>(x: T[], ft: TestFunction<T>): T[] {\n return x.slice(scanWhile(x, ft));\n}\n\n\n/**\n * Discard values from right, while a test passes.\n * @param x an array\n * @param ft test function (v, i, x)\n * @returns x[0..T-1] | ft(x[i]) = true ∀ i ∈ [T, |x|-1] & ft(x[T-1]) = false\n */\nexport function dropWhileRight<T>(x: T[], ft: TestFunction<T>): T[] {\n return x.slice(0, scanWhileRight(x, ft));\n}\n// #endregion\n\n\n\n\n// #region SCAN\n// ------------\n\n/**\n * Scan from left, while a test passes.\n * @param x an array\n * @param ft test function (v, i, x)\n * @returns first index where test fails\n */\nexport function scanWhile<T>(x: T[], ft: TestFunction<T>): number {\n let i = -1;\n for (const v of x)\n if (!ft(v, ++i, x)) return i;\n return ++i;\n}\n\n\n/**\n * Scan from right, while a test passes.\n * @param x an array\n * @param ft test function (v, i, x)\n * @returns first index where test passes till end\n */\nexport function scanWhileRight<T>(x: T[], ft: TestFunction<T>): number {\n let i = x.length-1;\n for (; i>=0; --i)\n if (!ft(x[i], i, x)) break;\n return ++i;\n}\n\n\n/**\n * Scan from left, until a test passes.\n * @param x an array\n * @param ft test function (v, i, x)\n * @returns first index where test passes\n */\nexport function scanUntil<T>(x: T[], ft: TestFunction<T>): number {\n let i = -1;\n for (const v of x)\n if (ft(v, ++i, x)) return i;\n return ++i;\n}\n\n\n/**\n * Scan from right, until a test passes.\n * @param x an array\n * @param ft test function (v, i, x)\n * @returns first index where test fails till end\n */\nexport function scanUntilRight<T>(x: T[], ft: TestFunction<T>): number {\n let i = x.length-1;\n for (; i>=0; --i)\n if (ft(x[i], i, x)) break;\n return ++i;\n}\n// #endregion\n\n\n\n\n// #region SEARCH\n// --------------\n\n/**\n * Find first index of a value.\n * @param x an array\n * @param v search value\n * @param i begin index [0]\n * @returns index of v in x[i..] if found else -1\n */\nexport function indexOf<T>(x: T[], v: T, i: number=0): number {\n return x.indexOf(v, i);\n}\n\n\n/**\n * Find last index of a value.\n * @param x an array\n * @param v search value\n * @param i begin index [|x|-1]\n * @returns last index of v in x[0..i] if found else -1\n */\nexport function lastIndexOf<T>(x: T[], v: T, i: number=x.length-1): number {\n return x.lastIndexOf(v, i);\n}\n\n\n/**\n * Find index of first value passing a test.\n * @param x an array\n * @param ft test function (v, i, x)\n * @returns first index of value, -1 if not found\n */\nexport function search<T>(x: T[], ft: TestFunction<T>): number {\n return x.findIndex(ft);\n}\nexport {search as findIndex};\n\n\n/**\n * Find index of last value passing a test.\n * @param x an array\n * @param ft test function (v, i, x)\n * @returns last index of value, -1 if not found\n */\nexport function searchRight<T>(x: T[], ft: TestFunction<T>): number {\n for (let i=x.length-1; i>=0; --i)\n if (ft(x[i], i, x)) return i;\n return -1;\n}\nexport {searchRight as findLastIndex};\n\n\n/**\n * Find indices of values passing a test.\n * @param x an array\n * @param ft test function (v, i, x)\n * @returns indices of value\n */\nexport function searchAll<T>(x: T[], ft: TestFunction<T>): number[] {\n let i = -1;\n const a: number[] = [];\n for (const v of x)\n if (ft(v, ++i, x)) a.push(i);\n return a;\n}\n// #endregion\n\n\n\n\n// #region FUNCTIONAL\n// ------------------\n\n/**\n * Call a function for each value.\n * @param x an array\n * @param fp process function (v, i, x)\n */\nexport function forEach<T>(x: T[], fp: ProcessFunction<T>): void {\n x.forEach(fp);\n}\n\n\n/**\n * Examine if any value satisfies a test.\n * @param x an array\n * @param ft test function (v, i, x)\n * @returns true if ft(vᵢ) = true for some vᵢ ∈ x\n */\nexport function some<T>(x: T[], ft: TestFunction<T> | null=null): boolean {\n if (ft) return x.some(ft);\n else return someBoolean(x);\n}\nexport {some as anyOf};\n\nfunction someBoolean<T>(x: T[]): boolean {\n const I = x.length;\n for (let i=0; i<I; ++i)\n if (x[i]) return true;\n return false;\n}\n\n\n/**\n * Examine if all values satisfy a test.\n * @param x an array\n * @param ft test function (v, i, x)\n * @returns true if ft(vᵢ) = true for all vᵢ ∈ x\n */\nexport function every<T>(x: T[], ft: TestFunction<T> | null=null): boolean {\n if (ft) return x.every(ft);\n else return everyBoolean(x);\n}\nexport {every as allOf};\n\nfunction everyBoolean<T>(x: T[]): boolean {\n const I = x.length;\n for (let i=0; i<I; ++i)\n if (!x[i]) return false;\n return true;\n}\n\n\n/**\n * Transform values of an array.\n * @param x an array\n * @param fm map function (v, i, x)\n * @returns [fm(v₀), fm(v₁), ...] | vᵢ ∈ x\n */\nexport function map<T, U=T>(x: T[], fm: MapFunction<T, T|U>): (T|U)[] {\n return x.map(fm);\n}\n\n\n/**\n * Transform values of an array!\n * @param x an array (updated!)\n * @param fm map function (v, i, x)\n * @returns x = [fm(v₀), fm(v₁), ...]; vᵢ ∈ x\n */\nexport function map$<T>(x: T[], fm: MapFunction<T, T>): T[] {\n const I = x.length;\n for (let i=0; i<I; ++i)\n x[i] = fm(x[i], i, x);\n return x;\n}\n\n\n/**\n * Reduce values of array to a single value.\n * @param x an array\n * @param fr reduce function (acc, v, i, x)\n * @param acc initial value\n * @returns fr(fr(acc, v₀), v₁)... | fr(acc, v₀) = v₀ if acc not given\n */\nexport function reduce<T, U=T>(x: T[], fr: ReduceFunction<T, T|U>, acc?: T|U): T|U {\n const init = arguments.length <= 2;\n return init? x.reduce(fr as ReduceFunction<T, T>) : x.reduce(fr as ReduceFunction<T, T>, acc as T);\n}\n\n\n/**\n * Reduce values from right, to a single value.\n * @param x an array\n * @param fr reduce function (acc, v, i, x)\n * @param acc initial value\n * @returns fr(fr(acc, vₓ₋₀), vₓ₋₁)... | fr(acc, vₓ₋₀) = vₓ₋₀ if acc not given\n */\nexport function reduceRight<T, U=T>(x: T[], fr: ReduceFunction<T, T|U>, acc?: T|U): T|U {\n let init = arguments.length <= 2;\n for (let i=x.length-1; i>=0; --i) {\n if (init) { acc = x[i]; init = false; }\n else acc = fr(acc as T | U, x[i], i, x);\n }\n return acc as T | U;\n}\n\n\n/**\n * Keep values which pass a test.\n * @param x an array\n * @param ft test function (v, i, x)\n * @returns [v₀, v₁, ...] | ft(vᵢ) = true; vᵢ ∈ x\n */\nexport function filter<T>(x: T[], ft: TestFunction<T>): T[] {\n return x.filter(ft);\n}\nexport {filter as findAll};\n\n\n/**\n * Keep values which pass a test!\n * @param x an array (updated!)\n * @param ft test function (v, i, x)\n * @returns x = [v₀, v₁, ...] | ft(vᵢ) = true; vᵢ ∈ x\n */\nexport function filter$<T>(x: T[], ft: TestFunction<T>): T[] {\n const I = x.length;\n let j = 0;\n for (let i=0; i<I; ++i)\n if (ft(x[i], i, x)) x[j++] = x[i];\n x.length = j;\n return x;\n}\n\n\n/**\n * Keep values at given indices.\n * @param x an array\n * @param is indices\n * @returns v₀, v₁, ... | vᵢ = x[i]; i ∈ is\n */\nexport function filterAt<T>(x: T[], is: number[]): T[] {\n const X = x.length;\n const a: T[] = [];\n for (const i of is)\n if (i>=0 && i<X) a.push(x[i]);\n return a;\n}\n\n\n/**\n * Discard values which pass a test.\n * @param x an array\n * @param ft test function (v, i, x)\n * @returns [v₀, v₁, ...] | ft(vᵢ) = false; vᵢ ∈ x\n */\nexport function reject<T>(x: T[], ft: TestFunction<T>): T[] {\n let i = -1;\n const a: T[] = [];\n for (const v of x)\n if (!ft(v, ++i, x)) a.push(v);\n return a;\n}\n\n\n/**\n * Discard values which pass a test!\n * @param x an array (updated!)\n * @param ft test function (v, i, x)\n * @returns x = [v₀, v₁, ...] | ft(vᵢ) = false; vᵢ ∈ x\n */\nexport function reject$<T>(x: T[], ft: TestFunction<T>): T[] {\n const I = x.length;\n let j = 0;\n for (let i=0; i<I; ++i)\n if (!ft(x[i], i, x)) x[j++] = x[i];\n x.length = j;\n return x;\n}\n\n\n/**\n * Discard values at given indices.\n * @param x an array\n * @param is indices\n * @returns [v₀, v₁, ...] | vᵢ = x[i]; i ∉ is\n */\nexport function rejectAt<T>(x: T[], is: number[]): T[] {\n let i = -1;\n const a: T[] = [];\n for (const v of x)\n if (!is.includes(++i)) a.push(v);\n return a;\n}\n// #endregion\n\n\n\n\n// #region FLATTEN\n// ---------------\n\n/**\n * Flatten nested array to given depth.\n * @param x a nested array\n * @param n maximum depth [-1 ⇒ all]\n * @param fm map function (v, i, x)\n * @param ft flatten test function (v, i, x) [is]\n * @returns flat iterable\n */\nexport function flat(x: unknown[], n: number=-1, fm: MapFunction<unknown, unknown> | null=null, ft: TestFunction<unknown> | null=null): unknown[] {\n fm = fm || IDENTITY;\n ft = ft || is;\n return flatTo$([], x, n, fm, ft);\n}\n\nfunction flatTo$(a: unknown[], x: unknown[], n: number, fm: MapFunction<unknown, unknown>, ft: TestFunction<unknown>): unknown[] {\n let i = -1;\n for (const v of x) {\n const w = fm(v, ++i, x);\n if (n!==0 && ft(w, i, x)) flatTo$(a, v as unknown[], n-1, fm, ft);\n else a.push(w);\n }\n return a;\n}\n\n\n/**\n * Flatten nested array, based on map function.\n * @param x an array\n * @param fm map function (v, i, x)\n * @param ft flatten test function (v, i, x) [is]\n * @returns flat iterable\n */\nexport function flatMap(x: unknown[], fm: MapFunction<unknown, unknown> | null=null, ft: TestFunction<unknown> | null=null): unknown[] {\n fm = fm || IDENTITY;\n ft = ft || is;\n let i = -1;\n const a: unknown[] = [];\n for (const v of x) {\n const w = fm(v, ++i, x);\n if (ft(w, i, x)) concat$(a, w as Iterable<unknown>);\n else a.push(w);\n }\n return a;\n}\n// #endregion\n\n\n\n\n// #region PREFIX SUM\n// ------------------\n\n/**\n * Perform exclusive prefix scan from left to right.\n * @param x an array\n * @param fr reduce function (acc, v, i, x)\n * @param acc initial value\n * @returns [acc, fr(acc, v₀), fr(fr(acc, v₀), v₁)...]\n */\nexport function exclusiveScan<T, U=T>(x: T[], fr: ReduceFunction<T, T|U>, acc: T|U): (T|U)[] {\n const a: (T|U)[] = [];\n const I = x.length;\n for (let i=0; i<I; ++i) {\n a.push(acc);\n acc = fr(acc, x[i], i, x);\n }\n return a;\n}\n\n\n/**\n * Perform exclusive prefix scan from left to right!\n * @param x an array (updated!)\n * @param fr reduce function (acc, v, i, x)\n * @param acc initial value\n * @returns x = [acc, fr(acc, v₀), fr(fr(acc, v₀), v₁)...]\n */\nexport function exclusiveScan$<T>(x: T[], fr: ReduceFunction<T, T>, acc: T): T[] {\n const I = x.length;\n for (let i=0; i<I; ++i) {\n const v = x[i];\n x[i] = acc;\n acc = fr(acc, v, i, x);\n }\n return x;\n}\n\n\n/**\n * Perform inclusive prefix scan from left to right.\n * @param x an array\n * @param fr reduce function (acc, v, i, x)\n * @param acc initial value\n * @returns [fr(acc, v₀), fr(fr(acc, v₀), v₁)...]\n */\nexport function inclusiveScan<T, U=T>(x: T[], fr: ReduceFunction<T, T|U>, acc?: T|U): (T|U)[] {\n let init = arguments.length <= 2;\n const a: (T|U)[] = [];\n const I = x.length;\n for (let i=0; i<I; ++i) {\n acc = init? x[i] : fr(acc as T|U, x[i], i, x);\n a.push(acc);\n init = false;\n }\n return a;\n}\nexport {inclusiveScan as accumulate};\n\n\n/**\n * Perform inclusive prefix scan from left to right!\n * @param x an array (updated!)\n * @param fr reduce function (acc, v, i, x)\n * @param acc initial value\n * @returns x = [fr(acc, v₀), fr(fr(acc, v₀), v₁)...]\n */\nexport function inclusiveScan$<T>(x: T[], fr: ReduceFunction<T, T>, acc: T): T[] {\n const I = x.length;\n for (let i=0; i<I; ++i)\n acc = x[i] = fr(acc, x[i], i, x);\n return x;\n}\n\n\n/**\n * Combine adjacent values of an array.\n * @param x an array\n * @param fc combine function (u, v)\n * @param acc initial value\n * @returns [fc(acc, v₀), fc(v₀, v₁)...] | vᵢ ∈ x\n */\nexport function adjacentCombine<T>(x: T[], fc: CombineFunction<T>, acc: T): T[] {\n const a: T[] = [];\n if (x.length>0) a.push(fc(acc, x[0]));\n const I = x.length;\n for (let i=1; i<I; ++i)\n a.push(fc(x[i-1], x[i]));\n return a;\n}\n// adjacentMap()?\n\n\n/**\n * Combine adjacent values of an array!\n * @param x an array (updated!)\n * @param fc combine function (u, v)\n * @param acc initial value\n * @returns x = [fc(acc, v₀), fc(v₀, v₁)...] | vᵢ ∈ x\n */\nexport function adjacentCombine$<T>(x: T[], fc: CombineFunction<T>, acc: T): T[] {\n const X = x.length;\n if (X===0) return x;\n let v = x[0];\n x[0] = fc(acc, v);\n for (let i=1; i<X; ++i) {\n const w = x[i];\n x[i] = fc(v, w);\n v = w;\n }\n return x;\n}\n// #endregion\n\n\n\n\n// #region COMBINE\n// ---------------\n\n/**\n * Place a separator between every value.\n * @param x an array\n * @param v separator\n * @returns [x[0], v, x[1], v, ..., x[|x|-1]]\n */\nexport function intersperse<T>(x: T[], v: T): T[] {\n const a: T[] = []; let i = -1;\n for (const u of x) {\n if (++i>0) a.push(v);\n a.push(u);\n }\n return a;\n}\n\n\n/**\n * Estimate new values between existing ones.\n * @param x an array\n * @param fc combine function (a, b)\n * @returns [x[0], fc(x[0], x[1]), x[1], fc(x[1], x[2]), ..., x[|x|-1]]\n */\nexport function interpolate<T>(x: T[], fc: CombineFunction<T>): T[] {\n const a = [];\n let u: T = undefined as T;\n let i = -1;\n for (const v of x) {\n if (++i>0) a.push(fc(u, v));\n a.push(u = v);\n }\n return a;\n}\n\n\n/**\n * Place values of an array between another.\n * @param x an array\n * @param y another array\n * @param m number of values from x [1]\n * @param n number of values from y [1]\n * @param s step size for x [m]\n * @param t step size for y [n]\n * @returns x[0..m] ⧺ y[0..n] ⧺ x[s..s+m] ⧺ y[t..t+n] ⧺ ... ⧺ x[k*s..|x|-1] | k ∈ W\n */\nexport function intermix<T>(x: T[], y: T[], m: number=1, n: number=1, s: number=m, t: number=n): T[] {\n const X = x.length;\n const Y = y.length;\n const a: T[] = [];\n m = Math.max(m, 0);\n n = Math.max(n, 0);\n s = Math.max(s, 1);\n t = Math.max(t, 1);\n for (let i=0, j=0; i<X; i+=s) {\n if (i>0) {\n for (let k=j, K=k+n; k<K; ++k)\n a.push(y[k % Y]);\n j += t;\n }\n concat$(a, x.slice(i, i+m));\n }\n return a;\n}\n\n\n/**\n * Place values from iterables alternately.\n * @param xs arrays\n * @returns [x₀[0], x₁[0], ..., x₀[1], x₁[0], ...] | [x₀, x₁, ...] = xs\n */\nexport function interleave<T>(xs: T[][]): T[] {\n const a: T[] = [];\n for (let i=0;; ++i) {\n let n = 0;\n for (const x of xs)\n if (i<x.length) { a.push(x[i]); ++n; }\n if (n===0) break;\n }\n return a;\n}\n\n\n/**\n * Combine values from arrays.\n * @param xs arrays\n * @param fm map function (vs, i)\n * @param fe end function (dones) [some]\n * @param vd default value\n * @returns [fm([x₀[0], x₁[0], ...]), fm([x₀[1], x₁[1], ...]), ...]\n */\nexport function zip<T, U=T[]>(xs: T[][], fm: MapFunction<T[], T[]|U> | null=null, fe: EndFunction | null=null, vd?: T): (T[]|U)[] {\n fm = fm || IDENTITY;\n fe = fe || some as EndFunction;\n const X = xs.length, a: (T[]|U)[] = [];\n if (X===0) return a;\n const ds = new Array(X).fill(false);\n const ls = xs.map(x => x.length);\n for (let i=0;; ++i) {\n const vs: T[] = [];\n for (let j=0; j<X; ++j) {\n ds[j] = i>=ls[j];\n vs[j] = ds[j]? vd as T : xs[j][i];\n }\n if (fe(ds)) break;\n a.push(fm(vs, i, null));\n }\n return a;\n}\n\n\n// TODO: zip2()?\n// #endregion\n\n\n\n\n// #region MANIPULATION\n// --------------------\n\n/**\n * Fill with given value.\n * @param x an array\n * @param v value\n * @param i begin index [0]\n * @param I end index [|x|]\n * @returns x' | x' = x; x'[i..I] = v\n */\nexport function fill<T>(x: T[], v: T, i: number=0, I: number=x.length): T[] {\n return x.slice().fill(v, i, I);\n}\n\n\n/**\n * Fill with given value!\n * @param x an array (updated!)\n * @param v value\n * @param i begin index [0]\n * @param I end index [|x|]\n * @returns x | x[i..I] = v\n */\nexport function fill$<T>(x: T[], v: T, i: number=0, I: number=x.length): T[] {\n return x.fill(v, i, I);\n}\n\n\n/**\n * Add value to the end.\n * @param x an array\n * @param vs values to add\n * @returns x ⧺ vs\n */\nexport function push<T>(x: T[], ...vs: T[]): T[] {\n return x.concat(vs);\n}\nexport {push as pushBack};\nexport {push as append};\n\n\n/**\n * Add values to the end!\n * @param x an array (updated!)\n * @param vs values to add\n * @returns x = x ⧺ vs\n */\nexport function push$<T>(x: T[], ...vs: T[]): T[] {\n x.push(...vs);\n return x;\n}\nexport {push$ as pushBack$};\nexport {push$ as append$};\n\n\n/**\n * Remove last value.\n * @param x an array\n * @returns x[0..|x|-1]\n */\nexport function pop<T>(x: T[]): T[] {\n return x.slice(0, -1);\n}\nexport {pop as popBack};\n\n\n/**\n * Remove last value!\n * @param x an array (updated!)\n * @returns x = x[0..|x|-1]\n */\nexport function pop$<T>(x: T[]): T[] {\n x.pop();\n return x;\n}\nexport {pop as popBack$};\n\n\n/**\n * Remove first value.\n * @param x an array\n * @returns x[1..]\n */\nexport function shift<T>(x: T[]): T[] {\n return x.slice(1);\n}\nexport {shift as popFront};\n\n\n/**\n * Remove first value!\n * @param x an array (updated!)\n * @returns x = x[1..]\n */\nexport function shift$<T>(x: T[]): T[] {\n x.shift();\n return x;\n}\nexport {shift$ as popFront$};\n\n\n/**\n * Add values to the start.\n * @param x an array\n * @param vs values to add\n * @returns vs ⧺ x\n */\nexport function unshift<T>(x: Iterable<T>, ...vs: T[]): T[] {\n return concat$(vs, x);\n}\nexport {unshift as pushFront};\nexport {unshift as prepend};\n\n\n/**\n * Add values to the start!\n * @param x an array (updated!)\n * @param vs values to add\n * @returns x = vs ⧺ x\n */\nexport function unshift$<T>(x: T[], ...vs: T[]): T[] {\n x.unshift(...vs);\n return x;\n}\nexport {unshift$ as pushFront$};\nexport {unshift$ as prepend$};\n\n\n/**\n * Copy part of array to another.\n * @param x target array\n * @param y source array\n * @param j write index [0]\n * @param i read begin index [0]\n * @param I read end index [|x|]\n * @returns x[0..j] ⧺ y[i..I] ⧺ x[j+I-i..]\n */\nexport function copy<T>(x: T[], y: T[], j: number=0, i: number=0, I: number=y.length): T[] {\n return copy$(x.slice(), y, j, i, I);\n}\n\n\n/**\n * Copy part of array to another!\n * @param x target array (updated!)\n * @param y source array\n * @param j write index [0]\n * @param i read begin index [0]\n * @param I read end index [|x|]\n * @returns x = x[0..j] ⧺ y[i..I] ⧺ x[j+I-i..]\n */\nexport function copy$<T>(x: T[], y: T[], j: number=0, i: number=0, I: number=y.length): T[] {\n j = index(x, j);\n [i, I] = indexRange(y, i, I);\n for (; i<I; ++i, ++j)\n x[j] = y[i];\n return x;\n}\n\n\n/**\n * Copy part of array within.\n * @param x an array\n * @param j write index [0]\n * @param i read begin index [0]\n * @param I read end index [|x|]\n * @returns x[0..j] ⧺ x[i..I] ⧺ x[j+I-i..]\n */\nexport function copyWithin<T>(x: T[], j: number=0, i: number=0, I: number=x.length): T[] {\n return x.slice().copyWithin(j, i, I);\n}\n\n\n/**\n * Copy part of array within!\n * @param x an array (updated!)\n * @param j write index [0]\n * @param i read begin index [0]\n * @param I read end index [|x|]\n * @returns x = x[0..j] ⧺ x[i..I] ⧺ x[j+I-i..]\n */\nexport function copyWithin$<T>(x: T[], j: number=0, i: number=0, I: number=x.length): T[] {\n return x.copyWithin(j, i, I);\n}\n\n\n/**\n * Move part of array within.\n * @param x an array\n * @param j write index [0]\n * @param i read begin index [0]\n * @param I read end index [|x|]\n * @returns x[0..j] ⧺ x[i..I] ⧺ x[j..i] ⧺ x[I..]\n */\nexport function moveWithin<T>(x: T[], j: number=0, i: number=0, I: number=x.length): T[] {\n j = index(x, j);\n [i, I] = indexRange(x, i, I);\n if (j<i) return movePart(x, j, i, I);\n else return movePart(x, i, I, j);\n}\n\nfunction movePart<T>(x: T[], i: number, j: number, k: number): T[] {\n return x.slice(0, i).concat(\n x.slice(j, k),\n x.slice(i, j),\n x.slice(k)\n );\n}\n\n\n/**\n * Move part of array within!\n * @param x an array (updated!)\n * @param j write ±index [0]\n * @param i read begin ±index [0]\n * @param I read end ±index [|x|]\n * @returns x = x[0..j] ⧺ x[i..I] ⧺ x[j..i] ⧺ x[I..]\n */\nexport function moveWithin$<T>(x: T[], j: number=0, i: number=0, I: number=x.length): T[] {\n j = index(x, j);\n [i, I] = indexRange(x, i, I);\n const p = x.slice(i, I), P = p.length;\n if (j<i) x.copyWithin(j+P, j, i);\n else x.copyWithin(i, I, j);\n return copy$(x, p, j<i? j : j-P);\n}\n// DOUBT: Are negative indices any helpful (other than basic shortcuts)?\n// DOUBT: It is not easy to use a negative index supporting function from another negative index supporting function.\n// DOUBT: Seems to me they are only complicating implementation of algorithms, and should be removed.\n\n\n/**\n * Remove or replace existing values.\n * @param x an array\n * @param i remove ±index\n * @param n number of values to remove [rest]\n * @param vs values to insert\n * @returns x[0..i] ⧺ vs ⧺ x[i+n..]\n */\nexport function splice<T>(x: T[], i: number, n: number=x.length, ...vs: T[]): T[] {\n i = index(x, i);\n n = Math.max(n, 0);\n return concat$(x.slice(0, i), vs, x.slice(i+n));\n}\nexport {splice as toSpliced};\n\n\n/**\n * Remove or replace existing values!\n * @param x an array (updated!)\n * @param i remove ±index\n * @param n number of values to remove [rest]\n * @param vs values to insert\n * @returns x = x[0..i] ⧺ vs ⧺ x[i+n..]\n */\nexport function splice$<T>(x: T[], i: number, n: number=x.length, ...vs: T[]): T[] {\n x.splice(i, n, ...vs);\n return x;\n}\n// #endregion\n\n\n\n\n// #region COUNT/PARTITION\n// -----------------------\n\n/**\n * Count values which satisfy a test.\n * @param x an array\n * @param ft test function (v, i, x)\n * @returns Σtᵢ | tᵢ = 1 if ft(vᵢ) else 0; vᵢ ∈ x\n */\nexport function count<T>(x: T[], ft: TestFunction<T>): number {\n let i = -1, a = 0;\n for (const v of x)\n if (ft(v, ++i, x)) ++a;\n return a;\n}\n\n\n/**\n * Count occurrences of each distinct value.\n * @param x an array\n * @param fm map function (v, i, x)\n * @returns Map \\{value ⇒ count\\}\n */\nexport function countEach<T, U=T>(x: T[], fm: MapFunction<T, T|U> | null=null): Map<T|U, number> {\n fm = fm || IDENTITY;\n let i = -1; const a = new Map();\n for (const v of x) {\n const w = fm(v, ++i, x);\n a.set(w, (a.get(w) || 0) + 1);\n }\n return a;\n}\nexport {countEach as countAs}; // DEPRECATED\n\n\n/**\n * Segregate values by test result.\n * @param x an array\n * @param ft test function (v, i, x)\n * @returns [satisfies, doesnt]\n */\nexport function partition<T>(x: T[], ft: TestFunction<T>): [T[], T[]] {\n const t: T[] = [], f: T[] = [];\n let i = -1;\n for (const v of x) {\n if (ft(v, ++i, x)) t.push(v);\n else f.push(v);\n }\n return [t, f];\n}\n\n\n/**\n * Segregate each distinct value.\n * @param x an array\n * @param fm map function (v, i, x)\n * @returns Map \\{key ⇒ values\\}\n */\nexport function partitionEach<T, U=T>(x: T[], fm: MapFunction<T, T|U> | null=null): Map<T|U, T[]> {\n fm = fm || IDENTITY;\n let i = -1; const a = new Map<T|U, T[]>();\n for (const v of x) {\n const w = fm(v, ++i, x);\n if (!a.has(w)) a.set(w, []);\n a.get(w)!.push(v);\n }\n return a;\n}\nexport {partitionEach as groupToMap};\nexport {partitionEach as partitionAs}; // DEPRECATED\n// #endregion\n\n\n\n\n// #region SPLITS\n// --------------\n\n/**\n * Break array considering test as separator.\n * @param x an array\n * @param ft test function (v, i, x)\n * @returns [x[j..k], x[l..m], ...] | ft(x[i]) = true; i = 0..j / k..l / ...\n */\nexport function split<T>(x: T[], ft: TestFunction<T>): T[][] {\n let i = -1;\n const a: T[][] = [];\n let b: T[] = [];\n for (const v of x) {\n if (!ft(v, ++i, x)) b.push(v);\n else if (b.length) { a.push(b); b = []; }\n }\n if (b.length) a.push(b);\n return a;\n}\n\n\n/**\n * Break array considering indices as separator.\n * @param x an array\n * @param is indices (sorted)\n * @returns [x[j..k], x[l..m], ...] | ft(x[i]) = true; i = 0..j / k..l / ...; i ∈ is\n */\nexport function splitAt<T>(x: T[], is: number[]): T[][] {\n let i = -1;\n const a: T[][] = [];\n let b: T[] = [];\n for (const v of x) {\n if (!is.includes(++i)) b.push(v);\n else if(b.length) { a.push(b); b = []; }\n }\n if (b.length) a.push(b);\n return a;\n}\n\n\n/**\n * Break array when test passes.\n * @param x an array\n * @param ft test function (v, i, x)\n * @returns [x[0..j], x[j..k], ...] | ft(x[i]) = true; i = j, k, ...\n */\nexport function cut<T>(x: T[], ft: TestFunction<T>): T[][] {\n let j = 0; const a = [];\n const I = x.length;\n for (let i=0; i<I; ++i) {\n if (!ft(x[i], i, x)) continue;\n a.push(x.slice(j, i));\n j = i;\n }\n a.push(x.slice(j));\n return a;\n}\n\n\n/**\n * Break array after test passes.\n * @param x an array\n * @param ft test function (v, i, x)\n * @returns [x[0..j+1], x[j+1..k], ...] | ft(x[i]) = true; i = j, k, ...\n */\nexport function cutRight<T>(x: T[], ft: TestFunction<T>): T[][] {\n let j = 0; const a = [];\n const I = x.length;\n for (let i=0; i<I; ++i) {\n if (!ft(x[i], i, x)) continue;\n a.push(x.slice(j, i+1));\n j = i+1;\n }\n a.push(x.slice(j));\n return a;\n}\n\n\n/**\n * Break array at given indices.\n * @param x an array\n * @param is split ±indices (left to right)\n * @returns [x[0..j], x[j..k], ...] | ft(x[i]) = true; i = j, k, ...; i ∈ is\n */\nexport function cutAt<T>(x: T[], is: number[]): T[][] {\n const X = x.length;\n let j = 0; const a = [];\n for (let i of is) {\n i = i<0? X+i : i;\n a.push(x.slice(j, i));\n j = Math.max(j, i);\n }\n a.push(x.slice(j));\n return a;\n}\n\n\n/**\n * Break array after given indices.\n * @param x an array\n * @param is split ±indices (left to right)\n * @returns [x[0..j+1], x[j+1..k], ...] | ft(x[i]) = true; i = j, k, ...; i ∈ is\n */\nexport function cutAtRight<T>(x: T[], is: number[]): T[][] {\n const X = x.length;\n let j = 0; const a = [];\n for (let i of is) {\n i = i<0? X+i : i;\n a.push(x.slice(j, i+1));\n j = Math.max(j, i+1);\n }\n a.push(x.slice(j));\n return a;\n}\n\n\n/**\n * Keep similar values together and in order.\n * @param x an array\n * @param fc compare function (a, b)\n * @param fm map function (v, i, x)\n * @returns [x[0..k], x[k..l], ...] | fc(x[i], x[j]) = 0; i, j = 0..k / k..l / ...\n */\nexport function group<T, U=T>(x: T[], fc: CompareFunction<T|U> | null=null, fm: MapFunction<T, T|U> | null=null): T[][] {\n fc = fc || COMPARE;\n fm = fm || IDENTITY;\n const a: T[][] = [];\n let b: T[] = [];\n let u: T|U = undefined as T, i = -1;\n for (const v of x) {\n const w = fm(v, ++i, x);\n if (i===0 || fc(u, w)===0) b.push(v);\n else { a.push(b); b = [v]; }\n u = w;\n }\n a.push(b);\n return a;\n}\n\n\n/**\n * Break array into chunks of given size.\n * @param x an array\n * @param n chunk size [1]\n * @param s chunk step [n]\n * @returns x[0..n] ⧺ x[s..s+n] ⧺ x[2s..2s+n] ⧺ ...\n */\nexport function chunk<T>(x: T[], n: number=1, s: number=n): T[][] {\n const a: T[][] = [];\n if (n<0) return a;\n s = Math.max(s, 1);\n const I = x.length;\n for (let i=0; i<I; i+=s)\n a.push(x.slice(i, i+n));\n return a;\n}\n// #endregion\n\n\n\n\n// #region CONCAT/JOIN\n// -------------------\n\n/**\n * Append values from arrays.\n * @param xs arrays\n * @returns x₀ ⧺ x₁ ⧺ ... | [x₀, x₁, ...] = xs\n */\nexport function concat<T>(...xs: T[][]): T[] {\n return ([] as T[]).concat(...xs);\n}\n\n\n/**\n * Append values from arrays!\n * @param x an array (updated!)\n * @param ys arrays to append\n * @returns x = x ⧺ y₀ ⧺ y₁ ⧺ ...] | [y₀, y₁, ...] = ys\n */\nexport function concat$<T>(x: T[], ...ys: Iterable<T>[]): T[] {\n for (const y of ys)\n x.push(...y);\n return x;\n}\n\n\n/**\n * Join values together into a string.\n * @param x an array\n * @param sep separator [,]\n * @returns \"$\\{v₀\\}$\\{sep\\}$\\{v₁\\}...\" | vᵢ ∈ x\n */\nexport function join<T>(x: T[], sep: string=\",\"): string {\n return x.join(sep);\n}\n// #endregion\n\n\n\n\n// #region REARRANGE\n// -----------------\n\n/**\n * Obtain values that cycle through array.\n * @param x an array\n * @param i begin ±index [0]\n * @param n number of values [|x|]\n */\nexport function cycle<T>(x: T[], i: number=0, n: number=x.length): T[] {\n const X = x.length;\n if (n<=0 || X===0) return [];\n i = mod(i, X);\n const a = x.slice(i, i+n);\n n -= a.length;\n const M = Math.floor(n/X);\n for (let m=0; m<M; ++m)\n concat$(a, x);\n return concat$(a, x.slice(0, n % X));\n}\n\n\n/**\n * Repeat an array given times.\n * @param x an array\n * @param n times [1]\n * @returns x ⧺ x ⧺ ...(n times)\n */\nexport function repeat<T>(x: T[], n: number=1): T[] {\n const a: T[] = [];\n for (; n>0; --n)\n concat$(a, x);\n return a;\n}\n\n\n/**\n * Reverse the values.\n * @param x an array\n * @returns [x[|x|-1], x[|x|-2], ..., x[1], x[0]]\n */\nexport function reverse<T>(x: T[]): T[] {\n return x.slice().reverse();\n}\nexport {reverse as toReversed};\n\n\n/**\n * Reverse the values!\n * @param x an array (updated!)\n * @returns x = [x[|x|-1], x[|x|-2], ..., x[1], x[0]]\n */\nexport function reverse$<T>(x: T[]): T[] {\n return x.reverse();\n}\n\n\n/**\n * Rotate values in array.\n * @param x an array\n * @param n rotate amount (+ve: left, -ve: right) [0]\n * @returns x[n..] ⧺ x[0..n]\n */\nexport function rotate<T>(x: T[], n: number=0): T[] {\n n = mod(n, x.length);\n return concat$(x.slice(n), x.slice(0, n));\n}\n\n\n/**\n * Rotate values in array!\n * @param x an array (updated!)\n * @param n rotate amount (+ve: left, -ve: right) [0]\n * @returns x = x[n..] ⧺ x[0..n]\n */\nexport function rotate$<T>(x: T[], n: number=0): T[] {\n n = mod(n, x.length);\n const y = x.slice(0, n);\n x.copyWithin(0, n);\n return copy$(x, y, x.length-n);\n}\n// #endregion\n\n\n\n\n// #region SET OPERATIONS\n// ------------------------\n\n/**\n * Examine if there are no duplicate values.\n * @param x an array\n * @param fc compare function (a, b)\n * @param fm map function (v, i, x)\n * @returns ∀ vᵢ, vⱼ ∈ x, is vᵢ ≠ vⱼ?\n */\nexport function isUnique<T, U=T>(x: T[], fc: CompareFunction<T|U> | null=null, fm: MapFunction<T, T|U> | null=null): boolean {\n if (fc) return isUniqueDual(x, fc, fm);\n else return isUniqueMap (x, fm);\n}\n\nfunction isUniqueMap<T, U=T>(x: T[], fm: MapFunction<T, T|U> | null=null): boolean {\n fm = fm || IDENTITY;\n const s = new Set(); let i = -1;\n for (const v of x) {\n const w = fm(v, ++i, x);\n if (s.has(w)) return false;\n s.add(w);\n }\n return true;\n}\n\nfunction isUniqueDual<T, U=T>(x: T[], fc: CompareFunction<T|U> | null=null, fm: MapFunction<T, T|U> | null=null): boolean {\n fc = fc || COMPARE;\n fm = fm || IDENTITY;\n const x1 = [...x].map(fm);\n for (const wx of x1) {\n for (const wy of x1)\n if (fc(wx, wy)===0) return false;\n }\n return true;\n}\n\n\n/**\n * Examine if arrays have no value in common.\n * @param x an array\n * @param y another array\n * @param fc compare function (a, b)\n * @param fm map function (v, i, x)\n * @returns x ∩ y = Φ?\n */\nexport function isDisjoint<T, U=T>(x: T[], y: T[], fc: CompareFunction<T|U> | null=null, fm: MapFunction<T, T|U> | null=null): boolean {\n if (fc) return isDisjointDual(x, y, fc, fm);\n else return isDisjointMap (x, y, fm);\n}\n\nfunction isDisjointMap<T, U=T>(x: T[], y: T[], fm: MapFunction<T, T|U> | null=null): boolean {\n fm = fm || IDENTITY;\n const s = toSet(y, fm); let i = -1;\n for (const v of x) {\n const w = fm(v, ++i, x);\n if (s.has(w)) return false;\n }\n return true;\n}\n\nfunction isDisjointDual<T, U=T>(x: T[], y: T[], fc: CompareFunction<T|U> | null=null, fm: MapFunction<T, T|U> | null=null): boolean {\n fc = fc || COMPARE;\n fm = fm || IDENTITY;\n const y1 = [...y].map(fm); let i = -1;\n for (const vx of x) {\n const wx = fm(vx, ++i, x);\n for (const wy of y1)\n if (fc(wx, wy)===0) return false;\n }\n return true;\n}\n\n\n/**\n * Remove duplicate values.\n * @param x an array\n * @param fc compare function (a, b)\n * @param fm map function (v, i, x)\n * @returns v₀, v₁, ... | vᵢ ∈ x; vᵢ ≠ vⱼ ∀ i, j\n */\nexport function unique<T, U=T>(x: T[], fc: CompareFunction<T|U> | null=null, fm: MapFunction<T, T|U> | null=null): T[] {\n if (fc) return uniqueDual(x, fc, fm);\n else return uniqueMap (x, fm);\n}\n\nfunction uniqueMap<T, U=T>(x: T[], fm: MapFunction<T, T|U> | null=null): T[] {\n fm = fm || IDENTITY;\n const s = new Set();\n let i = -1; const a = [];\n for (const v of x) {\n const w = fm(v, ++i, x);\n if (s.has(w)) continue;\n s.add(w); a.push(v);\n }\n return a;\n}\n\nfunction uniqueDual<T, U=T>(x: T[], fc: CompareFunction<T|U> | null=null, fm: MapFunction<T, T|U> | null=null): T[] {\n fc = fc || COMPARE;\n fm = fm || IDENTITY;\n let i = -1; const s = [], a = [];\n x: for (const vx of x) {\n const wx = fm(vx, ++i, x);\n for (const ws of s)\n if (fc(ws, wx)===0) continue x;\n s.push(wx); a.push(vx);\n }\n return a;\n}\n\n\n/**\n * Obtain values present in any array.\n * @param x an array\n * @param y another array\n * @param fc compare function (a, b)\n * @param fm map function (v, i, x)\n * @returns x ∪ y = \\{v | v ∈ x or v ∈ y\\}\n */\nexport function union<T, U=T>(x: T[], y: T[], fc: CompareFunction<T|U> | null=null, fm: MapFunction<T, T|U> | null=null): T[] {\n return union$(x.slice(), y, fc, fm);\n}\n\n\n/**\n * Obtain values present in any array!\n * @param x an array (updated!)\n * @param y another array\n * @param fc compare function (a, b)\n * @param fm map function (v, i, x)\n * @returns x = x ∪ y = \\{v | v ∈ x or v ∈ y\\}\n */\nexport function union$<T, U=T>(x: T[], y: T[], fc: CompareFunction<T|U> | null=null, fm: MapFunction<T, T|U> | null=null): T[] {\n if (fc) return unionDual$(x, y, fc, fm);\n else return unionMap$ (x, y, fm);\n}\n\nfunction unionMap$<T, U=T>(x: T[], y: T[], fm: MapFunction<T, T|U> | null=null): T[] {\n fm = fm || IDENTITY;\n const s = toSet(x, fm); let i = -1;\n for (const vy of y) {\n const wy = fm(vy, ++i, y);\n if (!s.has(wy)) x.push(vy);\n }\n return x;\n}\n\nfunction unionDual$<T, U=T>(x: T[], y: T[], fc: CompareFunction<T|U> | null=null, fm: MapFunction<T, T|U> | null=null): T[] {\n fc = fc || COMPARE;\n fm = fm || IDENTITY;\n const x1 = x.map(fm); let i = -1;\n y: for (const vy of y) {\n const wy = fm(vy, ++i, y);\n for (const wx of x1)\n if (fc(wx, wy)===0) continue y;\n x.push(vy);\n }\n return x;\n}\n\n\n/**\n * Obtain values present in both arrays.\n * @param x an array\n * @param y another array\n * @param fc compare function (a, b)\n * @param fm map function (v, i, x)\n * @returns x ∩ y = \\{v | v ∈ x, v ∈ y\\}\n */\nexport function intersection<T, U=T>(x: T[], y: T[], fc: CompareFunction<T|U> | null=null, fm: MapFunction<T, T|U> | null=null): T[] {\n if (fc) return intersectionDual(x, y, fc, fm);\n else return intersectionMap (x, y, fm);\n}\n\nfunction intersectionMap<T, U=T>(x: T[], y: T[], fm: MapFunction<T, T|U> | null=null): T[] {\n fm = fm || IDENTITY;\n const s = toSet(y, fm);\n let i = -1; const a = [];\n for (const vx of x) {\n const wx = fm(vx, ++i, x);\n if (s.has(wx)) a.push(vx);\n }\n return a;\n}\n\nfunction intersectionDual<T, U=T>(x: T[], y: T[], fc: CompareFunction<T|U> | null=null, fm: MapFunction<T, T|U> | null=null): T[] {\n fc = fc || COMPARE;\n fm = fm || IDENTITY;\n const y1 = [...y].map(fm);\n let i = -1; const a = [];\n x: for (const vx of x) {\n const wx = fm(vx, ++i, x);\n for (const wy of y1)\n if (fc(wx, wy)===0) { a.push(vx); continue x; }\n }\n return a;\n}\n\n\n/**\n * Obtain values not present in another array.\n * @param x an array\n * @param y another array\n * @param fc compare function (a, b)\n * @param fm map function (v, i, x)\n * @returns x - y = \\{v | v ∈ x, v ∉ y\\}\n */\nexport function difference<T, U=T>(x: T[], y: T[], fc: CompareFunction<T|U> | null=null, fm: MapFunction<T, T|U> | null=null): T[] {\n if (fc) return differenceDual(x, y, fc, fm);\n else return differenceMap (x, y, fm);\n}\n\nfunction differenceMap<T, U=T>(x: T[], y: T[], fm: MapFunction<T, T|U> | null=null): T[] {\n fm = fm || IDENTITY;\n const s = toSet(y, fm);\n let i = -1; const a = [];\n for (const vx of x) {\n const wx = fm(vx, ++i, x);\n if (!s.has(wx)) a.push(vx);\n }\n return a;\n}\n\nfunction differenceDual<T, U=T>(x: T[], y: T[], fc: CompareFunction<T|U> | null=null, fm: MapFunction<T, T|U> | null=null): T[] {\n fc = fc || COMPARE;\n fm = fm || IDENTITY;\n const y1 = [...y].map(fm);\n let i = -1; const a = [];\n x: for (const vx of x) {\n const wx = fm(vx, ++i, x);\n for (const wy of y1)\n if (fc(wx, wy)===0) continue x;\n a.push(vx);\n }\n return a;\n}\n\n\n/**\n * Obtain values not present in both arrays.\n * @param x an array\n * @param y another array\n * @param fc compare function (a, b)\n * @param fm map function (v, i, x)\n * @returns x-y ∪ y-x\n */\nexport function symmetricDifference<T, U=T>(x: T[], y: T[], fc: CompareFunction<T|U> | null=null, fm: MapFunction<T, T|U> | null=null): T[] {\n const x0 = fromIterable$(x);\n const y0 = fromIterable$(y);\n const ax = difference(x0, y0, fc, fm);\n const ay = difference(y0, x0, fc, fm);\n return concat$(ax, ay);\n}\n\n\n/**\n * Obtain cartesian product of arrays.\n * @param xs arrays\n * @param fm map function (vs, i)\n * @returns x₀ × x₁ × ... = \\{[v₀, v₁, ...] | v₀ ∈ x₀, v₁ ∈ x₁, ...] \\}\n */\nexport function cartesianProduct<T, U=T>(xs: T[][], fm: MapFunction<T[], T[]|U> | null=null): (T[]|U)[] {\n fm = fm || IDENTITY;\n const XS = xs.length;\n const a: (T[]|U)[] = [];\n if (XS===0) return a;\n const is = new Array(XS).fill(0);\n const ls = xs.map(x => x.length);\n if (ls.some(l => l===0)) return a;\n for (let i=0;; ++i) {\n const vs: T[] = [];\n for (let j=0; j<XS; ++j)\n vs.push(xs[j][is[j]]);\n a.push(fm(vs, i, null));\n let r = XS-1;\n for (; r>=0; --r) {\n if (++is[r]<ls[r]) break;\n is[r] = 0;\n }\n if (r<0) break;\n }\n return a;\n}\n// #endregion\n// #endregion\n"],
5
+ "mappings": "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",
6
+ "names": ["IDENTITY", "v", "COMPARE", "a", "b", "TAU", "mod", "x", "y", "toSet", "x", "fm", "a", "i", "v", "fromRange", "V", "dv", "n", "fromInvocation", "fn", "fromApplication", "fm", "v", "n", "a", "i", "fromIterable", "x", "fromIterable$", "x", "shallowClone", "x", "deepClone", "x", "is", "v", "keys", "ikeys", "values", "ivalues", "entries", "ientries", "index", "i", "X", "indexRange", "I", "isEmpty", "length", "resize$", "x", "vd", "X", "clear$", "get", "i", "index", "getAll", "x", "is", "i", "get", "getPath", "p", "a", "hasPath", "set", "v", "set$", "set$", "x", "i", "v", "index", "setPath$", "p", "y", "getPath", "is", "last", "swap", "j", "swap$", "t", "swapRaw$", "swapRanges", "I", "J", "indexRange", "swapRanges$", "remove", "remove$", "removePath$", "isSorted", "fc", "fm", "searchUnsortedValue", "hasUnsortedValue", "COMPARE", "IDENTITY", "X", "w0", "w", "sort", "fs", "sort$", "sort$", "x", "fc", "fm", "fs", "COMPARE", "X", "IDENTITY", "swapRaw$", "rangedPartialIntroSort$", "rangedSort", "i", "I", "rangedSort$", "indexRange", "partialSort", "partialSort$", "rangedPartialSort$", "rangedPartialSort", "n", "d", "rangedPartialIntroSortDo$", "s", "rangedPartialInsertionSort$", "rangedPartialHeapSort$", "p", "rangedQuickSortPartition$", "rangedQuickSortPartition$", "x", "i", "I", "p", "fc", "fm", "fs", "wp", "j", "k", "wk", "rangedPartialHeapSort$", "n", "rangedBuildReverseMinHeap$", "r", "rangedReverseMinHeapify$", "s", "lt", "rt", "rangedBuildMaxHeap$", "rangedMaxHeapify$", "rangedPartialInsertionSort$", "swapRaw$", "rangedPartialInsertionSortSwapless$", "rangedPartialInsertionSortSwap$", "_n", "key", "wkey", "_fs", "minimum", "x", "fc", "fm", "i", "searchMinimumValue", "minimumEntry", "x", "fc", "fm", "i", "searchMinimumValue", "maximum", "x", "fc", "fm", "i", "searchMaximumValue", "maximumEntry", "x", "fc", "fm", "i", "searchMaximumValue", "range", "x", "fc", "fm", "a", "b", "rangeEntries", "COMPARE", "IDENTITY", "X", "v", "w", "mi", "mv", "mw", "ni", "nv", "nw", "i", "minimums", "searchMinimumValues", "minimumEntries", "maximums", "searchMaximumValues", "maximumEntries", "searchMinimumValue", "searchMaximumValue", "IH", "ih", "fromRange", "rangedBuildMaxHeap$", "swapRaw$", "wr", "rangedMaxHeapify$", "j", "isEqual", "y", "Y", "compare", "I", "wx", "wy", "c", "head", "vd", "tail", "x", "init", "last", "vd", "middle", "x", "i", "n", "index", "slice", "I", "slice$", "length", "includes", "v", "hasValue", "fc", "fm", "searchValue", "COMPARE", "IDENTITY", "w", "vx", "wx", "searchValueRight", "searchValueAll", "a", "searchAdjacentDuplicateValue", "X", "w0", "searchMismatchedValue", "x", "y", "fc", "fm", "COMPARE", "IDENTITY", "X", "Y", "I", "i", "wx", "wy", "hasPrefix", "x", "y", "fc", "fm", "Y", "compare", "hasSuffix", "x", "y", "fc", "fm", "Y", "compare", "hasInfix", "x", "y", "fc", "fm", "searchInfix", "hasSubsequence", "searchSubsequence", "hasPermutation", "x1", "y1", "prefixes", "iprefixes", "X", "i", "suffixes", "isuffixes", "infixes", "iinfixes", "infixesFixed", "infixesAll", "I", "j", "subsequences", "isubsequences", "s", "permutations", "ipermutations", "ipermutationsFixed", "splice", "p", "COMPARE", "IDENTITY", "Y", "isInfixAt", "searchInfixRight", "searchInfixAll", "a", "wx", "wy", "vx", "randomValue", "fr", "randomPrefix", "x", "fr", "X", "randomSuffix", "x", "fr", "X", "randomInfix", "x", "fr", "X", "randomInfixLength", "i", "randomInfixLength", "X", "r", "C", "n", "randomSubsequence", "x", "fr", "randomSubsequenceFixed", "randomSubsequenceAll", "randomSubsequenceFixed", "x", "fr", "is", "fromRange", "randomPermutation$", "getAll", "randomSubsequenceAll", "a", "v", "randomPermutation", "X", "randomPermutation$", "x", "fr", "X", "i", "j", "t", "find", "x", "ft", "findRight", "i", "take", "takeRight", "x", "X", "takeWhile", "x", "ft", "scanWhile", "takeWhileRight", "scanWhileRight", "drop", "dropRight", "X", "dropWhile", "dropWhileRight", "i", "v", "scanUntil", "scanUntilRight", "indexOf", "lastIndexOf", "search", "searchRight", "x", "ft", "i", "searchAll", "x", "ft", "i", "a", "v", "forEach", "fp", "some", "someBoolean", "someBoolean", "x", "I", "i", "every", "ft", "everyBoolean", "everyBoolean", "x", "I", "i", "map", "fm", "map$", "reduce", "fr", "acc", "reduceRight", "init", "filter", "ft", "filter$", "x", "ft", "I", "j", "i", "filterAt", "is", "X", "a", "reject", "v", "reject$", "rejectAt", "flat", "fm", "IDENTITY", "flatTo$", "n", "w", "flatMap", "concat$", "exclusiveScan", "fr", "acc", "exclusiveScan$", "inclusiveScan", "init", "inclusiveScan$", "x", "fr", "acc", "I", "i", "adjacentCombine", "fc", "a", "adjacentCombine$", "X", "v", "w", "intersperse", "u", "interpolate", "intermix", "y", "m", "n", "s", "t", "Y", "j", "k", "K", "concat$", "interleave", "xs", "zip", "fm", "fe", "vd", "IDENTITY", "some", "ds", "ls", "vs", "fill", "fill$", "push", "push$", "x", "vs", "pop", "x", "pop$", "x", "shift", "x", "shift$", "x", "unshift", "x", "vs", "concat$", "unshift$", "x", "vs", "copy", "x", "y", "j", "i", "I", "copy$", "index", "indexRange", "copyWithin", "copyWithin$", "moveWithin", "movePart", "k", "moveWithin$", "p", "P", "splice", "n", "vs", "concat$", "splice$", "x", "i", "n", "vs", "count", "ft", "a", "v", "countEach", "fm", "IDENTITY", "w", "partition", "x", "ft", "t", "f", "i", "v", "partitionEach", "fm", "IDENTITY", "a", "w", "split", "x", "ft", "i", "a", "b", "v", "splitAt", "is", "cut", "j", "I", "cutRight", "cutAt", "X", "cutAtRight", "group", "fc", "fm", "COMPARE", "IDENTITY", "w", "chunk", "s", "concat", "xs", "concat$", "ys", "y", "join", "sep", "cycle", "n", "mod", "M", "m", "repeat", "reverse", "reverse$", "x", "rotate", "mod", "concat$", "rotate$", "y", "copy$", "isUnique", "fc", "fm", "isUniqueDual", "isUniqueMap", "IDENTITY", "s", "i", "v", "w", "COMPARE", "x1", "wx", "wy", "isDisjoint", "isDisjointDual", "isDisjointMap", "toSet", "y1", "vx", "unique", "uniqueDual", "uniqueMap", "a", "ws", "union", "union$", "unionDual$", "unionMap$", "vy", "intersection", "intersectionDual", "intersectionMap", "difference", "differenceDual", "differenceMap", "symmetricDifference", "x0", "fromIterable$", "y0", "ax", "ay", "cartesianProduct", "xs", "XS", "is", "ls", "l", "vs", "j", "r"]
7
+ }