New Case Study:See how Anthropic automated 95% of dependency reviews with Socket.Learn More →
Socket
Sign inDemoInstall
Socket
Sign inDemoInstall

extra-lists

Package Overview
Dependencies
Maintainers
1
Versions
150
Alerts
File Explorer

Advanced tools

License
Socket logo

Install Socket

Detect and block malicious and high-risk dependencies

Install

extra-lists - npm Package Compare versions

Comparing version 2.2.10 to 3.0.5

1519

index.d.ts

@@ -1,417 +0,154 @@

declare module "extra-lists" {
export type tillFn = (dones: boolean[]) => boolean;
export type reduceFn<T, U, V> = (acc: V, v: U, k: T, x: Lists<T, U>) => V;
export type calledFn<T, U> = (v: U, k: T, x: Lists<T, U>) => void;
export type testFn<T, U> = (v: U, k: T, x: Lists<T, U>) => boolean;
export type mapFn<T, U, V> = (v: U, k: T, x: Lists<T, U>) => V;
export type combineFn<T> = (a: T, b: T) => T;
export type compareFn<T> = (a: T, b: T) => number;
export type Entries<T, U> = Iterable<[
T,
U
]>;
export type Lists<T, U> = [
Iterable<T>,
Iterable<U>
];
/**
* Lists cartesian product of lists.
* [📘](https://github.com/nodef/extra-lists/wiki/cartesianProduct)
* @param xs lists
* @param fm map function (vs, i)
* @example
* ```javascript
* var x = [['a', 'b', 'c'], [1, 2, 3]];
* var y = [['d', 'e'], [10, 20]];
* [...cartesianProduct([x, y])].map(a => [[...a[0]], [...a[1]]]);
* // [
* // [ [ 'a', 'd' ], [ 1, 10 ] ],
* // [ [ 'a', 'e' ], [ 1, 20 ] ],
* // [ [ 'b', 'd' ], [ 2, 10 ] ],
* // [ [ 'b', 'e' ], [ 2, 20 ] ],
* // [ [ 'c', 'd' ], [ 3, 10 ] ],
* // [ [ 'c', 'e' ], [ 3, 20 ] ]
* // ]
*
* [...cartesianProduct([x, y], a => max(a))];
* // [
* // [ 'd', 10 ],
* // [ 'e', 20 ],
* // [ 'd', 10 ],
* // [ 'e', 20 ],
* // [ 'd', 10 ],
* // [ 'e', 20 ]
* // ]
* ```
* Entries is a list of key-value pairs, with unique keys.
* [📘](https://github.com/nodef/extra-lists/wiki/Entries)
*/
export function cartesianProduct<T, U, V = U>(xs: Lists<T, U>[], fm?: mapFn<number, Lists<T, U>, Lists<T, U> | V>): Iterable<Lists<T, U> | V>;
declare type Entries<K, V> = Iterable<[K, V]>;
/**
* Breaks lists into chunks of given size.
* [📘](https://github.com/nodef/extra-lists/wiki/chunk)
* @param x lists
* @param n chunk size (1)
* @param s chunk step (n)
* @example
* ```javascript
* var x = [
* ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h'],
* [1, 2, 3, 4, 5, 6, 7, 8]
* ];
* chunk(x, 3);
* // [
* // [ [ 'a', 'b', 'c' ], [ 1, 2, 3 ] ],
* // [ [ 'd', 'e', 'f' ], [ 4, 5, 6 ] ],
* // [ [ 'g', 'h' ], [ 7, 8 ] ]
* // ]
*
* chunk(x, 2, 3);
* // [
* // [ [ 'a', 'b' ], [ 1, 2 ] ],
* // [ [ 'd', 'e' ], [ 4, 5 ] ],
* // [ [ 'g', 'h' ], [ 7, 8 ] ]
* // ]
*
* chunk(x, 4, 3);
* // [
* // [ [ 'a', 'b', 'c', 'd' ], [ 1, 2, 3, 4 ] ],
* // [ [ 'd', 'e', 'f', 'g' ], [ 4, 5, 6, 7 ] ],
* // [ [ 'g', 'h' ], [ 7, 8 ] ]
* // ]
* ```
* Lists is a pair of key list and value list, with unique keys.
* [📘](https://github.com/nodef/extra-lists/wiki/Lists)
*/
export function chunk<T, U>(x: Lists<T, U>, n?: number, s?: number): Lists<T, U>[];
declare type Lists<K, V> = [Iterable<K>, Iterable<V>];
/**
* Compares two lists.
* [📘](https://github.com/nodef/extra-lists/wiki/compare)
* @param x lists
* @param y another lists
* @param fc compare function (a, b)
* @param fm map function (v, k, x)
* @returns x=y: 0, otherwise: -ve/+ve
* @example
* ```javascript
* var x = [['a', 'b'], [1, 2]];
* var y = [['a', 'b', 'c'], [1, 2, 3]];
* compare(x, y);
* // -1
*
* var y = [['a', 'b'], [1, 2]];
* compare(x, y);
* // 0
*
* var y = [['a', 'b'], [1, -2]];
* compare(x, y);
* // 1
*
* compare(x, y, (a, b) => Math.abs(a) - Math.abs(b));
* // 0
*
* compare(x, y, null, v => Math.abs(v));
* // 0
* ```
* Handle reading of a single value.
* [📘](https://github.com/nodef/extra-lists/wiki/ReadFunction)
* @returns value
*/
export function compare<T, U, V = U>(x: Lists<T, U>, y: Lists<T, U>, fc?: compareFn<U | V>, fm?: mapFn<T, U, U | V>): number;
declare type ReadFunction<T> = () => T;
/**
* Appends entries from all lists.
* [📘](https://github.com/nodef/extra-lists/wiki/concat)
* @param xs n lists
* @example
* ```javascript
* var x = [['a', 'b'], [1, 2]];
* var y = [['c', 'd'], [3, 4]];
* concat(x, y).map(c => [...c]);
* // [ [ 'a', 'b', 'c', 'd' ], [ 1, 2, 3, 4 ] ]
*
* var z = [['d', 'e'], [40, 50]];
* // [ [ 'a', 'b', 'c', 'd', 'd', 'e' ], [ 1, 2, 3, 4, 40, 50 ] ]
* ```
* Handle combining of two values.
* [📘](https://github.com/nodef/extra-lists/wiki/CombineFunction)
* @param a a value
* @param b another value
* @returns combined value
*/
export function concat<T, U>(...xs: Lists<T, U>[]): Lists<T, U>;
declare type CombineFunction<T> = (a: T, b: T) => T;
/**
* Counts values which satisfy a test.
* [📘](https://github.com/nodef/extra-lists/wiki/count)
* @param x lists
* @param ft test function (v, k, x)
* @example
* ```javascript
* var x = [['a', 'b', 'c', 'd', 'e'], [1, 1, 2, 2, 4]];
* count(x, v => v % 2 === 1);
* // 2
*
* count(x, v => v % 2 === 0);
* // 3
* ```
* Handle comparison of two values.
* [📘](https://github.com/nodef/extra-lists/wiki/CompareFunction)
* @param a a value
* @param b another value
* @returns a<b: -ve, a=b: 0, a>b: +ve
*/
export function count<T, U>(x: Lists<T, U>, ft: testFn<T, U>): number;
declare type CompareFunction<T> = (a: T, b: T) => number;
/**
* Counts occurrences of values.
* [📘](https://github.com/nodef/extra-lists/wiki/countAs)
* @param x lists
* @param fm map function (v, k, x)
* @returns Map {value => count}
* @example
* ```javascript
* var x = [['a', 'b', 'c', 'd', 'e'], [1, 1, 2, 2, 4]];
* countAs(x);
* // Map(3) { 1 => 2, 2 => 2, 4 => 1 }
*
* var x = [['a', 'b', 'c', 'd'], [1, 2, 3, 4]];
* countAs(x, v => v % 2);
* // Map(2) { 1 => 2, 0 => 2 }
* ```
* Handle processing of values in lists.
* [📘](https://github.com/nodef/extra-lists/wiki/ProcessFunction)
* @param v value in lists
* @param k key of value in lists
* @param x lists containing the value
*/
export function countAs<T, U, V = U>(x: Lists<T, U>, fm?: mapFn<T, U, U | V>): Map<U | V, number>;
declare type ProcessFunction<K, V> = (v: V, k: K, x: Lists<K, V>) => void;
/**
* Gives entries of lists not present in another.
* [📘](https://github.com/nodef/extra-lists/wiki/difference)
* @param x lists
* @param y another lists
* @example
* ```javascript
* var x = [['a', 'b', 'c', 'd', 'e'], [1, 2, 3, 4, 5]];
* var y = [['b', 'd'], [2, 4]];
* difference(x, y).map(c => [...c]);
* // [ [ 'a', 'c', 'e' ], [ 1, 3, 5 ] ]
*
* var y = [['b', 'd'], [-2, -4]];
* difference(x, y).map(c => [...c]);
* // [ [ 'a', 'c', 'e' ], [ 1, 3, 5 ] ]
* ```
* Handle selection of values in lists.
* [📘](https://github.com/nodef/extra-lists/wiki/TestFunction)
* @param v value in lists
* @param k key of value in lists
* @param x lists containing the value
* @returns selected?
*/
export function difference<T, U>(x: Lists<T, U>, y: Lists<T, U>): Lists<T, U>;
declare type TestFunction<K, V> = (v: V, k: K, x: Lists<K, V>) => boolean;
/**
* Removes first n entries.
* [📘](https://github.com/nodef/extra-lists/wiki/drop)
* @param x lists
* @param n number of entries (1)
* @example
* ```javascript
* var x = [['a', 'b', 'c', 'd', 'e'], [1, 2, 3, 4, 5]];
* drop(x, 2).map(c => [...c]);
* // [ [ 'c', 'd', 'e' ], [ 3, 4, 5 ] ]
*
* drop(x, 3).map(c => [...c]);
* // [ [ 'd', 'e' ], [ 4, 5 ] ]
* ```
* Handle transformation of a value to another.
* [📘](https://github.com/nodef/extra-lists/wiki/MapFunction)
* @param v value in lists
* @param k key of value in lists
* @param x lists containing the value
* @returns transformed value
*/
export function drop<T, U>(x: Lists<T, U>, n?: number): Lists<T, U>;
declare type MapFunction<K, V, W> = (v: V, k: K, x: Lists<K, V>) => W;
/**
* Lists all key-value pairs.
* [📘](https://github.com/nodef/extra-lists/wiki/entries)
* @param x lists
* @example
* ```javascript
* var x = [['a', 'b', 'c'], [1, 2, 3]];
* [...entries(x)];
* // [ [ 'a', 1 ], [ 'b', 2 ], [ 'c', 3 ] ]
* ```
* Handle reduction of multiple values into a single value.
* [📘](https://github.com/nodef/extra-lists/wiki/ReduceFunction)
* @param acc accumulator (temporary result)
* @param v value in lists
* @param k key of value in lists
* @param x lists containing the value
* @returns reduced value
*/
export function entries<T, U>(x: Lists<T, U>): Entries<T, U>;
declare type ReduceFunction<K, V, W> = (acc: W, v: V, k: K, x: Lists<K, V>) => W;
/**
* Picks an arbitrary entry.
* [📘](https://github.com/nodef/extra-lists/wiki/entry)
* @param x lists
* @param r random seed 0->1
* @example
* ```javascript
* var x = [['a', 'b', 'c'], [1, 2, 3]];
* entry(x);
* // [ 'c', 3 ]
*
* entry(x, 0.5);
* // [ 'b', 2 ]
* ```
* Handle ending of combined lists.
* [📘](https://github.com/nodef/extra-lists/wiki/EndFunction)
* @param dones iᵗʰ lists done?
* @returns combined lists done?
*/
export function entry<T, U>(x: Lists<T, U>, r?: number): [
T,
U
];
declare type EndFunction = (dones: boolean[]) => boolean;
/**
* Checks if all values satisfy a test.
* [📘](https://github.com/nodef/extra-lists/wiki/every)
* @param x lists
* @param ft test function (v, k ,x)
* @example
* ```javascript
* var x = [['a', 'b', 'c', 'd'], [1, 2, -3, -4]];
* every(x, v => v > 0);
* // false
*
* every(x, v => v > -10);
* // true
* ```
* Check if value is lists.
* [📘](https://github.com/nodef/extra-lists/wiki/is)
* @param v value
* @returns v is lists?
*/
export function every<T, U>(x: Lists<T, U>, ft: testFn<T, U>): boolean;
declare function is<K, V>(v: any): v is Lists<K, V>;
/**
* Keeps entries which pass a test.
* [📘](https://github.com/nodef/extra-lists/wiki/filter)
* List all keys.
* [📘](https://github.com/nodef/extra-lists/wiki/keys)
* @param x lists
* @param ft test function (v, k, x)
* @example
* ```javascript
* var x = [['a', 'b', 'c', 'd', 'e'], [1, 2, 3, 4, 5]];
* filter(x, v => v % 2 === 1);
* // [ [ 'a', 'c', 'e' ], [ 1, 3, 5 ] ]
*
* filter(x, v => v % 2 === 0);
* // [ [ 'b', 'd' ], [ 2, 4 ] ]
* ```
* @returns k₀, k₁, ... | kᵢ ∈ x[0]
*/
export function filter<T, U>(x: Lists<T, U>, ft: testFn<T, U>): Lists<T, U>;
declare function keys<K, V>(x: Lists<K, V>): Iterable<K>;
/**
* Gets lists with given keys.
* [📘](https://github.com/nodef/extra-lists/wiki/filterAt)
* List all values.
* [📘](https://github.com/nodef/extra-lists/wiki/values)
* @param x lists
* @param ks keys
* @example
* ```javascript
* var x = [['a', 'b', 'c', 'd', 'e'], [1, 2, 3, 4, 5]];
* filterAt(x, ['a', 'c', 'e']);
* // [ [ 'a', 'c', 'e' ], [ 1, 3, 5 ] ]
*
* filterAt(x, ['b', 'd']);
* // [ [ 'b', 'd' ], [ 2, 4 ] ]
* ```
* @returns v₀, v₁, ... | vᵢ ∈ x[1]
*/
export function filterAt<T, U>(x: Lists<T, U>, ks: T[]): Lists<T, U>;
declare function values<K, V>(x: Lists<K, V>): Iterable<V>;
/**
* Finds a value passing a test.
* [📘](https://github.com/nodef/extra-lists/wiki/find)
* List all key-value pairs.
* [📘](https://github.com/nodef/extra-lists/wiki/entries)
* @param x lists
* @param ft test function (v, k, x)
* @example
* ```javascript
* var x = [['a', 'b', 'c', 'd'], [1, 2, 3, 4]];
* find(x, v => v % 2 === 0);
* // 2 ^
*
* find(x, v => v % 8 === 0);
* // undefined
* ```
* @returns [k₀, v₀], [k₁, v₁], ... | kᵢ ∈ x[0]; vᵢ ∈ x[1]
*/
export function find<T, U>(x: Lists<T, U>, ft: testFn<T, U>): U;
declare function entries<K, V>(x: Lists<K, V>): Entries<K, V>;
/**
* Finds values passing a test.
* [📘](https://github.com/nodef/extra-lists/wiki/findAll)
* Convert lists to entries.
* [📘](https://github.com/nodef/extra-lists/wiki/fromEntries)
* @param x entries
* @returns x as lists
*/
declare function fromEntries<K, V>(x: Entries<K, V>): Lists<K, V>;
/**
* Find the size of lists.
* [📘](https://github.com/nodef/extra-lists/wiki/size)
* @param x lists
* @param ft test function (v, k, x)
* @example
* ```javascript
* var x = [['a', 'b', 'c', 'd'], [1, 2, 3, 4]];
* [...findAll(x, v => v % 2 === 0)];
* // [ 2, 4 ] ^ ^
*
* [...findAll(x, v => v % 8 === 0)];
* // []
* ```
* @returns |x|
*/
export function findAll<T, U>(x: Lists<T, U>, ft: testFn<T, U>): Iterable<U>;
declare function size<K, V>(x: Lists<K, V>): number;
/**
* Flattens nested lists to given depth.
* [📘](https://github.com/nodef/extra-lists/wiki/flat)
* @param x nested lists
* @param n maximum depth (-1)
* @param fm map function (v, k, x)
* @param ft test function (v, k, x)
* @example
* ```javascript
* var x = [['ab', 'cde'], [
* [['a', 'b'], [1, 2]],
* [['c', 'de'], [
* 3,
* [['d', 'e'], [
* 3,
* [['e'], [
* 5
* ]]
* ]]
* ]]
* ]];
* flat(x).map(c => [...c]);
* // [ [ 'a', 'b', 'c', 'd', 'e' ], [ 1, 2, 3, 3, 5 ] ]
*
* flat(x, 1).map(c => [...c]);
* // [ [ 'a', 'b', 'c', 'de' ], [ 1, 2, 3, [ [Array], [Array] ] ] ]
*
* flat(x, 2).map(c => [...c]);
* // [ [ 'a', 'b', 'c', 'd', 'e' ], [ 1, 2, 3, 3, [ [Array], [Array] ] ] ]
* ```
* Check if lists is empty.
* [📘](https://github.com/nodef/extra-lists/wiki/isEmpty)
* @param x lists
* @returns |x| = 0?
*/
export function flat<T>(x: Lists<T, any>, n?: number, fm?: mapFn<T, any, any>, ft?: testFn<T, any>): Lists<T, any>;
declare function isEmpty<K, V>(x: Lists<K, V>): boolean;
/**
* Flattens nested lists, using map function.
* [📘](https://github.com/nodef/extra-lists/wiki/flatMap)
* @param x nested lists
* Compare two lists.
* [📘](https://github.com/nodef/extra-lists/wiki/compare)
* @param x lists
* @param y another lists
* @param fc compare function (a, b)
* @param fm map function (v, k, x)
* @param ft test function (v, k, x)
* @example
* ```javascript
* var x = [['ab', 'cde'], [
* [['a', 'b'], [1, 2]],
* [['c', 'de'], [
* 3,
* [['d', 'e'], [
* 3,
* [['e'], [
* 5
* ]]
* ]]
* ]]
* ]];
* flatMap(x).map(c => [...c]);
* // [ [ 'a', 'b', 'c', 'de' ], [ 1, 2, 3, [ [Array], [Array] ] ] ]
*
* flatMap(x, v => flat(v, 1)).map(c => [...c]);
* // [ [ 'a', 'b', 'c', 'd', 'e' ], [ 1, 2, 3, 3, [ [Array], [Array] ] ] ]
*
* flatMap(x, v => flat(v)).map(c => [...c]);
* // [ [ 'a', 'b', 'c', 'd', 'e' ], [ 1, 2, 3, 3, 5 ] ]
* ```
* @returns x=y: 0, otherwise: -ve/+ve
*/
export function flatMap<T>(x: Lists<T, any>, fm?: mapFn<T, any, any>, ft?: testFn<T, any>): Lists<T, any>;
declare function compare<K, V, W = V>(x: Lists<K, V>, y: Lists<K, V>, fc?: CompareFunction<V | W> | null, fm?: MapFunction<K, V, V | W> | null): number;
/**
* Calls a function for each value.
* [📘](https://github.com/nodef/extra-lists/wiki/forEach)
* Check if two lists are equal.
* [📘](https://github.com/nodef/extra-lists/wiki/isEqual)
* @param x lists
* @param fc called function (v, k, x)
* @example
* ```javascript
* var x = [['a', 'b', 'c', 'd'], [1, 2, -3, -4]];
* forEach(x, v => console.log(v));
* // 1
* // 2
* // -3
* // -4
* ```
* @param y another lists
* @param fc compare function (a, b)
* @param fm map function (v, k, x)
* @returns x=y?
*/
export function forEach<T, U>(x: Lists<T, U>, fc: calledFn<T, U>): void;
declare function isEqual<K, V, W = V>(x: Lists<K, V>, y: Lists<K, V>, fc?: CompareFunction<V | W> | null, fm?: MapFunction<K, V, V | W> | null): boolean;
/**
* Creates lists from entries.
* [📘](https://github.com/nodef/extra-lists/wiki/fromEntries)
* @param es entries
* @example
* ```javascript
* var es = [['a', 1], ['b', 2], ['c', 3]];
* fromEntries(es).map(c => [...c]);
* // [ [ 'a', 'b', 'c' ], [ 1, 2, 3 ] ]
* ```
*/
export function fromEntries<T, U>(es: Entries<T, U>): Lists<T, U>;
/**
* Gets value at key.
* Get value at key.
* [📘](https://github.com/nodef/extra-lists/wiki/get)
* @param x lists
* @param k key
* @example
* ```javascript
* var x = [['a', 'b', 'c', 'd'], [2, 4, 6, 8]];
* get(x, 'b');
* // 4
*
* get(x, 'd');
* // 8
* ```
* @returns x[k]
*/
export function get<T, U>(x: Lists<T, U>, k: T): U;
declare function get<K, V>(x: Lists<K, V>, k: K): V;
/**

@@ -422,550 +159,247 @@ * Gets values at keys.

* @param ks keys
* @example
* ```javascript
* var x = [['a', 'b', 'c', 'd'], [2, 4, 6, 8]];
* getAll(x, ['b', 'd']);
* // [ 4, 8 ]
*
* getAll(x, ['e']);
* // [ undefined ]
* ```
* @returns x[k₀], x[k₁], ... | [k₀, k₁, ...] = ks
*/
export function getAll<T, U>(x: Lists<T, U>, ks: T[]): Iterable<U>;
declare function getAll<K, V>(x: Lists<K, V>, ks: K[]): Iterable<V>;
/**
* Gets value at path in nested lists.
* Get value at path in nested lists.
* [📘](https://github.com/nodef/extra-lists/wiki/getPath)
* @param x nested lists
* @param p path
* @example
* ```javascript
* var x = [['a', 'b', 'c'], [2, 4, 6]];
* var y = [['x', 'e', 'f'], [x, 10, 12]];
* getPath(y, ['e']);
* // 10
*
* getPath(y, ['x', 'b']);
* // 4
*
* getPath(y, ['x', 'b', 'c']);
* // undefined
* ```
* @returns x[k₀][k₁][...] | [k₀, k₁, ...] = p
*/
export function getPath<T>(x: Lists<T, any>, p: T[]): any;
declare function getPath<K>(x: Lists<K, any>, p: K[]): any;
/**
* Checks if lists has a key.
* [📘](https://github.com/nodef/extra-lists/wiki/has)
* @param x lists
* @param k key?
* @example
* ```javascript
* var x = [['a', 'b', 'c'], [1, 2, -3]];
* has(x, 'd');
* // false
*
* has(x, 'c');
* // true
* ```
*/
export function has<T, U>(x: Lists<T, U>, k: T): boolean;
/**
* Checks if map has an entry.
* [📘](https://github.com/nodef/extra-lists/wiki/hasEntry)
* @param x a map
* @param e entry?
* @param fc compare function (a, b)
* @param fm map function (v, k, x)
* @example
* ```javascript
* var x = [['a', 'b', 'c'], [1, 2, -3]];
* hasEntry(x, ['c', 3]);
* // false
*
* hasEntry(x, ['c', 3], (a, b) => Math.abs(a) - Math.abs(b));
* // true
*
* hasEntry(x, ['c', 3], null, v => Math.abs(v));
* // true
* ```
*/
export function hasEntry<T, U, V = U>(x: Lists<T, U>, e: [
T,
U
], fc?: compareFn<U | V>, fm?: mapFn<T, U, U | V>): boolean;
/**
* Checks if nested lists has a path.
* Check if nested lists has a path.
* [📘](https://github.com/nodef/extra-lists/wiki/hasPath)
* @param x nested lists
* @param p path
* @example
* ```javascript
* var x = [['a', 'b', 'c'], [2, 4, 6]];
* var y = [['x', 'e', 'f'], [x, 10, 12]];
* hasPath(y, ['e']);
* // true
*
* hasPath(y, ['x', 'b']);
* // true
*
* hasPath(y, ['x', 'b', 'c']);
* // false
* ```
* @param p search path
* @returns x[k₀][k₁][...] exists? | [k₀, k₁, ...] = p
*/
export function hasPath<T>(x: Lists<T, any>, p: T[]): boolean;
declare function hasPath<T>(x: Lists<T, any>, p: T[]): boolean;
/**
* Checks if lists has a subset.
* [📘](https://github.com/nodef/extra-lists/wiki/hasSubset)
* Set value at key.
* [📘](https://github.com/nodef/extra-lists/wiki/set)
* @param x lists
* @param y subset?
* @param fc compare function (a, b)
* @param fm map function (v, k, x)
* @example
* ```javascript
* var x = [['a', 'b', 'c', 'd'], [1, 2, 3, 4]];
* var y = [['b', 'd'], [2, 4]];
* hasSubset(x, y);
* // true
*
* var y = [['b', 'd'], [-2, -4]];
* hasSubset(x, y);
* // false
*
* hasSubset(x, y, (a, b) => Math.abs(a) - Math.abs(b));
* // true
*
* hasSubset(x, y, null, v => Math.abs(v));
* // true
* ```
* @param k key
* @param v value
* @returns x' | x' = x; x'[k] = v
*/
export function hasSubset<T, U, V = U>(x: Lists<T, U>, y: Lists<T, U>, fc?: compareFn<U | V>, fm?: mapFn<T, U, U | V>): boolean;
declare function set<K, V>(x: Lists<K, V>, k: K, v: V): Lists<K, V>;
/**
* Checks if lists has a value.
* [📘](https://github.com/nodef/extra-lists/wiki/hasValue)
* Exchange two values.
* [📘](https://github.com/nodef/extra-lists/wiki/swap)
* @param x lists
* @param v value?
* @param fc compare function (a, b)
* @param fm map function (v, k, x)
* @example
* ```javascript
* var x = [['a', 'b', 'c'], [1, 2, -3]];
* hasValue(x, 3);
* // false
*
* hasValue(x, 3, (a, b) => Math.abs(a) - Math.abs(b));
* // true
*
* hasValue(x, 3, null, v => Math.abs(v));
* // true
* ```
* @param k a key
* @param l another key
* @returns x' | x' = x; x'[k] = x[l]; x'[l] = x[k]
*/
export function hasValue<T, U, V = U>(x: Lists<T, U>, v: U, fc?: compareFn<U | V>, fm?: mapFn<T, U, U | V>): boolean;
declare function swap<K, V>(x: Lists<K, V>, k: K, l: K): Lists<K, V>;
/**
* Gets first entry.
* Remove value at key.
* [📘](https://github.com/nodef/extra-lists/wiki/remove)
* @param x lists
* @param k key
* @returns x - [k, v] | v = x[k]
*/
declare function remove<K, V>(x: Lists<K, V>, k: K): Lists<K, V>;
/**
* Get first entry from lists (default order).
* [📘](https://github.com/nodef/extra-lists/wiki/head)
* @param x lists
* @param ed default entry
* @example
* ```javascript
* var x = [['a', 'b', 'c'], [1, 2, 3]];
* head(x);
* // [ 'a', 1 ]
*
* var x = [[], []];
* head(x, ['', -1]);
* // [ '', -1 ]
* ```
* @returns [k₀, v₀] if x ≠ Φ else ed | [k₀, v₀] ∈ x
*/
export function head<T, U>(x: Lists<T, U>, ed?: [
T,
U
]): [
T,
U
];
declare function head<K, V>(x: Lists<K, V>, ed?: [K, V]): [K, V];
/**
* Gives entries present in both lists.
* [📘](https://github.com/nodef/extra-lists/wiki/intersection)
* Get lists without its first entry (default order).
* [📘](https://github.com/nodef/extra-lists/wiki/tail)
* @param x lists
* @param y another lists
* @param fc combine function (a, b)
* @example
* ```javascript
* var x = [['a', 'b', 'c', 'd'], [1, 2, 3, 4]];
* var y = [['b', 'c', 'e'], [20, 30, 50]];
* intersection(x, y).map(c => [...c]);
* // [ [ 'b', 'c' ], [ 2, 3 ] ]
*
* intersection(x, y, (a, b) => b).map(c => [...c]);
* // [ [ 'b', 'c' ], [ 20, 30 ] ]
* ```
* @returns x \\ \{[k₀, v₀]\} if x ≠ Φ else x | [k₀, v₀] ∈ x
*/
export function intersection<T, U>(x: Lists<T, U>, y: Lists<T, U>, fc?: combineFn<U>): Lists<T, U>;
declare function tail<K, V>(x: Lists<K, V>): Lists<K, V>;
/**
* Checks if value is lists.
* [📘](https://github.com/nodef/extra-lists/wiki/is)
* @param v value
* @example
* ```javascript
* is([['a', 'b'], [1, 2]]);
* // true
*
* is([[], []]);
* // true
*
* is(1);
* // false
* ```
* Keep first n entries only (default order).
* [📘](https://github.com/nodef/extra-lists/wiki/take)
* @param x lists
* @param n number of entries [1]
* @returns \{[k₀, v₀], [k₁, v₁], ...\} | [kᵢ, vᵢ] ∈ x and |\{[k₀, v₀], [k₁, v₁], ...\}| ≤ n
*/
export function is<T, U>(v: any): v is Lists<T, U>;
declare function take<K, V>(x: Lists<K, V>, n?: number): Lists<K, V>;
/**
* Checks if lists have no common keys.
* [📘](https://github.com/nodef/extra-lists/wiki/isDisjoint)
* @param x lists
* @param y another lists
* @example
* ```javascript
* var x = [['a', 'b', 'c'], [1, 2, 3]];
* var x = [['c', 'd'], [3, 4]];
* isDisjoint(x, y);
* // false
*
* var x = [['d'], [4]];
* isDisjoint(x, y);
* // true
* ```
* Remove first n entries (default order).
* [📘](https://github.com/nodef/extra-lists/wiki/drop)
* @param x a map
* @param n number of entries [1]
* @returns \{[kₙ, vₙ], [kₙ₊₁, vₙ₊₁], ...\} | [kᵢ, vᵢ] ∈ x and |\{[kₙ, vₙ], [kₙ₊₁, vₙ₊₁], ...\}| ≤ max(|x| - n, 0)
*/
export function isDisjoint<T, U>(x: Lists<T, U>, y: Lists<T, U>): boolean;
declare function drop<K, V>(x: Lists<K, V>, n?: number): Lists<K, V>;
/**
* Checks if lists is empty.
* [📘](https://github.com/nodef/extra-lists/wiki/isEmpty)
* Count values which satisfy a test.
* [📘](https://github.com/nodef/extra-lists/wiki/count)
* @param x lists
* @example
* ```javascript
* var x = [['a', 'b', 'c'], [1, 2, 3]];
* isEmpty(x);
* // false
*
* var x = [[], []];
* isEmpty(x);
* // true
* ```
* @param ft test function (v, k, x)
* @returns Σtᵢ | tᵢ = 1 if ft(vᵢ) else 0; [kᵢ, vᵢ] ∈ x
*/
export function isEmpty<T, U>(x: Lists<T, U>): boolean;
declare function count<K, V>(x: Lists<K, V>, ft: TestFunction<K, V>): number;
/**
* Checks if two lists are equal.
* [📘](https://github.com/nodef/extra-lists/wiki/isEqual)
* Count occurrences of values.
* [📘](https://github.com/nodef/extra-lists/wiki/countAs)
* @param x lists
* @param y another lists
* @param fc compare function (a, b)
* @param fm map function (v, k, x)
* @example
* ```javascript
* var x = [['a', 'b'], [1, 2]];
* var y = [['a', 'b'], [1, 2]];
* isEqual(x, y);
* // true
*
* var y = [['a', 'b'], [11, 12]];
* isEqual(x, y);
* // false
*
* isEqual(x, y, (a, b) => (a % 10) - (b % 10));
* // true
*
* isEqual(x, y, null, v => v % 10);
* // true
* ```
* @returns Map \{value ⇒ count\}
*/
export function isEqual<T, U, V = U>(x: Lists<T, U>, y: Lists<T, U>, fc?: compareFn<U | V>, fm?: mapFn<T, U, U | V>): boolean;
declare function countAs<K, V, W = V>(x: Lists<K, V>, fm?: MapFunction<K, V, V | W> | null): Map<V | W, number>;
/**
* Joins values together.
* [📘](https://github.com/nodef/extra-lists/wiki/join)
* Find smallest value.
* [📘](https://github.com/nodef/extra-lists/wiki/min)
* @param x lists
* @param sep separator (,)
* @param asc associator (=)
* @example
* ```javascript
* var x = [['a', 'b', 'c'], [1, 2, 3]];
* join(x);
* // 'a=1,b=2,c=3'
*
* join(x, ', ', ' => ');
* // 'a => 1, b => 2, c => 3'
* ```
* @param fc compare function (a, b)
* @param fm map function (v, k, x)
* @returns v | v ≤ vᵢ; [kᵢ, vᵢ] ∈ x
*/
export function join<T, U>(x: Lists<T, U>, sep?: string, asc?: string): string;
declare function min<K, V, W = V>(x: Lists<K, V>, fc?: CompareFunction<V | W> | null, fm?: MapFunction<K, V, V | W> | null): V;
/**
* Picks an arbitrary key.
* [📘](https://github.com/nodef/extra-lists/wiki/key)
* Find smallest entry.
* [📘](https://github.com/nodef/extra-lists/wiki/minEntry)
* @param x lists
* @param r random seed 0->1
* @example
* ```javascript
* var x = [['a', 'b', 'c'], [1, 2, 3]];
* key(x);
* // 'c'
*
* key(x, 0.5);
* // 'b'
* ```
* @param fc compare function (a, b)
* @param fm map function (v, k, x)
* @returns [min_key, min_value]
*/
export function key<T, U>(x: Lists<T, U>, r?: number): T;
declare function minEntry<K, V, W = V>(x: Lists<K, V>, fc?: CompareFunction<V | W> | null, fm?: MapFunction<K, V, V | W> | null): [K, V];
/**
* Lists all keys.
* [📘](https://github.com/nodef/extra-lists/wiki/keys)
* Find largest value.
* [📘](https://github.com/nodef/extra-lists/wiki/max)
* @param x lists
* @example
* ```javascript
* var x = [['a', 'b', 'c'], [1, 2, 3]];
* [...keys(x)];
* // [ 'a', 'b', 'c' ]
* ```
* @param fc compare function (a, b)
* @param fm map function (v, k, x)
* @returns v | v ≥ vᵢ; [kᵢ, vᵢ] ∈ x
*/
export function keys<T, U>(x: Lists<T, U>): Iterable<T>;
declare function max<K, V, W = V>(x: Lists<K, V>, fc?: CompareFunction<V | W> | null, fm?: MapFunction<K, V, V | W> | null): V;
/**
* Gets size of lists.
* [📘](https://github.com/nodef/extra-lists/wiki/length)
* Find largest entry.
* [📘](https://github.com/nodef/extra-lists/wiki/maxEntry)
* @param x lists
* @example
* ```javascript
* var x = [['a', 'b', 'c'], [1, 2, 3]];
* length(x);
* // 3
* ```
* @param fc compare function (a, b)
* @param fm map function (v, k, x)
* @returns [max_key, max_value]
*/
export function length<T, U>(x: Lists<T, U>): number;
declare function maxEntry<K, V, W = V>(x: Lists<K, V>, fc?: CompareFunction<V | W> | null, fm?: MapFunction<K, V, V | W> | null): [K, V];
/**
* Updates values based on map function.
* [📘](https://github.com/nodef/extra-lists/wiki/map)
* Find smallest and largest values.
* [📘](https://github.com/nodef/extra-lists/wiki/range)
* @param x lists
* @param fc compare function (a, b)
* @param fm map function (v, k, x)
* s
* @example
* ```javascript
* var x = [['a', 'b', 'c', 'd'], [1, 2, 3, 4]];
* map(x, v => v * 2);
* // [ [ 'a', 'b', 'c', 'd' ], [ 2, 4, 6, 8 ] ]
* ```
* @returns [min_value, max_value]
*/
export function map<T, U, V>(x: Lists<T, U>, fm: mapFn<T, U, V>): any[][];
declare function range<K, V, W = V>(x: Lists<K, V>, fc?: CompareFunction<V | W> | null, fm?: MapFunction<K, V, V | W> | null): [V, V];
/**
* Finds largest value.
* [📘](https://github.com/nodef/extra-lists/wiki/max)
* Find smallest and largest entries.
* [📘](https://github.com/nodef/extra-lists/wiki/rangeEntries)
* @param x lists
* @param fc compare function (a, b)
* @param fm map function (v, k, x)
* @returns [key, value]
* @example
* ```javascript
* var x = [['a', 'b', 'c', 'd'], [1, 2, -3, -4]];
* max(x);
* // [ 'b', 2 ]
*
* max(x, (a, b) => Math.abs(a) - Math.abs(b));
* // [ 'd', -4 ]
*
* max(x, null, v => Math.abs(v));
* // [ 'd', -4 ]
* ```
* @returns [min_entry, max_entry]
*/
export function max<T, U, V = U>(x: Lists<T, U>, fc?: compareFn<U | V>, fm?: mapFn<T, U, U | V>): [
T,
U
];
declare function rangeEntries<K, V, W = V>(x: Lists<K, V>, fc?: CompareFunction<V | W> | null, fm?: MapFunction<K, V, V | W> | null): [[K, V], [K, V]];
/**
* Finds smallest entry.
* [📘](https://github.com/nodef/extra-lists/wiki/min)
* List all possible subsets.
* [📘](https://github.com/nodef/extra-lists/wiki/subsets)
* @param x lists
* @param fc compare function (a, b)
* @param fm map function (v, k, x)
* @returns [key, value]
* @example
* ```javascript
* var x = [['a', 'b', 'c', 'd'], [1, 2, -3, -4]];
* min(x);
* // [ 'd', -4 ]
*
* min(x, (a, b) => Math.abs(a) - Math.abs(b));
* // [ 'a', 1 ]
*
* min(x, null, v => Math.abs(v));
* // [ 'a', 1 ]
* ```
* @param n number of entries in each subset [-1 ⇒ any]
* @returns entries selected by bit from 0..2^|x| if n<0; only of length n otherwise
*/
export function min<T, U, V = U>(x: Lists<T, U>, fc?: compareFn<U | V>, fm?: mapFn<T, U, U | V>): [
T,
U
];
declare function subsets<K, V>(x: Lists<K, V>, n?: number): Iterable<Lists<K, V>>;
/**
* Segregates values by test result.
* [📘](https://github.com/nodef/extra-lists/wiki/partition)
* Pick an arbitrary key.
* [📘](https://github.com/nodef/extra-lists/wiki/randomKey)
* @param x lists
* @param ft test function (v, k, x)
* @returns [satisfies, doesnt]
* @example
* ```javascript
* var x = [['a', 'b', 'c', 'd'], [1, 2, 3, 4]];
* partition(x, v => v % 2 == 0).map(x => [...x]);
* // [ [ [ 'b', 'd' ], [ 2, 4 ] ], [ [ 'a', 'c' ], [ 1, 3 ] ] ]
*
* var x = [['a', 'b', 'c', 'd', 'e'], [1, 2, 3, 4, 5]];
* partition(x, v => v % 2 == 1).map(x => [...x]);
* // [ [ [ 'a', 'c', 'e' ], [ 1, 3, 5 ] ], [ [ 'b', 'd' ], [ 2, 4 ] ] ]
* ```
* @param fr random number generator ([0, 1))
* @returns kᵢ | kᵢ ∈ x[0]
*/
export function partition<T, U>(x: Lists<T, U>, ft: testFn<T, U>): [
Lists<T, U>,
Lists<T, U>
];
declare function randomKey<K, V>(x: Lists<K, V>, fr?: ReadFunction<number>): K;
/**
* Segregates values by similarity.
* [📘](https://github.com/nodef/extra-lists/wiki/partitionAs)
* Pick an arbitrary value.
* [📘](https://github.com/nodef/extra-lists/wiki/randomValue)
* @param x lists
* @param fm map function (v, k, x)
* @returns Map {key => values}
* @example
* ```javascript
* var x = [['a', 'b', 'c', 'd'], [1, 2, 3, 4]];
* partitionAs(x, v => v % 2 == 0);
* // Map(2) {
* // false => [ [ 'a', 'c' ], [ 1, 3 ] ],
* // true => [ [ 'b', 'd' ], [ 2, 4 ] ]
* // }
*
* var x = [['a', 'b', 'c', 'd', 'e'], [1, 2, 3, 4, 5]];
* partitionAs(x, v => v % 3);
* // Map(3) {
* // 1 => [ [ 'a', 'd' ], [ 1, 4 ] ],
* // 2 => [ [ 'b', 'e' ], [ 2, 5 ] ],
* // 0 => [ [ 'c' ], [ 3 ] ]
* // }
* ```
* @param fr random number generator ([0, 1))
* @returns vᵢ | vᵢ ∈ x[1]
*/
export function partitionAs<T, U, V = U>(x: Lists<T, U>, fm?: mapFn<T, U, U | V>): Map<U | V, Lists<T, U>>;
declare function randomValue<K, V>(x: Lists<K, V>, fr?: ReadFunction<number>): V;
/**
* Finds smallest and largest entries.
* [📘](https://github.com/nodef/extra-lists/wiki/range)
* Pick an arbitrary entry.
* [📘](https://github.com/nodef/extra-lists/wiki/randomEntry)
* @param x lists
* @param fc compare function (a, b)
* @param fm map function (v, k, x)
* @returns [smallest, largest]
* @example
* ```javascript
* var x = [['a', 'b', 'c', 'd'], [1, 2, -3, -4]];
* range(x);
* // [ [ 'd', -4 ], [ 'b', 2 ] ]
*
* range(x, (a, b) => Math.abs(a) - Math.abs(b));
* // [ [ 'a', 1 ], [ 'd', -4 ] ]
*
* range(x, null, v => Math.abs(v));
* // [ [ 'a', 1 ], [ 'd', -4 ] ]
* ```
* @param fr random number generator ([0, 1))
* @returns [kᵢ, vᵢ] | kᵢ ∈ x[0]; vᵢ ∈ x[1]
*/
export function range<T, U, V = U>(x: Lists<T, U>, fc?: compareFn<U | V>, fm?: mapFn<T, U, U | V>): [
[
T,
U
],
[
T,
U
]
];
declare function randomEntry<K, V>(x: Lists<K, V>, fr?: ReadFunction<number>): [K, V];
/**
* Reduces values to a single value.
* [📘](https://github.com/nodef/extra-lists/wiki/reduce)
* Pick an arbitrary subset.
* [📘](https://github.com/nodef/extra-lists/wiki/randomSubset)
* @param x lists
* @param fr reduce function (acc, v, k, x)
* @param acc initial value
* @example
* ```javascript
* var x = [['a', 'b', 'c', 'd'], [1, 2, 3, 4]];
* reduce(x, (acc, v) => acc+v);
* // 10
*
* reduce(x, (acc, v) => acc+v, 100);
* // 110
* ```
* @param n number of entries [-1 ⇒ any]
* @param fr random number generator ([0, 1))
* @returns [[kᵢ, kⱼ, ...], [vᵢ, vⱼ, ...]] | kᵢ, kⱼ, ... ∈ x[0]; vᵢ, vⱼ, ... ∈ x[1]; |[kᵢ, kⱼ, , ...]| = |x| if n<0 else n
*/
export function reduce<T, U, V = U>(x: Lists<T, U>, fr: reduceFn<T, U, U | V>, acc?: U | V): U | V;
declare function randomSubset<K, V>(x: Lists<K, V>, n?: number, fr?: ReadFunction<number>): Lists<K, V>;
/**
* Discards entries which pass a test.
* [📘](https://github.com/nodef/extra-lists/wiki/reject)
* Check if lists has a key.
* [📘](https://github.com/nodef/extra-lists/wiki/has)
* @param x lists
* @param ft test function (v, k, x)
* @example
* ```javascript
* var x = [['a', 'b', 'c', 'd', 'e'], [1, 2, 3, 4, 5]];
* reject(x, v => v % 2 === 1);
* // [ [ 'b', 'd' ], [ 2, 4 ] ]
*
* reject(x, v => v % 2 === 0);
* // [ [ 'a', 'c', 'e' ], [ 1, 3, 5 ] ]
* ```
* @param k search key
* @returns k ∈ keys(x)?
*/
export function reject<T, U>(x: Lists<T, U>, ft: testFn<T, U>): Lists<T, U>;
declare function has<K, V>(x: Lists<K, V>, k: K): boolean;
/**
* Gets lists without given keys.
* [📘](https://github.com/nodef/extra-lists/wiki/rejectAt)
* Check if lists has a value.
* [📘](https://github.com/nodef/extra-lists/wiki/hasValue)
* @param x lists
* @param ks keys
* @example
* ```javascript
* var x = [['a', 'b', 'c', 'd', 'e'], [1, 2, 3, 4, 5]];
* rejectAt(x, ['a', 'c', 'e']);
* // [ [ 'b', 'd' ], [ 2, 4 ] ]
*
* rejectAt(x, ['b', 'd']);
* // [ [ 'a', 'c', 'e' ], [ 1, 3, 5 ] ]
* ```
* @param v search value
* @param fc compare function (a, b)
* @param fm map function (v, k, x)
* @returns v ∈ values(x)?
*/
export function rejectAt<T, U>(x: Lists<T, U>, ks: T[]): Lists<T, U>;
declare function hasValue<K, V, W = V>(x: Lists<K, V>, v: V, fc?: CompareFunction<V | W> | null, fm?: MapFunction<K, V, V | W> | null): boolean;
/**
* Deletes an entry.
* [📘](https://github.com/nodef/extra-lists/wiki/remove)
* Check if lists has an entry.
* [📘](https://github.com/nodef/extra-lists/wiki/hasEntry)
* @param x lists
* @param k key
* @example
* ```javascript
* var x = [['a', 'b', 'c', 'd'], [2, 4, 6, 8]];
* remove(x, 'b');
* // [ [ 'a', 'c', 'd' ], [ 2, 6, 8 ] ]
*
* remove(x, 'd');
* // [ [ 'a', 'b', 'c' ], [ 2, 4, 6 ] ]
* ```
* @param e search entry
* @param fc compare function (a, b)
* @param fm map function (v, k, x)
* @returns k ∈ x[0]; v ∈ x[1]; k ⇒ v? | [k, v] = e
*/
export function remove<T, U>(x: Lists<T, U>, k: T): Lists<T, U>;
declare function hasEntry<K, V, W = V>(x: Lists<K, V>, e: [K, V], fc?: CompareFunction<V | W> | null, fm?: MapFunction<K, V, V | W> | null): boolean;
/**
* Finds key of first entry not passing a test.
* [📘](https://github.com/nodef/extra-lists/wiki/scanUntil)
* Check if lists has a subset.
* [📘](https://github.com/nodef/extra-lists/wiki/hasSubset)
* @param x lists
* @param y search subset
* @param fc compare function (a, b)
* @param fm map function (v, k, x)
* @returns y ⊆ x?
*/
declare function hasSubset<K, V, W = V>(x: Lists<K, V>, y: Lists<K, V>, fc?: CompareFunction<V | W> | null, fm?: MapFunction<K, V, V | W> | null): boolean;
/**
* Find first value passing a test (default order).
* [📘](https://github.com/nodef/extra-lists/wiki/find)
* @param x lists
* @param ft test function (v, k, x)
* @example
* ```javascript
* var x = [['a', 'b', 'c', 'd'], [1, 2, 3, 2]];
* scanUntil(x, v => v % 2 === 0);
* // 'b' ^
*
* scanUntil(x, v => v % 8 === 0);
* // undefined
* ```
* @returns first v | ft(v) = true; [k, v] ∈ x
*/
export function scanUntil<T, U>(x: Lists<T, U>, ft: testFn<T, U>): T;
declare function find<K, V>(x: Lists<K, V>, ft: TestFunction<K, V>): V;
/**
* Finds key of first entry not passing a test.
* [📘](https://github.com/nodef/extra-lists/wiki/scanWhile)
* Find values passing a test.
* [📘](https://github.com/nodef/extra-lists/wiki/findAll)
* @param x lists
* @param ft test function (v, k, x)
* @example
* ```javascript
* var x = [['a', 'b', 'c', 'd'], [1, 2, 3, 2]];
* scanWhile(x, v => v % 2 !== 0);
* // 'b' ^
*
* scanWhile(x, v => v % 8 !== 0);
* // undefined
* ```
* @returns v₀, v₁, ... | ft(vᵢ) = true; [kᵢ, vᵢ] ∈ x
*/
export function scanWhile<T, U>(x: Lists<T, U>, ft: testFn<T, U>): T;
declare function findAll<K, V>(x: Lists<K, V>, ft: TestFunction<K, V>): Iterable<V>;
/**

@@ -976,31 +410,15 @@ * Finds key of an entry passing a test.

* @param ft test function (v, k, x)
* @example
* ```javascript
* var x = [['a', 'b', 'c', 'd'], [1, 2, 3, 2]];
* search(x, v => v === 2);
* // 'b' ^
*
* search(x, v => v === 4);
* // undefined
* ```
* @returns key of entry
*/
export function search<T, U>(x: Lists<T, U>, ft: testFn<T, U>): T;
declare function search<K, V>(x: Lists<K, V>, ft: TestFunction<K, V>): K;
/**
* Finds keys of entries passing a test.
* Find keys of entries passing a test.
* [📘](https://github.com/nodef/extra-lists/wiki/searchAll)
* @param x lists
* @param ft test function (v, k, x)
* @example
* ```javascript
* var x = [['a', 'b', 'c', 'd'], [1, 2, 3, -2]];
* [...searchAll(x, v => v === 2)];
* // [ 'b' ] ^
*
* [...searchAll(x, v => Math.abs(v) === 2)];
* // [ 'b', 'd' ] ^ ^
* ```
* @returns keys of entries
*/
export function searchAll<T, U>(x: Lists<T, U>, ft: testFn<T, U>): Iterable<T>;
declare function searchAll<K, V>(x: Lists<K, V>, ft: TestFunction<K, V>): Iterable<K>;
/**
* Finds key with given value.
* Find a key with given value.
* [📘](https://github.com/nodef/extra-lists/wiki/searchValue)

@@ -1011,18 +429,7 @@ * @param x lists

* @param fm map function (v, k, x)
* @example
* ```javascript
* var x = [['a', 'b', 'c', 'd', 'e'], [1, -2, 3, 2, 5]];
* searchValue(x, 2);
* // 'd' ^
*
* searchValue(x, 2, (a, b) => Math.abs(a) - Math.abs(b));
* // 'b' ^
*
* searchValue(x, 2, null, v => Math.abs(v));
* // 'b' ^
* ```
* @returns key of value
*/
export function searchValue<T, U, V = U>(x: Lists<T, U>, v: U, fc?: compareFn<U | V>, fm?: mapFn<T, U, U | V>): T;
declare function searchValue<K, V, W = V>(x: Lists<K, V>, v: V, fc?: CompareFunction<V | W> | null, fm?: MapFunction<K, V, V | W> | null): K;
/**
* Finds keys with given value.
* Find keys with given value.
* [📘](https://github.com/nodef/extra-lists/wiki/searchValueAll)

@@ -1033,283 +440,197 @@ * @param x lists

* @param fm map function (v, k, x)
* @example
* ```javascript
* var x = [['a', 'b', 'c', 'd', 'e'], [1, -2, 3, 2, 5]];
* [...searchValueAll(x, 2)];
* // [ 'd' ] ^
*
* [...searchValueAll(x, 2, (a, b) => Math.abs(a) - Math.abs(b))];
* // [ 'b', 'd' ] ^ ^
*
* [...searchValueAll(x, 2, null, v => Math.abs(v))];
* // [ 'b', 'd' ] ^ ^
* ```
* @returns keys of value
*/
export function searchValueAll<T, U, V = U>(x: Lists<T, U>, v: U, fc?: compareFn<U | V>, fm?: mapFn<T, U, U | V>): Iterable<T>;
declare function searchValueAll<K, V, W = V>(x: Lists<K, V>, v: V, fc?: CompareFunction<V | W> | null, fm?: MapFunction<K, V, V | W> | null): Iterable<K>;
/**
* Sets value at key.
* [📘](https://github.com/nodef/extra-lists/wiki/set)
* Call a function for each value.
* [📘](https://github.com/nodef/extra-lists/wiki/forEach)
* @param x lists
* @param k key
* @param v value
* @example
* ```javascript
* var x = [['a', 'b', 'c', 'd'], [2, 4, 6, 8]];
* set(x, 'b', 40);
* // [ [ 'a', 'b', 'c', 'd' ], [ 2, 40, 6, 8 ] ]
*
* set(x, 'd', 80);
* // [ [ 'a', 'b', 'c', 'd' ], [ 2, 4, 6, 80 ] ]
* ```
* @param fp process function (v, k, x)
*/
export function set<T, U>(x: Lists<T, U>, k: T, v: U): Lists<T, U>;
declare function forEach<K, V>(x: Lists<K, V>, fc: ProcessFunction<K, V>): void;
/**
* Removes first entry.
* [📘](https://github.com/nodef/extra-lists/wiki/shift)
* Check if any value satisfies a test.
* [📘](https://github.com/nodef/extra-lists/wiki/some)
* @param x lists
* @example
* ```javascript
* var x = [['a', 'b', 'c'], [1, 2, 3]];
* shift(x).map(c => [...c]);
* // [ [ 'b', 'c' ], [ 2, 3 ] ]
*
* var x = [['a', 'b', 'c', 'd'], [1, 2, 3, 4]];
* shift(x).map(c => [...c]);
* // [ [ 'b', 'c', 'd' ], [ 2, 3, 4 ] ]
* ```
* @param ft test function (v, k, x)
* @returns true if ft(vᵢ) = true for some [kᵢ, vᵢ] ∈ x
*/
export function shift<T, U>(x: Lists<T, U>): Lists<T, U>;
declare function some<K, V>(x: Lists<K, V>, ft?: TestFunction<K, V> | null): boolean;
/**
* Gets size of lists.
* [📘](https://github.com/nodef/extra-lists/wiki/size)
* Check if all values satisfy a test.
* [📘](https://github.com/nodef/extra-lists/wiki/every)
* @param x entries
* @param ft test function (v, k, x)
* @returns true if ft(vᵢ) = true for every [kᵢ, vᵢ] ∈ x
*/
declare function every<K, V>(x: Lists<K, V>, ft: TestFunction<K, V>): boolean;
/**
* Transform values of entries.
* [📘](https://github.com/nodef/extra-lists/wiki/map)
* @param x lists
* @example
* ```javascript
* var x = [['a', 'b', 'c'], [1, 2, 3]];
* size(x);
* // 3
* ```
* @param fm map function (v, k, x)
* @returns [k₀, fm(v₀)], [k₁, fm(v₁)], ... | [kᵢ, vᵢ] ∈ x
*/
export function size<T, U>(x: Lists<T, U>): number;
declare function map<K, V, W>(x: Lists<K, V>, fm: MapFunction<K, V, W>): any[][];
/**
* Checks if any value satisfies a test.
* [📘](https://github.com/nodef/extra-lists/wiki/some)
* Reduce values of entries to a single value.
* [📘](https://github.com/nodef/extra-lists/wiki/reduce)
* @param x lists
* @param fr reduce function (acc, v, k, x)
* @param acc initial value
* @returns fr(fr(acc, v₀), v₁)... | fr(acc, v₀) = v₀ if acc not given
*/
declare function reduce<K, V, W = V>(x: Lists<K, V>, fr: ReduceFunction<K, V, V | W>, acc?: V | W): V | W;
/**
* Keep entries which pass a test.
* [📘](https://github.com/nodef/extra-lists/wiki/filter)
* @param x lists
* @param ft test function (v, k, x)
* @example
* ```javascript
* var x = [['a', 'b', 'c', 'd'], [1, 2, -3, -4]];
* some(x, v => v > 10);
* // false
*
* some(x, v => v < 0);
* // true
* ```
* @returns [k₀, v₀], [k₁, v₁], ... | ft(vᵢ) = true; [kᵢ, vᵢ] ∈ x
*/
export function some<T, U>(x: Lists<T, U>, ft?: testFn<T, U>): boolean;
declare function filter<K, V>(x: Lists<K, V>, ft: TestFunction<K, V>): Lists<K, V>;
/**
* Picks an arbitrary submap.
* [📘](https://github.com/nodef/extra-lists/wiki/subset)
* Keep entries with given keys.
* [📘](https://github.com/nodef/extra-lists/wiki/filterAt)
* @param x lists
* @param n number of entries (-1 => any)
* @param r random seed 0->1
* @example
* ```javascript
* var x = [['a', 'b', 'c', 'd'], [1, 2, 3, 4]];
* subset(x).map(c => [...c]);
* // [ [ 'b', 'c' ], [ 2, 3 ] ]
*
* subset(x, 3, 0.3).map(c => [...c]);
* // [ [ 'a', 'b', 'd' ], [ 1, 2, 4 ] ]
*
* subset(x, 2, 0.3).map(c => [...c]);
* // [ [ 'b', 'd' ], [ 2, 4 ] ]
* ```
* @param ks keys
* @returns [k₀, v₀], [k₁, v₁], ... | kᵢ ∈ ks; [kᵢ, vᵢ] ∈ x
*/
export function subset<T, U>(x: Lists<T, U>, n?: number, r?: number): Lists<T, U>;
declare function filterAt<K, V>(x: Lists<K, V>, ks: K[]): Lists<K, V>;
/**
* Lists all possible subsets.
* [📘](https://github.com/nodef/extra-lists/wiki/subsets)
* Discard entries which pass a test.
* [📘](https://github.com/nodef/extra-lists/wiki/reject)
* @param x lists
* @param n number of entries (-1 => any)
* @example
* ```javascript
* var x = [['a', 'b'], [1, 2]];
* [...subsets(x)].map(a => [[...a[0]], [...a[1]]]);
* // [
* // [ [], [] ],
* // [ [ 'a' ], [ 1 ] ],
* // [ [ 'b' ], [ 2 ] ],
* // [ [ 'a', 'b' ], [ 1, 2 ] ]
* // ]
*
* var x = [['a', 'b', 'c'], [1, 2, 3]];
* [...subsets(x)].map(a => [[...a[0]], [...a[1]]]);
* // [
* // [ [], [] ],
* // [ [ 'a' ], [ 1 ] ],
* // [ [ 'b' ], [ 2 ] ],
* // [ [ 'a', 'b' ], [ 1, 2 ] ],
* // [ [ 'c' ], [ 3 ] ],
* // [ [ 'a', 'c' ], [ 1, 3 ] ],
* // [ [ 'b', 'c' ], [ 2, 3 ] ],
* // [ [ 'a', 'b', 'c' ], [ 1, 2, 3 ] ]
* // ]
* ```
* @param ft test function (v, k, x)
* @returns [k₀, v₀], [k₁, v₁], ... | ft(vᵢ) = false; [kᵢ, vᵢ] ∈ x
*/
export function subsets<T, U>(x: Lists<T, U>, n?: number): Iterable<Lists<T, U>>;
declare function reject<K, V>(x: Lists<K, V>, ft: TestFunction<K, V>): Lists<K, V>;
/**
* Exchanges two values.
* [📘](https://github.com/nodef/extra-lists/wiki/swap)
* Discard entries with given keys.
* [📘](https://github.com/nodef/extra-lists/wiki/rejectAt)
* @param x lists
* @param k a key
* @param l another key
* @example
* ```javascript
* var x = [['a', 'b', 'c', 'd'], [1, 2, 3, 4]];
* swap(x, 'a', 'b').map(c => [...c]);
* // [ [ 'b', 'a', 'c', 'd' ], [ 1, 2, 3, 4 ] ]
*
* swap(x, 'a', 'd').map(c => [...c]);
* // [ [ 'd', 'b', 'c', 'a' ], [ 1, 2, 3, 4 ] ]
* ```
* @param ks keys
* @returns [k₀, v₀], [k₁, v₁], ... | kᵢ ∉ ks; [kᵢ, vᵢ] ∈ x
*/
export function swap<T, U>(x: Lists<T, U>, k: T, l: T): Lists<T, U>;
declare function rejectAt<K, V>(x: Lists<K, V>, ks: K[]): Lists<K, V>;
/**
* Gives entries not present in both lists.
* [📘](https://github.com/nodef/extra-lists/wiki/symmetricDifference)
* Flatten nested lists to given depth.
* [📘](https://github.com/nodef/extra-lists/wiki/flat)
* @param x nested lists
* @param n maximum depth [-1 ⇒ all]
* @param fm map function (v, k, x)
* @param ft test function for flatten (v, k, x) [is]
* @returns flat lists
*/
declare function flat<K>(x: Lists<K, any>, n?: number, fm?: MapFunction<K, any, any> | null, ft?: TestFunction<K, any> | null): Lists<K, any>;
/**
* Flatten nested lists, based on map function.
* [📘](https://github.com/nodef/extra-lists/wiki/flatMap)
* @param x nested lists
* @param fm map function (v, k, x)
* @param ft test function for flatten (v, k, x) [is]
* @returns flat lists
*/
declare function flatMap<K>(x: Lists<K, any>, fm?: MapFunction<K, any, any> | null, ft?: TestFunction<K, any> | null): Lists<K, any>;
/**
* Combine matching entries from all lists.
* [📘](https://github.com/nodef/extra-lists/wiki/zip)
* @param xs all lists
* @param fm map function (vs, k)
* @param ft end function (dones) [some]
* @param vd default value
* @returns fm([x₀[k₀], x₁[k₀], ...]), fm([x₀[k₁], x₁[k₁], ...]), ...
*/
declare function zip<K, V, W = V>(xs: Lists<K, V>[], fm?: MapFunction<K, V[], V[] | W> | null, ft?: EndFunction, vd?: V): Lists<K, V[] | W>;
/**
* Segregate values by test result.
* [📘](https://github.com/nodef/extra-lists/wiki/partition)
* @param x lists
* @param y another lists
* @example
* ```javascript
* var x = [['a', 'b', 'c', 'd'], [1, 2, 3, 4]];
* var y = [['c', 'd', 'e', 'f'], [30, 40, 50, 60]];
* symmetricDifference(x, y).map(c => [...c]);
* // [ [ 'a', 'b', 'e', 'f' ], [ 1, 2, 50, 60 ] ]
*
* var y = [['d', 'e', 'f'], [40, 50, 60]];
* symmetricDifference(x, y).map(c => [...c]);
* // [ [ 'a', 'b', 'c', 'e', 'f' ], [ 1, 2, 3, 50, 60 ] ]
* ```
* @param ft test function (v, k, x)
* @returns [satisfies, doesnt]
*/
export function symmetricDifference<T, U>(x: Lists<T, U>, y: Lists<T, U>): Lists<T, U>;
declare function partition<K, V>(x: Lists<K, V>, ft: TestFunction<K, V>): [Lists<K, V>, Lists<K, V>];
/**
* Gets lists without the first entry.
* [📘](https://github.com/nodef/extra-lists/wiki/tail)
* Segregate entries by similarity.
* [📘](https://github.com/nodef/extra-lists/wiki/partitionAs)
* @param x entries
* @param fm map function (v, k, x)
* @returns Map \{key ⇒ entries\}
*/
declare function partitionAs<K, V, W = V>(x: Lists<K, V>, fm?: MapFunction<K, V, V | W> | null): Map<V | W, Lists<K, V>>;
/**
* Break lists into chunks of given size.
* [📘](https://github.com/nodef/extra-lists/wiki/chunk)
* @param x lists
* @example
* ```javascript
* var x = [['a', 'b', 'c'], [1, 2, 3]];
* tail(x).map(c => [...c]);
* // [ [ 'b', 'c' ], [ 2, 3 ] ]
*
* var x = [['a'], [1]];
* tail(x).map(c => [...c]);
* // [ [], [] ]
* ```
* @param n chunk size [1]
* @param s chunk step [n]
* @returns [x[0..n], x[s..s+n], x[2s..2s+n], ...]
*/
export function tail<T, U>(x: Lists<T, U>): Lists<T, U>;
declare function chunk<K, V>(x: Lists<K, V>, n?: number, s?: number): Lists<K, V>[];
/**
* Keeps first n entries only.
* [📘](https://github.com/nodef/extra-lists/wiki/take)
* Append entries from all lists, preferring last.
* [📘](https://github.com/nodef/extra-lists/wiki/concat)
* @param xs all lists
* @returns x₀ ∪ x₁ ∪ ... | [x₀, x₁, ...] = xs
*/
declare function concat<K, V>(...xs: Lists<K, V>[]): Lists<K, V>;
/**
* Join lists together into a string.
* [📘](https://github.com/nodef/extra-lists/wiki/join)
* @param x lists
* @param n number of entries (1)
* @example
* ```javascript
* var x = [['a', 'b', 'c', 'd'], [1, 2, 3, 4]];
* take(x, 2).map(c => [...c]);
* // [ [ 'a', 'b' ], [ 1, 2 ] ]
*
* take(x, 3).map(c => [...c]);
* // [ [ 'a', 'b', 'c' ], [ 1, 2, 3 ] ]
* ```
* @param sep separator [,]
* @param asc associator [=]
* @returns "$\{k₀\}=$\{v₀\},$\{k₁\}=$\{v₁\}..." | [kᵢ, vᵢ] ∈ x
*/
export function take<T, U>(x: Lists<T, U>, n?: number): Lists<T, U>;
declare function join<K, V>(x: Lists<K, V>, sep?: string, asc?: string): string;
/**
* Gives lists present in any lists.
* [📘](https://github.com/nodef/extra-lists/wiki/union)
* Check if lists have no common keys.
* [📘](https://github.com/nodef/extra-lists/wiki/isDisjoint)
* @param x lists
* @param y another lists
* @param fc combine function (a, b)
* @example
* ```javascript
* var x = [['a', 'b', 'c'], [1, 2, 3]];
* var y = [['b', 'c', 'd'], [20, 30, 40]];
* union(x, y).map(v => [...v]);
* // [ [ 'a', 'b', 'c', 'd' ], [ 1, 2, 3, 40 ] ]
*
* union(x, y, (a, b) => b).map(v => [...v]);
* // [ [ 'a', 'b', 'c', 'd' ], [ 1, 20, 30, 40 ] ]
* ```
* @returns x ∩ y = Φ?
*/
export function union<T, U>(x: Lists<T, U>, y: Lists<T, U>, fc?: combineFn<U>): Lists<T, U>;
declare function isDisjoint<K, V>(x: Lists<K, V>, y: Lists<K, V>): boolean;
/**
* Gives keys present in any lists.
* Obtain keys present in any lists.
* [📘](https://github.com/nodef/extra-lists/wiki/unionKeys)
* @param xs n lists
* @example
* ```javascript
* var x = [['a', 'b', 'c', 'd'], [1, 2, 3, 4]];
* var y = [['b', 'c', 'e'], [20, 30, 50]];
* unionKeys(x, y);
* // Set(5) { 'a', 'b', 'c', 'd', 'e' }
* ```
* @param xs all lists
* @returns \{k₀, k₁, ...\} | [kᵢ, vᵢ] ∈ x₀ ∪ x₁, ...; [x₀, x₁, ...] = xs
*/
export function unionKeys<T, U>(...xs: Lists<T, U>[]): Set<T>;
declare function unionKeys<K, V>(...xs: Lists<K, V>[]): Set<K>;
/**
* Picks an arbitrary value.
* [📘](https://github.com/nodef/extra-lists/wiki/value)
* Obtain entries present in any lists.
* [📘](https://github.com/nodef/extra-lists/wiki/union)
* @param x lists
* @param r random seed 0->1
* @example
* ```javascript
* var x = [['a', 'b', 'c'], [1, 2, 3]];
* value(x);
* // 3
*
* value(x, 0.5);
* // 2
* ```
* @param y another lists
* @param fc combine function (a, b)
* @returns x ∪ y = \{[kᵢ, vᵢ] | [kᵢ, vᵢ] ∈ x or [kᵢ, vᵢ] ∈ y\}
*/
export function value<T, U>(x: Lists<T, U>, r?: number): U;
declare function union<K, V>(x: Lists<K, V>, y: Lists<K, V>, fc?: CombineFunction<V> | null): Lists<K, V>;
/**
* Lists all values.
* [📘](https://github.com/nodef/extra-lists/wiki/values)
* Obtain entries present in both lists.
* [📘](https://github.com/nodef/extra-lists/wiki/intersection)
* @param x lists
* @example
* ```javascript
* var x = [['a', 'b', 'c'], [1, 2, 3]];
* [...values(x)];
* // [ 1, 2, 3 ]
* ```
* @param y another lists
* @param fc combine function (a, b)
* @returns x ∩ y = \{[kᵢ, vᵢ] | [kᵢ, vᵢ] ∈ x and [kᵢ, vᵢ] ∈ y\}
*/
export function values<T, U>(x: Lists<T, U>): Iterable<U>;
declare function intersection<K, V>(x: Lists<K, V>, y: Lists<K, V>, fc?: CombineFunction<V> | null): Lists<K, V>;
/**
* Combines matching entries from all lists.
* [📘](https://github.com/nodef/extra-lists/wiki/zip)
* @param xs n lists
* @param fm map function (vs, k)
* @param ft till function (dones) (some)
* @param vd default value
* @example
* ```javascript
* const array = require('extra-array');
*
* var x = [['a', 'b', 'c'], [1, 2, 3]];
* var y = [['a', 'b'], [10, 20]];
* zip([x, y]).map(c => [...c]);
* // [ [ 'a', 'b' ], [ [ 1, 10 ], [ 2, 20 ] ] ] (shortest)
*
* zip([x, y], ([a, b]) => a + b).map(c => [...c]);
* // [ [ 'a', 'b' ], [ 11, 22 ] ]
*
* zip([x, y], null, array.some).map(c => [...c]);
* // [ [ 'a', 'b' ], [ [ 1, 10 ], [ 2, 20 ] ] ] (shortest)
*
* zip([x, y], null, array.every, 0).map(c => [...c]);
* // [ [ 'a', 'b', 'c' ], [ [ 1, 10 ], [ 2, 20 ], [ 3, 0 ] ] ] (longest)
* ```
* Obtain entries not present in another lists.
* [📘](https://github.com/nodef/extra-lists/wiki/difference)
* @param x lists
* @param y another lists
* @returns x = x - y = \{[kᵢ, vᵢ] | [kᵢ, vᵢ] ∈ x, [kᵢ, *] ∉ y\}
*/
export function zip<T, U, V = U>(xs: Lists<T, U>[], fm?: mapFn<T, U[], U[] | V>, ft?: tillFn, vd?: U): Lists<T, U[] | V>;
declare function difference<K, V>(x: Lists<K, V>, y: Lists<K, V>): Lists<K, V>;
/**
* Obtain entries not present in both lists.
* [📘](https://github.com/nodef/extra-lists/wiki/symmetricDifference)
* @param x lists
* @param y another lists
* @returns x = x-y ∪ y-x
*/
declare function symmetricDifference<K, V>(x: Lists<K, V>, y: Lists<K, V>): Lists<K, V>;
export {};
}
export { CombineFunction, CompareFunction, EndFunction, Entries, Lists, MapFunction, ProcessFunction, ReadFunction, ReduceFunction, TestFunction, chunk, compare, concat, count, countAs, difference, drop, entries, randomEntry as entry, every, filter, filterAt, find, findAll, flat, flatMap, forEach, fromEntries, get, getAll, getPath, has, hasEntry, hasPath, hasSubset, hasValue, head, intersection, is, isDisjoint, isEmpty, isEqual, join, randomKey as key, keys, size as length, map, max, maxEntry, min, minEntry, partition, partitionAs, randomEntry, randomKey, randomSubset, randomValue, range, rangeEntries, reduce, reject, rejectAt, remove, search, searchAll, searchValue, searchValueAll, set, size, some, randomSubset as subset, subsets, swap, symmetricDifference, tail, take, union, unionKeys, randomValue as value, values, zip };

1357

index.js
'use strict';
Object.defineProperty(exports, '__esModule', { value: true });
function id(v) {
function IDENTITY$3(v) {
return v;
}
function keys(x) {
return x[0];
function COMPARE$3(a, b) {
return a < b ? -1 : (a > b ? 1 : 0);
}
function values(x) {
return x[1];
function IDENTITY$2(v) {
return v;
}
function* entries(x) {
var vi = values(x)[Symbol.iterator]();
for (var k of keys(x))
yield [k, vi.next().value];
function COMPARE$2(a, b) {
return a < b ? -1 : (a > b ? 1 : 0);
}
function id$1(v) {
return v;
const END = Number.MAX_SAFE_INTEGER;
function is$1(v) {
return v != null && typeof v[Symbol.iterator] === "function";
}
function* cartesianProduct(xs, fm = null) {
var fm = fm || id$1;
var XS = xs.length;
var kss = xs.map(x => [...x.keys()]);
var ls = kss.map(ks => ks.length);
var is = kss.map(ks => 0);
for (var j = 0;; j++) {
var a = new Map();
for (var n = 0; n < XS; n++) {
var i = is[n], x = xs[n];
var ks = kss[n], k = ks[i];
a.set(k, x.get(k));
function isList(v) {
return is$1(v) && typeof v !== "string";
}
function isOnce(x) {
return x[Symbol.iterator]() === x;
}
function toMany(x, now = false) {
if (!isOnce(x))
return x;
return now ? Array.from(x) : toManyLate(x[Symbol.iterator](), []);
}
function toManyLate(ix, a) {
return {
[Symbol.iterator]: () => {
var i = -1;
return {
next: () => {
if (++i < a.length)
return { value: a[i], done: false };
var { value, done } = ix.next();
if (!done)
a[i] = value;
return { value, done };
}
};
}
yield fm(a, j, null);
for (var r = XS - 1; r >= 0; r--) {
is[r]++;
if (is[r] < ls[r])
break;
is[r] = 0;
}
if (r < 0)
break;
}
};
}
function filterAt(x, ks) {
var a = new Map();
for (var k of ks)
a.set(k, x.get(k));
return a;
function isEmpty$1(x) {
for (var _ of x)
return false;
return true;
}
function cmp(a, b) {
return a < b ? -1 : (a > b ? 1 : 0);
function length(x, i = 0, I = END) {
var j = -1, n = 0;
for (var _ of x)
if (++j >= i && j < I)
++n;
return n;
}
function unionKeys(...xs) {
var a = new Set();
for (var x of xs) {
for (var [k] of x)
a.add(k);
}
return a;
function slice(x, i = 0, I = END) {
if (i >= 0 && I >= 0)
return slicePos(x, i, I);
else if (i >= 0 && I < 0)
return slicePosNeg(x, i, I);
else
return sliceNeg(x, i, I);
}
function concat$(x, ...ys) {
for (var y of ys) {
for (var [k, v] of y)
x.set(k, v);
function* slicePos(x, i, I) {
var k = -1;
for (var v of x) {
if (++k >= I)
break;
if (k >= i)
yield v;
}
return x;
}
function count(x, fn) {
var a = 0;
for (var [k, v] of x)
if (fn(v, k, x))
a++;
return a;
}
function countAs(x, fm) {
var fm = fm || id$1;
var a = new Map();
for (var [k, v] of x) {
var v1 = fm(v, k, x);
var n = a.get(v1) || 0;
a.set(v1, n + 1);
function* slicePosNeg(x, i, I) {
var j = 0, k = -1;
var a = [], A = -I;
for (var v of x) {
if (++k < i)
continue;
if (a.length >= A)
yield a[j];
a[j] = v;
j = (j + 1) % A;
}
return a;
}
function index(x, i = 0) {
return i < 0 ? Math.max(x.length + i, 0) : Math.min(i, x.length);
}
function fromRange(v, V = v, s = 1) {
var a = [];
if (s >= 0) {
for (; v < V; v += s)
a.push(v);
function* sliceNeg(x, i, I) {
var j = 0, X = 0;
var a = [], A = -i;
for (var v of x) {
a[j] = v;
j = (j + 1) % A;
++X;
}
else {
for (; v > V; v += s)
a.push(v);
}
return a;
var i = Math.max(X + i, 0);
var I = I < 0 ? Math.max(X + I, 0) : Math.min(I, X);
var n = Math.max(I - i, 0);
var J = Math.max(j + n - A, 0);
yield* a.slice(j, j + n);
yield* a.slice(0, J);
}
function get(x, i) {
return x[index(x, i)];
function head$1(x, vd) {
for (var v of x)
return v;
return vd;
}
function getAll(x, is) {
return is.map(i => get(x, i));
function take$1(x, n = 1) {
return slice(x, 0, n);
}
function random(r) {
var a = Math.floor(r * 2 ** 31);
return function () {
var t = a += 0x6D2B79F5;
t = Math.imul(t ^ t >>> 15, t | 1);
t ^= t + Math.imul(t ^ t >>> 7, t | 61);
return ((t ^ t >>> 14) >>> 0) / 4294967296;
};
function drop$1(x, n = 1) {
return slice(x, n);
}
function permutation$(x, n = -1, r = Math.random()) {
if (n > x.length)
return x;
var X = x.length, rnd = random(r);
var n = n >= 0 ? n : Math.floor((X + 1) * rnd());
for (var i = 0; i < n; i++) {
var j = i + Math.floor((X - i) * rnd());
var t = x[i];
x[i] = x[j];
x[j] = t;
function searchValue$2(x, v, fc = null, fm = null) {
var fc = fc || COMPARE$2;
var fm = fm || IDENTITY$2;
var v1 = fm(v, 0, null), i = -1;
for (var u of x) {
var u1 = fm(u, ++i, x);
if (fc(u1, v1) === 0)
return i;
}
x.length = n;
return x;
return -1;
}
function subsequenceNum(x, n, r) {
var is = fromRange(0, x.length, 1);
permutation$(is, n, r).sort();
return getAll(x, is);
function hasValue$1(x, v, fc = null, fm = null) {
return searchValue$2(x, v, fc, fm) >= 0;
}
function subsequenceAny(x, r) {
var rnd = random(r), a = [];
function* map$1(x, fm) {
var i = -1;
for (var v of x)
if (rnd() >= 0.5)
a.push(v);
return a;
yield fm(v, ++i, x);
}
function subsequence(x, n = -1, r = Math.random()) {
var X = x.length;
if (n >= 0)
return n > X ? null : subsequenceNum(x, n, r);
return subsequenceAny(x, r);
function* concat$2(...xs) {
for (var x of xs)
yield* x;
}
function* subsequences(x, n = -1) {
var X = x.length;
if (n >= X) {
if (n === X)
yield x;
return;
}
if (n === 0 || X === 0) {
yield [];
return;
}
var y = x.slice(0, -1);
yield* subsequences(y, n);
for (var s of subsequences(y, n - 1)) {
s.push(x[X - 1]);
yield s;
}
function IDENTITY$1$1(v) {
return v;
}
function scanWhile(x, ft) {
for (var [k, v] of x)
if (!ft(v, k, x))
return k;
function randomValue$1(x, fr = Math.random) {
var i = Math.floor(fr() * x.length);
return x[i];
}
function every(x, ft) {
return scanWhile(x, ft) === undefined;
function some$3(x, ft = null) {
if (ft)
return x.some(ft);
else
return someBoolean$1(x);
}
function find(x, ft) {
for (var [k, v] of x)
if (ft(v, k, x))
return v;
function someBoolean$1(x) {
for (var i = 0, I = x.length; i < I; ++i)
if (x[i])
return true;
return false;
}
function findAll(x, ft) {
function zip$2(xs, fm = null, fe = null, vd) {
var fm = fm || IDENTITY$1$1;
var fe = fe || some$3;
var X = xs.length, a = [];
if (X === 0)
return a;
var ds = new Array(X).fill(false);
var ls = xs.map(x => x.length);
for (var i = 0;; ++i) {
for (var j = 0, vs = []; j < X; ++j) {
ds[j] = i >= ls[j];
vs[j] = ds[j] ? vd : xs[j][i];
}
if (fe(ds))
break;
a.push(fm(vs, i, null));
}
return a;
}
function chunk$1(x, n = 1, s = n) {
var a = [];
for (var [k, v] of x)
if (ft(v, k, x))
a.push(v);
for (var i = 0, I = x.length; i < I; i += s)
a.push(x.slice(i, i + n));
return a;
}
function forEach(x, fc) {
for (var [k, v] of x)
fc(v, k, x);
function concat$1(...xs) {
return concat$$1(new Set(), ...xs);
}
function fromLists(ls) {
var [ks, vs] = ls, vi = vs[Symbol.iterator]();
var a = new Map();
for (var k of ks)
a.set(k, vi.next().value);
return a;
function concat$$1(x, ...ys) {
for (var y of ys) {
for (var v of y)
x.add(v);
}
return x;
}
function getAll$1(x, ks) {
return ks.map(k => x.get(k));
}
function hasSubset(x, y, fc = null, fm = null) {
var fc = fc || cmp, fm = fm || id$1;
for (var [k, v] of y) {
if (!x.has(k))
function isDisjoint$1(x, y) {
for (var v of y)
if (x.has(v))
return false;
var u1 = fm(x.get(k), k, x);
var v1 = fm(v, k, y);
if (fc(u1, v1) !== 0)
return false;
}
return true;
}
function searchValue(x, v, fc = null, fm = null) {
var fc = fc || cmp, fm = fm || id$1;
var v1 = fm(v, null, null);
for (var [k, u] of x) {
var u1 = fm(u, k, x);
if (fc(u1, v1) === 0)
return k;
}
function IDENTITY$1(v) {
return v;
}
function someBool(x) {
for (var v of x)
if (v)
return true;
return false;
function COMPARE$1(a, b) {
return a < b ? -1 : (a > b ? 1 : 0);
}
function someTest(x, ft) {
var i = -1;
for (var v of x)
if (ft(v, ++i, x))
return true;
return false;
function* keys$1(x) {
for (var [k] of x)
yield k;
}
function some(x, ft = null) {
if (ft)
return someTest(x, ft);
else
return someBool(x);
function* values$1(x) {
for (var [, v] of x)
yield v;
}
function intersection(x, y, fc = null) {
var fc = fc || id$1;
function get$2(x, k) {
for (var [j, u] of x)
if (j === k)
return u;
}
function count$1(x, ft) {
var a = 0;
for (var [k, v] of x)
if (ft(v, k, x))
++a;
return a;
}
function countAs$1(x, fm = null) {
var fm = fm || IDENTITY$1;
var a = new Map();
for (var [k, v] of y)
if (x.has(k))
a.set(k, fc(x.get(k), v));
for (var [k, v] of x) {
var w = fm(v, k, x);
var n = a.get(w) || 0;
a.set(w, n + 1);
}
return a;
}
function join(x, sep = ",", asc = "=") {
var a = "";
for (var [k, v] of x)
a += k + asc + v + sep;
return a.slice(0, -sep.length);
}
function range(x, fc = null, fm = null) {
var fc = fc || cmp, fm = fm || id$1;
function rangeEntries$1(x, fc = null, fm = null) {
var fc = fc || COMPARE$1;
var fm = fm || IDENTITY$1;
var mk, mu, mv;

@@ -270,12 +255,68 @@ var nk, nu, nv;

}
i++;
++i;
}
return [[mk, mu], [nk, nu]];
}
function reduce(x, fr, acc) {
function find$1(x, ft) {
for (var [k, v] of x)
if (ft(v, k, x))
return v;
}
function* findAll$1(x, ft) {
for (var [k, v] of x)
if (ft(v, k, x))
yield v;
}
function search$1(x, ft) {
for (var [k, v] of x)
if (ft(v, k, x))
return k;
}
function* searchAll$1(x, ft) {
for (var [k, v] of x)
if (ft(v, k, x))
yield k;
}
function searchValue$1(x, v, fc = null, fm = null) {
var fc = fc || COMPARE$1;
var fm = fm || IDENTITY$1;
var w = fm(v, null, null);
for (var [k, u] of x) {
var wx = fm(u, k, x);
if (fc(wx, w) === 0)
return k;
}
}
function* searchValueAll$1(x, v, fc = null, fm = null) {
var fc = fc || COMPARE$1;
var fm = fm || IDENTITY$1;
var w = fm(v, null, null);
for (var [k, u] of x) {
var wx = fm(u, k, x);
if (fc(wx, w) === 0)
yield k;
}
}
function forEach$1(x, fp) {
for (var [k, v] of x)
fp(v, k, x);
}
function some$2(x, ft) {
for (var [k, v] of x)
if (ft(v, k, x))
return true;
return false;
}
function every$1(x, ft) {
for (var [k, v] of x)
if (!ft(v, k, x))
return false;
return true;
}
function reduce$1(x, fr, acc) {
var init = arguments.length <= 2;
for (var [k, v] of x) {
if (init) {
init = false;
acc = v;
init = false;
}

@@ -287,143 +328,108 @@ else

}
function search(x, ft) {
function join$1(x, sep = ",", asc = "=") {
var a = "";
for (var [k, v] of x)
if (ft(v, k, x))
return k;
a += k + asc + v + sep;
return a.slice(0, -sep.length);
}
function scanUntil(x, ft) {
return search(x, ft);
function IDENTITY(v) {
return v;
}
function searchAll(x, ft) {
var a = [];
for (var [k, v] of x)
if (ft(v, k, x))
a.push(k);
return a;
function COMPARE(a, b) {
return a < b ? -1 : (a > b ? 1 : 0);
}
function searchValueAll(x, v, fc = null, fm = null) {
var fc = fc || cmp, fm = fm || id$1;
var v1 = fm(v, null, x), a = [];
for (var [k, u] of x) {
var u1 = fm(u, k, x);
if (fc(u1, v1) === 0)
a.push(k);
}
function fromRange(v, V, dv = 1) {
var n = (V - v) / dv, a = [];
for (var i = 0; i < n; ++i, v += dv)
a.push(v);
return a;
}
function some$1(x, ft) {
return scanUntil(x, ft) !== undefined;
function index(x, i) {
var X = x.length;
return i >= 0 ? Math.min(i, X) : Math.max(X + i, 0);
}
function subset(x, n = -1, r = Math.random()) {
var ks = subsequence([...x.keys()], n, r);
return filterAt(x, ks);
function get$1(x, i) {
return x[index(x, i)];
}
function* subsets(x, n = -1) {
for (var ks of subsequences([...x.keys()], n))
yield filterAt(x, ks);
function getAll$1(x, is) {
return is.map(i => get$1(x, i));
}
function symmetricDifference$(x, y) {
for (var [k, v] of y) {
if (x.has(k))
x.delete(k);
else
x.set(k, v);
function* subsequences(x, n = -1) {
var X = x.length;
if (n > X)
return;
if (n === X) {
yield x;
return;
}
return x;
}
function symmetricDifference(x, y) {
return symmetricDifference$(new Map(x), y);
}
function union$(x, y, fc = null) {
var fc = fc || id$1;
for (var [k, v] of y) {
if (!x.has(k))
x.set(k, v);
else
x.set(k, fc(x.get(k), v));
if (n === 0 || X === 0) {
yield [];
return;
}
return x;
}
function union(x, y, fc = null) {
return union$(new Map(x), y, fc);
}
function zip(xs, fm = null, ft = null, vd) {
var fm = fm || id$1, ft = ft || some;
var ks = unionKeys(...xs), a = new Map();
for (var k of ks) {
var ds = xs.map(x => !x.has(k));
if (ft(ds))
break;
var vs = xs.map(x => !x.has(k) ? vd : x.get(k));
a.set(k, fm(vs, k, null));
var y = x.slice(0, -1);
yield* subsequences(y, n);
for (var s of subsequences(y, n - 1)) {
s.push(x[X - 1]);
yield s;
}
return a;
}
function* cartesianProduct$1(xs, fm = null) {
var fm = fm || id, ys = xs.map(x => new Map(entries(x)));
yield* cartesianProduct(ys, (vs, i) => fm([vs.keys(), vs.values()], i, null));
function randomSubsequence(x, n = -1, fr = Math.random) {
var X = x.length;
if (n > X)
return null;
if (n >= 0)
return randomSubsequenceFixed(x, n, fr);
else
return randomSubsequenceAll(x, fr);
}
function id$2(v) {
return v;
function randomSubsequenceFixed(x, n, fr) {
var is = fromRange(0, x.length);
randomPermutation$(is, n, fr).sort();
return getAll$1(x, is);
}
function chunk(x, n = 1, s = n) {
function randomSubsequenceAll(x, fr) {
var a = [];
for (var i = 0, I = x.length; i < I; i += s)
a.push(x.slice(i, i + n));
for (var v of x)
if (fr() < 0.5)
a.push(v);
return a;
}
function someBool$1(x) {
for (var i = 0, I = x.length; i < I; i++)
if (x[i])
return true;
return false;
function randomPermutation$(x, n = -1, fr = Math.random) {
var X = x.length;
if (n > X)
return x;
var n = n >= 0 ? n : Math.floor((X + 1) * fr());
for (var i = 0; i < n; ++i) {
var j = i + Math.floor((X - i) * fr());
var t = x[i];
x[i] = x[j];
x[j] = t;
}
x.length = n;
return x;
}
function some$2(x, ft = null) {
function some$1(x, ft = null) {
if (ft)
return x.some(ft);
else
return someBool$1(x);
return someBoolean(x);
}
function value(x, r = Math.random()) {
var i = Math.floor(r * x.length);
return x[i];
function someBoolean(x) {
for (var i = 0, I = x.length; i < I; ++i)
if (x[i])
return true;
return false;
}
function zip$1(xs, fm = null, ft = null, vd) {
var fm = fm || id$2, ft = ft || some$2;
var X = xs.length, a = [];
if (X === 0)
return a;
var ds = new Array(X).fill(false);
var ls = xs.map(x => x.length);
for (var i = 0;; i++) {
for (var j = 0, vs = []; j < X; j++) {
ds[j] = i >= ls[j];
vs[j] = ds[j] ? vd : xs[j][i];
}
if (ft(ds))
break;
a.push(fm(vs, i, null));
}
function fromLists(x) {
var [ks, vs] = x;
var iv = vs[Symbol.iterator]();
var a = new Map();
for (var k of ks)
a.set(k, iv.next().value);
return a;
}
function chunk$1(x, n = 1, s = n) {
var kss = chunk([...keys(x)], n, s);
var vss = chunk([...values(x)], n, s);
return zip$1([kss, vss]);
}
function id$3(v) {
return v;
}
function cmp$1(a, b) {
return a < b ? -1 : (a > b ? 1 : 0);
}
function unionKeys$1(...xs) {
var a = new Set();
for (var x of xs) {
for (var [k] of x)
a.add(k);
}
return a;
}
function compare(x, y, fc = null, fm = null) {
var fc = fc || cmp$1, fm = fm || id$3;
function compare$1(x, y, fc = null, fm = null) {
var fc = fc || COMPARE;
var fm = fm || IDENTITY;
var ks = unionKeys$1(x, y);

@@ -435,5 +441,5 @@ for (var k of ks) {

return 1;
var u = fm(x.get(k), k, x);
var v = fm(y.get(k), k, y);
var c = fc(u, v);
var vx = fm(x.get(k), k, x);
var vy = fm(y.get(k), k, y);
var c = fc(vx, vy);
if (c !== 0)

@@ -444,287 +450,263 @@ return c;

}
function compare$1(x, y, fc = null, fm = null) {
return compare(new Map(x), new Map(y), fc, fm);
function getAll$2(x, ks) {
return ks.map(k => x.get(k));
}
function get$1(x, k) {
for (var [j, u] of x)
if (k === j)
return u;
function* subsets$1(x, n = -1) {
for (var ks of subsequences([...x.keys()], n))
yield filterAt$1(x, ks);
}
function compare$2(x, y, fc, fm) {
return compare$1(entries(x), entries(y), fc, fm);
function randomSubset$1(x, n = -1, fr = Math.random) {
var ks = randomSubsequence([...x.keys()], n, fr);
return filterAt$1(x, ks);
}
function is(v) {
return v != null && typeof v[Symbol.iterator] === "function";
function hasSubset$1(x, y, fc = null, fm = null) {
var fc = fc || COMPARE;
var fm = fm || IDENTITY;
for (var [k, v] of y) {
if (!x.has(k))
return false;
var wx = fm(x.get(k), k, x);
var wy = fm(v, k, y);
if (fc(wx, wy) !== 0)
return false;
}
return true;
}
function* concat(...xs) {
for (var x of xs)
yield* x;
function filterAt$1(x, ks) {
var a = new Map();
for (var k of ks)
a.set(k, x.get(k));
return a;
}
const END = Number.MAX_SAFE_INTEGER;
function* slicePos(x, i, I) {
var k = -1;
for (var v of x) {
if (++k >= I)
function zip$1(xs, fm = null, fe = null, vd) {
var fm = fm || IDENTITY;
var fe = fe || some$1;
var ks = unionKeys$1(...xs), a = new Map();
for (var k of ks) {
var ds = xs.map(x => !x.has(k));
if (fe(ds))
break;
if (k >= i)
yield v;
var vs = xs.map(x => !x.has(k) ? vd : x.get(k));
a.set(k, fm(vs, k, null));
}
return a;
}
function* slicePosNeg(x, i, I) {
var j = 0, k = -1;
var a = [], A = -I;
for (var v of x) {
if (++k < i)
continue;
if (a.length >= A)
yield a[j];
a[j] = v;
j = (j + 1) % A;
function concat$(x, ...ys) {
for (var y of ys) {
for (var [k, v] of y)
x.set(k, v);
}
return x;
}
function* sliceNeg(x, i, I) {
var j = 0, n = 0;
var a = [], A = -i;
for (var v of x) {
a[j] = v;
j = (j + 1) % A;
n++;
function unionKeys$1(...xs) {
var a = new Set();
for (var x of xs) {
for (var [k] of x)
a.add(k);
}
if (n < A)
return;
var I = I < 0 ? I : Math.min(I - n, 0);
var n = Math.max(I - i, 0);
var J = Math.max(j + n - A, 0);
yield* a.slice(j, j + n);
yield* a.slice(0, J);
return a;
}
function* slice(x, i = 0, I = END) {
if (i >= 0 && I >= 0)
yield* slicePos(x, i, I);
else if (i >= 0 && I < 0)
yield* slicePosNeg(x, i, I);
else
yield* sliceNeg(x, i, I);
function union$1(x, y, fc = null) {
return union$(new Map(x), y, fc);
}
function size(x, i = 0, I = END) {
var j = -1, n = 0;
for (var _ of x)
if (++j >= i && j < I)
n++;
return n;
function union$(x, y, fc = null) {
var fc = fc || IDENTITY;
for (var [k, v] of y) {
if (!x.has(k))
x.set(k, v);
else
x.set(k, fc(x.get(k), v));
}
return x;
}
function id$1$1(v) {
return v;
function intersection$1(x, y, fc = null) {
var fc = fc || IDENTITY;
var a = new Map();
for (var [k, v] of y)
if (x.has(k))
a.set(k, fc(x.get(k), v));
return a;
}
function cmp$1$1(a, b) {
return a < b ? -1 : (a > b ? 1 : 0);
function symmetricDifference$1(x, y) {
return symmetricDifference$(new Map(x), y);
}
function searchValue$1(x, v, fc = null, fm = null) {
var fc = fc || cmp$1$1, fm = fm || id$1$1;
var v1 = fm(v, 0, null), i = -1;
for (var u of x) {
var u1 = fm(u, ++i, x);
if (fc(u1, v1) === 0)
return i;
function symmetricDifference$(x, y) {
for (var [k, v] of y) {
if (x.has(k))
x.delete(k);
else
x.set(k, v);
}
return -1;
return x;
}
function* map(x, fm) {
var i = -1;
for (var v of x)
yield fm(v, ++i, x);
function is(v) {
return Array.isArray(v) && v.length === 2 && isList(v[0]) && isList(v[1]);
}
function* drop(x, n = 1) {
yield* slice(x, n);
function keys(x) {
return x[0];
}
function isList(v) {
return is(v) && typeof v !== "string";
function values(x) {
return x[1];
}
function head(x, vd) {
for (var v of x)
return v;
return vd;
function* entries(x) {
var iv = values(x)[Symbol.iterator]();
for (var k of keys(x))
yield [k, iv.next().value];
}
function searchValue$1$1(x, v, fc = null, fm = null) {
return searchValue$1(x, v, fc, fm);
function fromEntries(x) {
var ex = toMany(x);
return [keys$1(ex), values$1(ex)];
}
function hasValue(x, v, fc = null, fm = null) {
return searchValue$1$1(x, v, fc, fm) >= 0;
function size(x) {
return length(keys(x));
}
function isEmpty(x) {
for (var _ of x)
return false;
return true;
return isEmpty$1(keys(x));
}
function* take(x, n = 1) {
yield* slice(x, 0, n);
function compare(x, y, fc = null, fm = null) {
return compare$1(fromLists(x), fromLists(y), fc, fm);
}
function concat$1(...xs) {
var ks = concat(...xs.map(keys));
var vs = concat(...xs.map(values));
return [ks, vs];
function isEqual(x, y, fc = null, fm = null) {
return compare(x, y, fc, fm) === 0;
}
function count$1(x, ft) {
return count(entries(x), ft);
function get(x, k) {
return get$2(entries(x), k);
}
function countAs$1(x, fm = null) {
return countAs(entries(x), fm);
function getAll(x, ks) {
return getAll$2(fromLists(x), ks);
}
function difference(x, y) {
var a = fromLists(x);
for (var k of keys(y))
a.delete(k);
return [a.keys(), a.values()];
function getPath(x, p) {
for (var k of p)
x = is(x) ? get(x, k) : undefined;
return x;
}
function drop$1(x, n = 1) {
var ks = drop(keys(x), n);
var vs = drop(values(x), n);
function hasPath(x, p) {
return getPath(x, p) !== undefined;
}
function set(x, k, v) {
var ks = [], vs = [];
for (var [j, u] of entries(x)) {
ks.push(j);
vs.push(j === k ? v : u);
}
return [ks, vs];
}
function entry(x, r = Math.random()) {
return value([...entries(x)], r);
function swap(x, k, l) {
var ks = map$1(keys(x), j => j === k ? l : (j === l ? k : j));
return [ks, values(x)];
}
function every$1(x, ft) {
return every(entries(x), ft);
}
function filter(x, ft) {
function remove(x, k) {
var ks = [], vs = [];
for (var [k, v] of entries(x))
if (ft(v, k, x)) {
ks.push(k);
vs.push(v);
}
for (var [j, u] of entries(x)) {
if (j === k)
continue;
ks.push(j);
vs.push(u);
}
return [ks, vs];
}
function filterAt$1(x, ks) {
var js = [], us = [];
for (var [k, v] of entries(x))
if (ks.includes(k)) {
js.push(k);
us.push(v);
}
return [js, us];
function head(x, ed = []) {
return head$1(entries(x), ed);
}
function find$1(x, ft) {
return find(entries(x), ft);
function tail(x) {
return drop(x, 1);
}
function findAll$1(x, ft) {
return findAll(entries(x), ft);
function take(x, n = 1) {
var ks = take$1(keys(x), n);
var vs = take$1(values(x), n);
return [ks, vs];
}
function is$1(v) {
return Array.isArray(v) && v.length === 2 && isList(v[0]) && isList(v[1]);
function drop(x, n = 1) {
var ks = drop$1(keys(x), n);
var vs = drop$1(values(x), n);
return [ks, vs];
}
function flatTo(x, n, fm, ft, a) {
for (var [k, v] of entries(x)) {
var v1 = fm(v, k, x);
if (n !== 0 && ft(v1, k, x))
flatTo(v1, n - 1, fm, ft, a);
else
a.set(k, v1);
}
return a;
function count(x, ft) {
return count$1(entries(x), ft);
}
function flat(x, n = -1, fm = null, ft = null) {
var fm = fm || id, ft = ft || is$1;
var a = flatTo(x, n, fm, ft, new Map());
return [a.keys(), a.values()];
function countAs(x, fm = null) {
return countAs$1(entries(x), fm);
}
function flatMap(x, fm = null, ft = null) {
var fm = fm || id, ft = ft || is$1;
var a = new Map();
for (var [k, v] of entries(x)) {
var v1 = fm(v, k, x);
if (ft(v1, k, x))
concat$(a, entries(v1));
else
a.set(k, v1);
}
return [a.keys(), a.values()];
function min(x, fc = null, fm = null) {
return rangeEntries(x, fc, fm)[0][1];
}
function forEach$1(x, fc) {
forEach(entries(x), fc);
function minEntry(x, fc = null, fm = null) {
return rangeEntries(x, fc, fm)[0];
}
function fromEntries(es) {
var a = new Map(es);
return [a.keys(), a.values()];
function max(x, fc = null, fm = null) {
return rangeEntries(x, fc, fm)[1][1];
}
function get$2(x, k) {
return get$1(entries(x), k);
function maxEntry(x, fc = null, fm = null) {
return rangeEntries(x, fc, fm)[1];
}
function getAll$2(x, ks) {
return getAll$1(new Map(entries(x)), ks);
function range(x, fc = null, fm = null) {
var [a, b] = rangeEntries(x, fc, fm);
return [a[1], b[1]];
}
function getPath(x, p) {
for (var k of p)
x = is$1(x) ? get$2(x, k) : undefined;
return x;
function rangeEntries(x, fc = null, fm = null) {
return rangeEntries$1(entries(x), fc, fm);
}
function has(x, k) {
return hasValue(keys(x), k);
function* subsets(x, n = -1) {
for (var a of subsets$1(fromLists(x), n))
yield [a.keys(), a.values()];
}
function cmp$2(a, b) {
return a < b ? -1 : (a > b ? 1 : 0);
function randomKey(x, fr = Math.random) {
return randomValue$1([...keys(x)], fr);
}
function hasEntry(x, e, fc = null, fm = null) {
var fc = fc || cmp$2, fm = fm || id, [k, v] = e;
var [k, v] = e, u = get$2(x, k);
return fc(fm(u, k, x), v) === 0;
function randomValue(x, fr = Math.random) {
return randomValue$1([...values(x)], fr);
}
function hasPath(x, p) {
return getPath(x, p) !== undefined;
function randomEntry(x, fr = Math.random) {
return randomValue$1([...entries(x)], fr);
}
function hasSubset$1(x, y, fc = null, fm = null) {
return hasSubset(new Map(entries(x)), entries(y), fc, fm);
function randomSubset(x, n = -1, fr = Math.random) {
var a = randomSubset$1(fromLists(x), n, fr);
return [a.keys(), a.values()];
}
function searchValue$2(x, v, fc = null, fm = null) {
return searchValue(entries(x), v, fc, fm);
function has(x, k) {
return hasValue$1(keys(x), k);
}
function hasValue$1(x, v, fc = null, fm = null) {
return searchValue$2(x, v, fc, fm) !== undefined;
function hasValue(x, v, fc = null, fm = null) {
return searchValue(x, v, fc, fm) !== undefined;
}
function head$1(x, ed = []) {
return head(entries(x), ed);
function hasEntry(x, e, fc = null, fm = null) {
var fc = fc || COMPARE$3;
var fm = fm || IDENTITY$3;
var [k, v] = e, u = get(x, k);
var u1 = fm(u, k, x);
var v1 = fm(v, k, x);
return fc(u1, v1) === 0;
}
function intersection$1(x, y, fc = null) {
var a = intersection(new Map(entries(x)), entries(y), fc);
return [a.keys(), a.values()];
function hasSubset(x, y, fc = null, fm = null) {
return hasSubset$1(fromLists(x), fromLists(y), fc, fm);
}
function concat$$1(x, ...ys) {
for (var y of ys) {
for (var v of y)
x.add(v);
}
return x;
function find(x, ft) {
return find$1(entries(x), ft);
}
function concat$2(...xs) {
return concat$$1(new Set(), ...xs);
function findAll(x, ft) {
return findAll$1(entries(x), ft);
}
function isDisjoint(x, y) {
for (var v of y)
if (x.has(v))
return false;
return true;
function search(x, ft) {
return search$1(entries(x), ft);
}
function isDisjoint$1(x, y) {
return isDisjoint(new Set(keys(x)), keys(y));
function searchAll(x, ft) {
return searchAll$1(entries(x), ft);
}
function isEmpty$1(x) {
return isEmpty(keys(x));
function searchValue(x, v, fc = null, fm = null) {
return searchValue$1(entries(x), v, fc, fm);
}
function isEqual(x, y, fc = null, fm = null) {
return compare$2(x, y, fc, fm) === 0;
function searchValueAll(x, v, fc = null, fm = null) {
return searchValueAll$1(entries(x), v, fc, fm);
}
function join$1(x, sep = ',', asc = '=') {
return join(entries(x), sep, asc);
function forEach(x, fc) {
forEach$1(entries(x), fc);
}
function key(x, r = Math.random()) {
return value([...keys(x)], r);
function some(x, ft = null) {
return some$2(entries(x), ft);
}
function size$1(x) {
return size(keys(x));
function every(x, ft) {
return every$1(entries(x), ft);
}
function length(x) {
return size$1(x);
}
function map$1(x, fm) {
function map(x, fm) {
var ks = [], vs = [];

@@ -737,41 +719,24 @@ for (var [k, v] of entries(x)) {

}
function range$1(x, fc = null, fm = null) {
return range(entries(x), fc, fm);
function reduce(x, fr, acc) {
var A = arguments.length, es = entries(x);
return A > 2 ? reduce$1(es, fr, acc) : reduce$1(es, fr);
}
function max(x, fc = null, fm = null) {
return range$1(x, fc, fm)[1];
}
function min(x, fc = null, fm = null) {
return range$1(x, fc, fm)[0];
}
function partition(x, ft) {
var tk = [], tv = [], fk = [], fv = [];
for (var [k, v] of entries(x)) {
function filter(x, ft) {
var ks = [], vs = [];
for (var [k, v] of entries(x))
if (ft(v, k, x)) {
tk.push(k);
tv.push(v);
ks.push(k);
vs.push(v);
}
else {
fk.push(k);
fv.push(v);
return [ks, vs];
}
function filterAt(x, ks) {
var js = [], us = [];
for (var [k, v] of entries(x))
if (ks.includes(k)) {
js.push(k);
us.push(v);
}
}
return [[tk, tv], [fk, fv]];
return [js, us];
}
function partitionAs(x, fm = null) {
var fm = fm || id, a = new Map();
for (var [k, v] of entries(x)) {
var v1 = fm(v, k, x);
if (!a.has(v1))
a.set(v1, [[], []]);
var [ak, av] = a.get(v1);
ak.push(k);
av.push(v);
}
return a;
}
function reduce$1(x, fr, acc) {
var A = arguments.length, es = entries(x);
return A > 2 ? reduce(es, fr, acc) : reduce(es, fr);
}
function reject(x, ft) {

@@ -795,99 +760,121 @@ var ks = [], vs = [];

}
function remove(x, k) {
var ks = [], vs = [];
for (var [j, u] of entries(x))
if (j !== k) {
ks.push(j);
vs.push(u);
}
return [ks, vs];
function flat(x, n = -1, fm = null, ft = null) {
var fm = fm || IDENTITY$3;
var ft = ft || is;
var a = flatTo$(new Map(), x, n, fm, ft);
return [a.keys(), a.values()];
}
function scanUntil$1(x, ft) {
return scanUntil(entries(x), ft);
function flatTo$(a, x, n, fm, ft) {
for (var [k, v] of entries(x)) {
var v1 = fm(v, k, x);
if (n !== 0 && ft(v1, k, x))
flatTo$(a, v1, n - 1, fm, ft);
else
a.set(k, v1);
}
return a;
}
function scanWhile$1(x, ft) {
return scanWhile(entries(x), ft);
function flatMap(x, fm = null, ft = null) {
var fm = fm || IDENTITY$3;
var ft = ft || is;
var a = new Map();
for (var [k, v] of entries(x)) {
var w = fm(v, k, x);
if (ft(w, k, x))
concat$(a, entries(w));
else
a.set(k, w);
}
return [a.keys(), a.values()];
}
function search$1(x, ft) {
return search(entries(x), ft);
function zip(xs, fm = null, ft = null, vd) {
var a = zip$1(xs.map(x => new Map(entries(x))), fm, ft, vd);
return [a.keys(), a.values()];
}
function searchAll$1(x, ft) {
return searchAll(entries(x), ft);
function partition(x, ft) {
var tk = [], tv = [], fk = [], fv = [];
for (var [k, v] of entries(x)) {
if (ft(v, k, x)) {
tk.push(k);
tv.push(v);
}
else {
fk.push(k);
fv.push(v);
}
}
return [[tk, tv], [fk, fv]];
}
function searchValueAll$1(x, v, fc = null, fm = null) {
return searchValueAll(entries(x), v, fc, fm);
}
function set(x, k, v) {
var ks = [], vs = [];
for (var [j, u] of entries(x)) {
ks.push(j);
vs.push(j === k ? v : u);
function partitionAs(x, fm = null) {
var fm = fm || IDENTITY$3;
var a = new Map();
for (var [k, v] of entries(x)) {
var v1 = fm(v, k, x);
if (!a.has(v1))
a.set(v1, [[], []]);
var [ak, av] = a.get(v1);
ak.push(k);
av.push(v);
}
return [ks, vs];
return a;
}
function shift(x) {
return drop$1(x, 1);
function chunk(x, n = 1, s = n) {
var kss = chunk$1([...keys(x)], n, s);
var vss = chunk$1([...values(x)], n, s);
return zip$2([kss, vss]);
}
function some$3(x, ft = null) {
return some$1(entries(x), ft);
}
function subset$1(x, n = -1, r = Math.random()) {
var a = subset(new Map(entries(x)), n, r);
function concat(...xs) {
var ks = concat$2(...xs.map(keys));
var vs = concat$2(...xs.map(values));
var a = fromLists([ks, vs]);
return [a.keys(), a.values()];
}
function* subsets$1(x, n = -1) {
for (var a of subsets(new Map(entries(x)), n))
yield [a.keys(), a.values()];
function join(x, sep = ',', asc = '=') {
return join$1(entries(x), sep, asc);
}
function swap(x, k, l) {
var ks = map(keys(x), j => j === k ? l : (j === l ? k : j));
return [ks, values(x)];
function isDisjoint(x, y) {
return isDisjoint$1(new Set(keys(x)), keys(y));
}
function symmetricDifference$1(x, y) {
var a = symmetricDifference(entries(x), entries(y));
function unionKeys(...xs) {
return concat$1(...xs.map(x => new Set(keys(x))));
}
function union(x, y, fc = null) {
var a = union$1(entries(x), entries(y), fc);
return [a.keys(), a.values()];
}
function tail(x) {
return drop$1(x, 1);
function intersection(x, y, fc = null) {
var a = intersection$1(new Map(entries(x)), entries(y), fc);
return [a.keys(), a.values()];
}
function take$1(x, n = 1) {
var ks = take(keys(x), n);
var vs = take(values(x), n);
return [ks, vs];
}
function union$1(x, y, fc = null) {
var a = union(entries(x), entries(y), fc);
function difference(x, y) {
var a = fromLists(x);
for (var k of keys(y))
a.delete(k);
return [a.keys(), a.values()];
}
function unionKeys$2(...xs) {
return concat$2(...xs.map(x => keys(x)));
}
function value$1(x, r = Math.random()) {
return value([...values(x)], r);
}
function zip$2(xs, fm = null, ft = null, vd) {
var a = zip(xs.map(x => new Map(entries(x))), fm, ft, vd);
function symmetricDifference(x, y) {
var a = symmetricDifference$1(entries(x), entries(y));
return [a.keys(), a.values()];
}
exports.cartesianProduct = cartesianProduct$1;
exports.chunk = chunk$1;
exports.compare = compare$2;
exports.concat = concat$1;
exports.count = count$1;
exports.countAs = countAs$1;
exports.chunk = chunk;
exports.compare = compare;
exports.concat = concat;
exports.count = count;
exports.countAs = countAs;
exports.difference = difference;
exports.drop = drop$1;
exports.drop = drop;
exports.entries = entries;
exports.entry = entry;
exports.every = every$1;
exports.entry = randomEntry;
exports.every = every;
exports.filter = filter;
exports.filterAt = filterAt$1;
exports.find = find$1;
exports.findAll = findAll$1;
exports.filterAt = filterAt;
exports.find = find;
exports.findAll = findAll;
exports.flat = flat;
exports.flatMap = flatMap;
exports.forEach = forEach$1;
exports.forEach = forEach;
exports.fromEntries = fromEntries;
exports.get = get$2;
exports.getAll = getAll$2;
exports.get = get;
exports.getAll = getAll;
exports.getPath = getPath;

@@ -897,44 +884,48 @@ exports.has = has;

exports.hasPath = hasPath;
exports.hasSubset = hasSubset$1;
exports.hasValue = hasValue$1;
exports.head = head$1;
exports.intersection = intersection$1;
exports.is = is$1;
exports.isDisjoint = isDisjoint$1;
exports.isEmpty = isEmpty$1;
exports.hasSubset = hasSubset;
exports.hasValue = hasValue;
exports.head = head;
exports.intersection = intersection;
exports.is = is;
exports.isDisjoint = isDisjoint;
exports.isEmpty = isEmpty;
exports.isEqual = isEqual;
exports.join = join$1;
exports.key = key;
exports.join = join;
exports.key = randomKey;
exports.keys = keys;
exports.length = length;
exports.map = map$1;
exports.length = size;
exports.map = map;
exports.max = max;
exports.maxEntry = maxEntry;
exports.min = min;
exports.minEntry = minEntry;
exports.partition = partition;
exports.partitionAs = partitionAs;
exports.range = range$1;
exports.reduce = reduce$1;
exports.randomEntry = randomEntry;
exports.randomKey = randomKey;
exports.randomSubset = randomSubset;
exports.randomValue = randomValue;
exports.range = range;
exports.rangeEntries = rangeEntries;
exports.reduce = reduce;
exports.reject = reject;
exports.rejectAt = rejectAt;
exports.remove = remove;
exports.scanUntil = scanUntil$1;
exports.scanWhile = scanWhile$1;
exports.search = search$1;
exports.searchAll = searchAll$1;
exports.searchValue = searchValue$2;
exports.searchValueAll = searchValueAll$1;
exports.search = search;
exports.searchAll = searchAll;
exports.searchValue = searchValue;
exports.searchValueAll = searchValueAll;
exports.set = set;
exports.shift = shift;
exports.size = size$1;
exports.some = some$3;
exports.subset = subset$1;
exports.subsets = subsets$1;
exports.size = size;
exports.some = some;
exports.subset = randomSubset;
exports.subsets = subsets;
exports.swap = swap;
exports.symmetricDifference = symmetricDifference$1;
exports.symmetricDifference = symmetricDifference;
exports.tail = tail;
exports.take = take$1;
exports.union = union$1;
exports.unionKeys = unionKeys$2;
exports.value = value$1;
exports.take = take;
exports.union = union;
exports.unionKeys = unionKeys;
exports.value = randomValue;
exports.values = values;
exports.zip = zip$2;
exports.zip = zip;

66

package.json
{
"name": "extra-lists",
"version": "2.2.10",
"version": "3.0.5",
"description": "Lists is a pair of key list and value list, with unique keys.",
"main": "index.js",
"module": "index.mjs",
"sideEffects": false,
"exports": {

@@ -12,11 +13,25 @@ "require": "./index.js",

"scripts": {
"test": "exit",
"build": "ebuild export+main+example+wiki+readme --wikiExample=false --asciinema=false",
"deploy": "ebuild jsdoc+export+main+meta+example+github+publish"
"test": "jest",
"build": "node ./build",
"publish-docs": "node ./build publish-docs",
"publish-packages": "node ./build publish-packages"
},
"runkitExampleFilename": "example.js",
"keywords": [
"extra",
"lists",
"cartesianProduct",
"entry",
"key",
"length",
"subset",
"value",
"CombineFunction",
"CompareFunction",
"EndFunction",
"Entries",
"Lists",
"MapFunction",
"ProcessFunction",
"ReadFunction",
"ReduceFunction",
"TestFunction",
"chunk",

@@ -30,3 +45,2 @@ "compare",

"entries",
"entry",
"every",

@@ -56,11 +70,16 @@ "filter",

"join",
"key",
"keys",
"length",
"map",
"max",
"maxEntry",
"min",
"minEntry",
"partition",
"partitionAs",
"randomEntry",
"randomKey",
"randomSubset",
"randomValue",
"range",
"rangeEntries",
"reduce",

@@ -70,4 +89,2 @@ "reject",

"remove",
"scanUntil",
"scanWhile",
"search",

@@ -78,6 +95,4 @@ "searchAll",

"set",
"shift",
"size",
"some",
"subset",
"subsets",

@@ -90,6 +105,7 @@ "swap",

"unionKeys",
"value",
"values",
"zip"
],
"author": "wolfram77@gmail.com",
"license": "MIT",
"repository": {

@@ -103,12 +119,18 @@ "type": "git",

"homepage": "https://github.com/nodef/extra-lists#readme",
"author": "wolfram77@gmail.com",
"license": "MIT",
"devDependencies": {
"extra-array": "^2.10.16",
"extra-build": "^1.3.30",
"extra-entries": "^2.2.17",
"extra-iterable": "^2.5.21",
"extra-map": "^2.2.14",
"extra-set": "^2.2.10"
"@rollup/plugin-commonjs": "^24.0.0",
"@rollup/plugin-node-resolve": "^15.0.1",
"@types/jest": "^29.2.4",
"extra-array": "^3.1.14",
"extra-build": "^2.2.39",
"extra-entries": "^3.0.47",
"extra-function": "^1.1.20",
"extra-iterable": "^3.2.11",
"extra-map": "^3.1.13",
"extra-set": "^3.1.5",
"jest": "^29.3.1",
"rollup-plugin-cleanup": "^3.2.1",
"rollup-plugin-dts": "^5.1.0",
"ts-jest": "^29.0.3"
}
}
example.js
index.mjs

Sorry, the diff of this file is not supported yet

LICENSE

Sorry, the diff of this file is not supported yet

SocketSocket SOC 2 Logo

Product

  • Package Alerts
  • Integrations
  • Docs
  • Pricing
  • FAQ
  • Roadmap
  • Changelog

About

Packages

npm

Go

Maven

PyPI

Rubygems

Stay in touch

Get open source security insights delivered straight into your inbox.

  • Terms
  • Privacy
  • Security

Made with ⚡️ by Socket Inc