| 1 | {"version":3,"file":"index.js","sources":["../src/array.ts","../src/iter.ts","../src/chain.ts","../src/empty.ts","../src/enumerate.ts","../src/filter.ts","../src/find.ts","../src/map.ts","../src/range.ts","../src/reduce.ts","../src/repeat.ts","../src/retro.ts","../src/sort.ts","../src/stride.ts","../src/string.ts","../src/take.ts","../src/zip.ts"],"sourcesContent":["// Copyright (c) Jupyter Development Team.\n// Distributed under the terms of the Modified BSD License.\n/*-----------------------------------------------------------------------------\n| Copyright (c) 2014-2017, PhosphorJS Contributors\n|\n| Distributed under the terms of the BSD 3-Clause License.\n|\n| The full license is in the file LICENSE, distributed with this software.\n|----------------------------------------------------------------------------*/\n\n/**\n * The namespace for array-specific algorithms.\n */\nexport namespace ArrayExt {\n /**\n * Find the index of the first occurrence of a value in an array.\n *\n * @param array - The array-like object to search.\n *\n * @param value - The value to locate in the array. Values are\n * compared using strict `===` equality.\n *\n * @param start - The index of the first element in the range to be\n * searched, inclusive. The default value is `0`. Negative values\n * are taken as an offset from the end of the array.\n *\n * @param stop - The index of the last element in the range to be\n * searched, inclusive. The default value is `-1`. Negative values\n * are taken as an offset from the end of the array.\n *\n * @returns The index of the first occurrence of the value, or `-1`\n * if the value is not found.\n *\n * #### Notes\n * If `stop < start` the search will wrap at the end of the array.\n *\n * #### Complexity\n * Linear.\n *\n * #### Undefined Behavior\n * A `start` or `stop` which is non-integral.\n *\n * #### Example\n * ```typescript\n * import { ArrayExt } from '@lumino/algorithm';\n *\n * let data = ['one', 'two', 'three', 'four', 'one'];\n * ArrayExt.firstIndexOf(data, 'red'); // -1\n * ArrayExt.firstIndexOf(data, 'one'); // 0\n * ArrayExt.firstIndexOf(data, 'one', 1); // 4\n * ArrayExt.firstIndexOf(data, 'two', 2); // -1\n * ArrayExt.firstIndexOf(data, 'two', 2, 1); // 1\n * ```\n */\n export function firstIndexOf<T>(\n array: ArrayLike<T>,\n value: T,\n start = 0,\n stop = -1\n ): number {\n let n = array.length;\n if (n === 0) {\n return -1;\n }\n if (start < 0) {\n start = Math.max(0, start + n);\n } else {\n start = Math.min(start, n - 1);\n }\n if (stop < 0) {\n stop = Math.max(0, stop + n);\n } else {\n stop = Math.min(stop, n - 1);\n }\n let span: number;\n if (stop < start) {\n span = stop + 1 + (n - start);\n } else {\n span = stop - start + 1;\n }\n for (let i = 0; i < span; ++i) {\n let j = (start + i) % n;\n if (array[j] === value) {\n return j;\n }\n }\n return -1;\n }\n\n /**\n * Find the index of the last occurrence of a value in an array.\n *\n * @param array - The array-like object to search.\n *\n * @param value - The value to locate in the array. Values are\n * compared using strict `===` equality.\n *\n * @param start - The index of the first element in the range to be\n * searched, inclusive. The default value is `-1`. Negative values\n * are taken as an offset from the end of the array.\n *\n * @param stop - The index of the last element in the range to be\n * searched, inclusive. The default value is `0`. Negative values\n * are taken as an offset from the end of the array.\n *\n * @returns The index of the last occurrence of the value, or `-1`\n * if the value is not found.\n *\n * #### Notes\n * If `start < stop` the search will wrap at the front of the array.\n *\n * #### Complexity\n * Linear.\n *\n * #### Undefined Behavior\n * A `start` or `stop` which is non-integral.\n *\n * #### Example\n * ```typescript\n * import { ArrayExt } from '@lumino/algorithm';\n *\n * let data = ['one', 'two', 'three', 'four', 'one'];\n * ArrayExt.lastIndexOf(data, 'red'); // -1\n * ArrayExt.lastIndexOf(data, 'one'); // 4\n * ArrayExt.lastIndexOf(data, 'one', 1); // 0\n * ArrayExt.lastIndexOf(data, 'two', 0); // -1\n * ArrayExt.lastIndexOf(data, 'two', 0, 1); // 1\n * ```\n */\n export function lastIndexOf<T>(\n array: ArrayLike<T>,\n value: T,\n start = -1,\n stop = 0\n ): number {\n let n = array.length;\n if (n === 0) {\n return -1;\n }\n if (start < 0) {\n start = Math.max(0, start + n);\n } else {\n start = Math.min(start, n - 1);\n }\n if (stop < 0) {\n stop = Math.max(0, stop + n);\n } else {\n stop = Math.min(stop, n - 1);\n }\n let span: number;\n if (start < stop) {\n span = start + 1 + (n - stop);\n } else {\n span = start - stop + 1;\n }\n for (let i = 0; i < span; ++i) {\n let j = (start - i + n) % n;\n if (array[j] === value) {\n return j;\n }\n }\n return -1;\n }\n\n /**\n * Find the index of the first value which matches a predicate.\n *\n * @param array - The array-like object to search.\n *\n * @param fn - The predicate function to apply to the values.\n *\n * @param start - The index of the first element in the range to be\n * searched, inclusive. The default value is `0`. Negative values\n * are taken as an offset from the end of the array.\n *\n * @param stop - The index of the last element in the range to be\n * searched, inclusive. The default value is `-1`. Negative values\n * are taken as an offset from the end of the array.\n *\n * @returns The index of the first matching value, or `-1` if no\n * matching value is found.\n *\n * #### Notes\n * If `stop < start` the search will wrap at the end of the array.\n *\n * #### Complexity\n * Linear.\n *\n * #### Undefined Behavior\n * A `start` or `stop` which is non-integral.\n *\n * Modifying the length of the array while searching.\n *\n * #### Example\n * ```typescript\n * import { ArrayExt } from '@lumino/algorithm';\n *\n * function isEven(value: number): boolean {\n * return value % 2 === 0;\n * }\n *\n * let data = [1, 2, 3, 4, 3, 2, 1];\n * ArrayExt.findFirstIndex(data, isEven); // 1\n * ArrayExt.findFirstIndex(data, isEven, 4); // 5\n * ArrayExt.findFirstIndex(data, isEven, 6); // -1\n * ArrayExt.findFirstIndex(data, isEven, 6, 5); // 1\n * ```\n */\n export function findFirstIndex<T>(\n array: ArrayLike<T>,\n fn: (value: T, index: number) => boolean,\n start = 0,\n stop = -1\n ): number {\n let n = array.length;\n if (n === 0) {\n return -1;\n }\n if (start < 0) {\n start = Math.max(0, start + n);\n } else {\n start = Math.min(start, n - 1);\n }\n if (stop < 0) {\n stop = Math.max(0, stop + n);\n } else {\n stop = Math.min(stop, n - 1);\n }\n let span: number;\n if (stop < start) {\n span = stop + 1 + (n - start);\n } else {\n span = stop - start + 1;\n }\n for (let i = 0; i < span; ++i) {\n let j = (start + i) % n;\n if (fn(array[j], j)) {\n return j;\n }\n }\n return -1;\n }\n\n /**\n * Find the index of the last value which matches a predicate.\n *\n * @param object - The array-like object to search.\n *\n * @param fn - The predicate function to apply to the values.\n *\n * @param start - The index of the first element in the range to be\n * searched, inclusive. The default value is `-1`. Negative values\n * are taken as an offset from the end of the array.\n *\n * @param stop - The index of the last element in the range to be\n * searched, inclusive. The default value is `0`. Negative values\n * are taken as an offset from the end of the array.\n *\n * @returns The index of the last matching value, or `-1` if no\n * matching value is found.\n *\n * #### Notes\n * If `start < stop` the search will wrap at the front of the array.\n *\n * #### Complexity\n * Linear.\n *\n * #### Undefined Behavior\n * A `start` or `stop` which is non-integral.\n *\n * Modifying the length of the array while searching.\n *\n * #### Example\n * ```typescript\n * import { ArrayExt } from '@lumino/algorithm';\n *\n * function isEven(value: number): boolean {\n * return value % 2 === 0;\n * }\n *\n * let data = [1, 2, 3, 4, 3, 2, 1];\n * ArrayExt.findLastIndex(data, isEven); // 5\n * ArrayExt.findLastIndex(data, isEven, 4); // 3\n * ArrayExt.findLastIndex(data, isEven, 0); // -1\n * ArrayExt.findLastIndex(data, isEven, 0, 1); // 5\n * ```\n */\n export function findLastIndex<T>(\n array: ArrayLike<T>,\n fn: (value: T, index: number) => boolean,\n start = -1,\n stop = 0\n ): number {\n let n = array.length;\n if (n === 0) {\n return -1;\n }\n if (start < 0) {\n start = Math.max(0, start + n);\n } else {\n start = Math.min(start, n - 1);\n }\n if (stop < 0) {\n stop = Math.max(0, stop + n);\n } else {\n stop = Math.min(stop, n - 1);\n }\n let d: number;\n if (start < stop) {\n d = start + 1 + (n - stop);\n } else {\n d = start - stop + 1;\n }\n for (let i = 0; i < d; ++i) {\n let j = (start - i + n) % n;\n if (fn(array[j], j)) {\n return j;\n }\n }\n return -1;\n }\n\n /**\n * Find the first value which matches a predicate.\n *\n * @param array - The array-like object to search.\n *\n * @param fn - The predicate function to apply to the values.\n *\n * @param start - The index of the first element in the range to be\n * searched, inclusive. The default value is `0`. Negative values\n * are taken as an offset from the end of the array.\n *\n * @param stop - The index of the last element in the range to be\n * searched, inclusive. The default value is `-1`. Negative values\n * are taken as an offset from the end of the array.\n *\n * @returns The first matching value, or `undefined` if no matching\n * value is found.\n *\n * #### Notes\n * If `stop < start` the search will wrap at the end of the array.\n *\n * #### Complexity\n * Linear.\n *\n * #### Undefined Behavior\n * A `start` or `stop` which is non-integral.\n *\n * Modifying the length of the array while searching.\n *\n * #### Example\n * ```typescript\n * import { ArrayExt } from '@lumino/algorithm';\n *\n * function isEven(value: number): boolean {\n * return value % 2 === 0;\n * }\n *\n * let data = [1, 2, 3, 4, 3, 2, 1];\n * ArrayExt.findFirstValue(data, isEven); // 2\n * ArrayExt.findFirstValue(data, isEven, 2); // 4\n * ArrayExt.findFirstValue(data, isEven, 6); // undefined\n * ArrayExt.findFirstValue(data, isEven, 6, 5); // 2\n * ```\n */\n export function findFirstValue<T>(\n array: ArrayLike<T>,\n fn: (value: T, index: number) => boolean,\n start = 0,\n stop = -1\n ): T | undefined {\n let index = findFirstIndex(array, fn, start, stop);\n return index !== -1 ? array[index] : undefined;\n }\n\n /**\n * Find the last value which matches a predicate.\n *\n * @param object - The array-like object to search.\n *\n * @param fn - The predicate function to apply to the values.\n *\n * @param start - The index of the first element in the range to be\n * searched, inclusive. The default value is `-1`. Negative values\n * are taken as an offset from the end of the array.\n *\n * @param stop - The index of the last element in the range to be\n * searched, inclusive. The default value is `0`. Negative values\n * are taken as an offset from the end of the array.\n *\n * @returns The last matching value, or `undefined` if no matching\n * value is found.\n *\n * #### Notes\n * If `start < stop` the search will wrap at the front of the array.\n *\n * #### Complexity\n * Linear.\n *\n * #### Undefined Behavior\n * A `start` or `stop` which is non-integral.\n *\n * Modifying the length of the array while searching.\n *\n * #### Example\n * ```typescript\n * import { ArrayExt } from '@lumino/algorithm';\n *\n * function isEven(value: number): boolean {\n * return value % 2 === 0;\n * }\n *\n * let data = [1, 2, 3, 4, 3, 2, 1];\n * ArrayExt.findLastValue(data, isEven); // 2\n * ArrayExt.findLastValue(data, isEven, 4); // 4\n * ArrayExt.findLastValue(data, isEven, 0); // undefined\n * ArrayExt.findLastValue(data, isEven, 0, 1); // 2\n * ```\n */\n export function findLastValue<T>(\n array: ArrayLike<T>,\n fn: (value: T, index: number) => boolean,\n start = -1,\n stop = 0\n ): T | undefined {\n let index = findLastIndex(array, fn, start, stop);\n return index !== -1 ? array[index] : undefined;\n }\n\n /**\n * Find the index of the first element which compares `>=` to a value.\n *\n * @param array - The sorted array-like object to search.\n *\n * @param value - The value to locate in the array.\n *\n * @param fn - The 3-way comparison function to apply to the values.\n * It should return `< 0` if an element is less than a value, `0` if\n * an element is equal to a value, or `> 0` if an element is greater\n * than a value.\n *\n * @param start - The index of the first element in the range to be\n * searched, inclusive. The default value is `0`. Negative values\n * are taken as an offset from the end of the array.\n *\n * @param stop - The index of the last element in the range to be\n * searched, inclusive. The default value is `-1`. Negative values\n * are taken as an offset from the end of the array.\n *\n * @returns The index of the first element which compares `>=` to the\n * value, or `length` if there is no such element. If the computed\n * index for `stop` is less than `start`, then the computed index\n * for `start` is returned.\n *\n * #### Notes\n * The array must already be sorted in ascending order according to\n * the comparison function.\n *\n * #### Complexity\n * Logarithmic.\n *\n * #### Undefined Behavior\n * Searching a range which is not sorted in ascending order.\n *\n * A `start` or `stop` which is non-integral.\n *\n * Modifying the length of the array while searching.\n *\n * #### Example\n * ```typescript\n * import { ArrayExt } from '@lumino/algorithm';\n *\n * function numberCmp(a: number, b: number): number {\n * return a - b;\n * }\n *\n * let data = [0, 3, 4, 7, 7, 9];\n * ArrayExt.lowerBound(data, 0, numberCmp); // 0\n * ArrayExt.lowerBound(data, 6, numberCmp); // 3\n * ArrayExt.lowerBound(data, 7, numberCmp); // 3\n * ArrayExt.lowerBound(data, -1, numberCmp); // 0\n * ArrayExt.lowerBound(data, 10, numberCmp); // 6\n * ```\n */\n export function lowerBound<T, U>(\n array: ArrayLike<T>,\n value: U,\n fn: (element: T, value: U) => number,\n start = 0,\n stop = -1\n ): number {\n let n = array.length;\n if (n === 0) {\n return 0;\n }\n if (start < 0) {\n start = Math.max(0, start + n);\n } else {\n start = Math.min(start, n - 1);\n }\n if (stop < 0) {\n stop = Math.max(0, stop + n);\n } else {\n stop = Math.min(stop, n - 1);\n }\n let begin = start;\n let span = stop - start + 1;\n while (span > 0) {\n let half = span >> 1;\n let middle = begin + half;\n if (fn(array[middle], value) < 0) {\n begin = middle + 1;\n span -= half + 1;\n } else {\n span = half;\n }\n }\n return begin;\n }\n\n /**\n * Find the index of the first element which compares `>` than a value.\n *\n * @param array - The sorted array-like object to search.\n *\n * @param value - The value to locate in the array.\n *\n * @param fn - The 3-way comparison function to apply to the values.\n * It should return `< 0` if an element is less than a value, `0` if\n * an element is equal to a value, or `> 0` if an element is greater\n * than a value.\n *\n * @param start - The index of the first element in the range to be\n * searched, inclusive. The default value is `0`. Negative values\n * are taken as an offset from the end of the array.\n *\n * @param stop - The index of the last element in the range to be\n * searched, inclusive. The default value is `-1`. Negative values\n * are taken as an offset from the end of the array.\n *\n * @returns The index of the first element which compares `>` than the\n * value, or `length` if there is no such element. If the computed\n * index for `stop` is less than `start`, then the computed index\n * for `start` is returned.\n *\n * #### Notes\n * The array must already be sorted in ascending order according to\n * the comparison function.\n *\n * #### Complexity\n * Logarithmic.\n *\n * #### Undefined Behavior\n * Searching a range which is not sorted in ascending order.\n *\n * A `start` or `stop` which is non-integral.\n *\n * Modifying the length of the array while searching.\n *\n * #### Example\n * ```typescript\n * import { ArrayExt } from '@lumino/algorithm';\n *\n * function numberCmp(a: number, b: number): number {\n * return a - b;\n * }\n *\n * let data = [0, 3, 4, 7, 7, 9];\n * ArrayExt.upperBound(data, 0, numberCmp); // 1\n * ArrayExt.upperBound(data, 6, numberCmp); // 3\n * ArrayExt.upperBound(data, 7, numberCmp); // 5\n * ArrayExt.upperBound(data, -1, numberCmp); // 0\n * ArrayExt.upperBound(data, 10, numberCmp); // 6\n * ```\n */\n export function upperBound<T, U>(\n array: ArrayLike<T>,\n value: U,\n fn: (element: T, value: U) => number,\n start = 0,\n stop = -1\n ): number {\n let n = array.length;\n if (n === 0) {\n return 0;\n }\n if (start < 0) {\n start = Math.max(0, start + n);\n } else {\n start = Math.min(start, n - 1);\n }\n if (stop < 0) {\n stop = Math.max(0, stop + n);\n } else {\n stop = Math.min(stop, n - 1);\n }\n let begin = start;\n let span = stop - start + 1;\n while (span > 0) {\n let half = span >> 1;\n let middle = begin + half;\n if (fn(array[middle], value) > 0) {\n span = half;\n } else {\n begin = middle + 1;\n span -= half + 1;\n }\n }\n return begin;\n }\n\n /**\n * Test whether two arrays are shallowly equal.\n *\n * @param a - The first array-like object to compare.\n *\n * @param b - The second array-like object to compare.\n *\n * @param fn - The comparison function to apply to the elements. It\n * should return `true` if the elements are \"equal\". The default\n * compares elements using strict `===` equality.\n *\n * @returns Whether the two arrays are shallowly equal.\n *\n * #### Complexity\n * Linear.\n *\n * #### Undefined Behavior\n * Modifying the length of the arrays while comparing.\n *\n * #### Example\n * ```typescript\n * import { ArrayExt } from '@lumino/algorithm';\n *\n * let d1 = [0, 3, 4, 7, 7, 9];\n * let d2 = [0, 3, 4, 7, 7, 9];\n * let d3 = [42];\n * ArrayExt.shallowEqual(d1, d2); // true\n * ArrayExt.shallowEqual(d2, d3); // false\n * ```\n */\n export function shallowEqual<T>(\n a: ArrayLike<T>,\n b: ArrayLike<T>,\n fn?: (a: T, b: T) => boolean\n ): boolean {\n // Check for object identity first.\n if (a === b) {\n return true;\n }\n\n // Bail early if the lengths are different.\n if (a.length !== b.length) {\n return false;\n }\n\n // Compare each element for equality.\n for (let i = 0, n = a.length; i < n; ++i) {\n if (fn ? !fn(a[i], b[i]) : a[i] !== b[i]) {\n return false;\n }\n }\n\n // The array are shallowly equal.\n return true;\n }\n\n /**\n * Create a slice of an array subject to an optional step.\n *\n * @param array - The array-like object of interest.\n *\n * @param options - The options for configuring the slice.\n *\n * @returns A new array with the specified values.\n *\n * @throws An exception if the slice `step` is `0`.\n *\n * #### Complexity\n * Linear.\n *\n * #### Undefined Behavior\n * A `start`, `stop`, or `step` which is non-integral.\n *\n * #### Example\n * ```typescript\n * import { ArrayExt } from '@lumino/algorithm';\n *\n * let data = [0, 3, 4, 7, 7, 9];\n * ArrayExt.slice(data); // [0, 3, 4, 7, 7, 9]\n * ArrayExt.slice(data, { start: 2 }); // [4, 7, 7, 9]\n * ArrayExt.slice(data, { start: 0, stop: 4 }); // [0, 3, 4, 7]\n * ArrayExt.slice(data, { step: 2 }); // [0, 4, 7]\n * ArrayExt.slice(data, { step: -1 }); // [9, 7, 7, 4, 3, 0]\n * ```\n */\n export function slice<T>(\n array: ArrayLike<T>,\n options: slice.IOptions = {}\n ): T[] {\n // Extract the options.\n let { start, stop, step } = options;\n\n // Set up the `step` value.\n if (step === undefined) {\n step = 1;\n }\n\n // Validate the step size.\n if (step === 0) {\n throw new Error('Slice `step` cannot be zero.');\n }\n\n // Look up the length of the array.\n let n = array.length;\n\n // Set up the `start` value.\n if (start === undefined) {\n start = step < 0 ? n - 1 : 0;\n } else if (start < 0) {\n start = Math.max(start + n, step < 0 ? -1 : 0);\n } else if (start >= n) {\n start = step < 0 ? n - 1 : n;\n }\n\n // Set up the `stop` value.\n if (stop === undefined) {\n stop = step < 0 ? -1 : n;\n } else if (stop < 0) {\n stop = Math.max(stop + n, step < 0 ? -1 : 0);\n } else if (stop >= n) {\n stop = step < 0 ? n - 1 : n;\n }\n\n // Compute the slice length.\n let length;\n if ((step < 0 && stop >= start) || (step > 0 && start >= stop)) {\n length = 0;\n } else if (step < 0) {\n length = Math.floor((stop - start + 1) / step + 1);\n } else {\n length = Math.floor((stop - start - 1) / step + 1);\n }\n\n // Compute the sliced result.\n let result: T[] = [];\n for (let i = 0; i < length; ++i) {\n result[i] = array[start + i * step];\n }\n\n // Return the result.\n return result;\n }\n\n /**\n * The namespace for the `slice` function statics.\n */\n export namespace slice {\n /**\n * The options for the `slice` function.\n */\n export interface IOptions {\n /**\n * The starting index of the slice, inclusive.\n *\n * Negative values are taken as an offset from the end\n * of the array.\n *\n * The default is `0` if `step > 0` else `n - 1`.\n */\n start?: number;\n\n /**\n * The stopping index of the slice, exclusive.\n *\n * Negative values are taken as an offset from the end\n * of the array.\n *\n * The default is `n` if `step > 0` else `-n - 1`.\n */\n stop?: number;\n\n /**\n * The step value for the slice.\n *\n * This must not be `0`.\n *\n * The default is `1`.\n */\n step?: number;\n }\n }\n\n /**\n * An array-like object which supports item assignment.\n */\n export type MutableArrayLike<T> = {\n readonly length: number;\n [index: number]: T;\n };\n\n /**\n * Move an element in an array from one index to another.\n *\n * @param array - The mutable array-like object of interest.\n *\n * @param fromIndex - The index of the element to move. Negative\n * values are taken as an offset from the end of the array.\n *\n * @param toIndex - The target index of the element. Negative\n * values are taken as an offset from the end of the array.\n *\n * #### Complexity\n * Linear.\n *\n * #### Undefined Behavior\n * A `fromIndex` or `toIndex` which is non-integral.\n *\n * #### Example\n * ```typescript\n * import { ArrayExt } from from '@lumino/algorithm';\n *\n * let data = [0, 1, 2, 3, 4];\n * ArrayExt.move(data, 1, 2); // [0, 2, 1, 3, 4]\n * ArrayExt.move(data, 4, 2); // [0, 2, 4, 1, 3]\n * ```\n */\n export function move<T>(\n array: MutableArrayLike<T>,\n fromIndex: number,\n toIndex: number\n ): void {\n let n = array.length;\n if (n <= 1) {\n return;\n }\n if (fromIndex < 0) {\n fromIndex = Math.max(0, fromIndex + n);\n } else {\n fromIndex = Math.min(fromIndex, n - 1);\n }\n if (toIndex < 0) {\n toIndex = Math.max(0, toIndex + n);\n } else {\n toIndex = Math.min(toIndex, n - 1);\n }\n if (fromIndex === toIndex) {\n return;\n }\n let value = array[fromIndex];\n let d = fromIndex < toIndex ? 1 : -1;\n for (let i = fromIndex; i !== toIndex; i += d) {\n array[i] = array[i + d];\n }\n array[toIndex] = value;\n }\n\n /**\n * Reverse an array in-place.\n *\n * @param array - The mutable array-like object of interest.\n *\n * @param start - The index of the first element in the range to be\n * reversed, inclusive. The default value is `0`. Negative values\n * are taken as an offset from the end of the array.\n *\n * @param stop - The index of the last element in the range to be\n * reversed, inclusive. The default value is `-1`. Negative values\n * are taken as an offset from the end of the array.\n *\n * #### Complexity\n * Linear.\n *\n * #### Undefined Behavior\n * A `start` or `stop` index which is non-integral.\n *\n * #### Example\n * ```typescript\n * import { ArrayExt } from '@lumino/algorithm';\n *\n * let data = [0, 1, 2, 3, 4];\n * ArrayExt.reverse(data, 1, 3); // [0, 3, 2, 1, 4]\n * ArrayExt.reverse(data, 3); // [0, 3, 2, 4, 1]\n * ArrayExt.reverse(data); // [1, 4, 2, 3, 0]\n * ```\n */\n export function reverse<T>(\n array: MutableArrayLike<T>,\n start = 0,\n stop = -1\n ): void {\n let n = array.length;\n if (n <= 1) {\n return;\n }\n if (start < 0) {\n start = Math.max(0, start + n);\n } else {\n start = Math.min(start, n - 1);\n }\n if (stop < 0) {\n stop = Math.max(0, stop + n);\n } else {\n stop = Math.min(stop, n - 1);\n }\n while (start < stop) {\n let a = array[start];\n let b = array[stop];\n array[start++] = b;\n array[stop--] = a;\n }\n }\n\n /**\n * Rotate the elements of an array in-place.\n *\n * @param array - The mutable array-like object of interest.\n *\n * @param delta - The amount of rotation to apply to the elements. A\n * positive value will rotate the elements to the left. A negative\n * value will rotate the elements to the right.\n *\n * @param start - The index of the first element in the range to be\n * rotated, inclusive. The default value is `0`. Negative values\n * are taken as an offset from the end of the array.\n *\n * @param stop - The index of the last element in the range to be\n * rotated, inclusive. The default value is `-1`. Negative values\n * are taken as an offset from the end of the array.\n *\n * #### Complexity\n * Linear.\n *\n * #### Undefined Behavior\n * A `delta`, `start`, or `stop` which is non-integral.\n *\n * #### Example\n * ```typescript\n * import { ArrayExt } from '@lumino/algorithm';\n *\n * let data = [0, 1, 2, 3, 4];\n * ArrayExt.rotate(data, 2); // [2, 3, 4, 0, 1]\n * ArrayExt.rotate(data, -2); // [0, 1, 2, 3, 4]\n * ArrayExt.rotate(data, 10); // [0, 1, 2, 3, 4]\n * ArrayExt.rotate(data, 9); // [4, 0, 1, 2, 3]\n * ArrayExt.rotate(data, 2, 1, 3); // [4, 2, 0, 1, 3]\n * ```\n */\n export function rotate<T>(\n array: MutableArrayLike<T>,\n delta: number,\n start = 0,\n stop = -1\n ): void {\n let n = array.length;\n if (n <= 1) {\n return;\n }\n if (start < 0) {\n start = Math.max(0, start + n);\n } else {\n start = Math.min(start, n - 1);\n }\n if (stop < 0) {\n stop = Math.max(0, stop + n);\n } else {\n stop = Math.min(stop, n - 1);\n }\n if (start >= stop) {\n return;\n }\n let length = stop - start + 1;\n if (delta > 0) {\n delta = delta % length;\n } else if (delta < 0) {\n delta = ((delta % length) + length) % length;\n }\n if (delta === 0) {\n return;\n }\n let pivot = start + delta;\n reverse(array, start, pivot - 1);\n reverse(array, pivot, stop);\n reverse(array, start, stop);\n }\n\n /**\n * Fill an array with a static value.\n *\n * @param array - The mutable array-like object to fill.\n *\n * @param value - The static value to use to fill the array.\n *\n * @param start - The index of the first element in the range to be\n * filled, inclusive. The default value is `0`. Negative values\n * are taken as an offset from the end of the array.\n *\n * @param stop - The index of the last element in the range to be\n * filled, inclusive. The default value is `-1`. Negative values\n * are taken as an offset from the end of the array.\n *\n * #### Notes\n * If `stop < start` the fill will wrap at the end of the array.\n *\n * #### Complexity\n * Linear.\n *\n * #### Undefined Behavior\n * A `start` or `stop` which is non-integral.\n *\n * #### Example\n * ```typescript\n * import { ArrayExt } from '@lumino/algorithm';\n *\n * let data = ['one', 'two', 'three', 'four'];\n * ArrayExt.fill(data, 'r'); // ['r', 'r', 'r', 'r']\n * ArrayExt.fill(data, 'g', 1); // ['r', 'g', 'g', 'g']\n * ArrayExt.fill(data, 'b', 2, 3); // ['r', 'g', 'b', 'b']\n * ArrayExt.fill(data, 'z', 3, 1); // ['z', 'z', 'b', 'z']\n * ```\n */\n export function fill<T>(\n array: MutableArrayLike<T>,\n value: T,\n start = 0,\n stop = -1\n ): void {\n let n = array.length;\n if (n === 0) {\n return;\n }\n if (start < 0) {\n start = Math.max(0, start + n);\n } else {\n start = Math.min(start, n - 1);\n }\n if (stop < 0) {\n stop = Math.max(0, stop + n);\n } else {\n stop = Math.min(stop, n - 1);\n }\n let span: number;\n if (stop < start) {\n span = stop + 1 + (n - start);\n } else {\n span = stop - start + 1;\n }\n for (let i = 0; i < span; ++i) {\n array[(start + i) % n] = value;\n }\n }\n\n /**\n * Insert a value into an array at a specific index.\n *\n * @param array - The array of interest.\n *\n * @param index - The index at which to insert the value. Negative\n * values are taken as an offset from the end of the array.\n *\n * @param value - The value to set at the specified index.\n *\n * #### Complexity\n * Linear.\n *\n * #### Undefined Behavior\n * An `index` which is non-integral.\n *\n * #### Example\n * ```typescript\n * import { ArrayExt } from '@lumino/algorithm';\n *\n * let data = [0, 1, 2];\n * ArrayExt.insert(data, 0, -1); // [-1, 0, 1, 2]\n * ArrayExt.insert(data, 2, 12); // [-1, 0, 12, 1, 2]\n * ArrayExt.insert(data, -1, 7); // [-1, 0, 12, 1, 7, 2]\n * ArrayExt.insert(data, 6, 19); // [-1, 0, 12, 1, 7, 2, 19]\n * ```\n */\n export function insert<T>(array: Array<T>, index: number, value: T): void {\n let n = array.length;\n if (index < 0) {\n index = Math.max(0, index + n);\n } else {\n index = Math.min(index, n);\n }\n for (let i = n; i > index; --i) {\n array[i] = array[i - 1];\n }\n array[index] = value;\n }\n\n /**\n * Remove and return a value at a specific index in an array.\n *\n * @param array - The array of interest.\n *\n * @param index - The index of the value to remove. Negative values\n * are taken as an offset from the end of the array.\n *\n * @returns The value at the specified index, or `undefined` if the\n * index is out of range.\n *\n * #### Complexity\n * Linear.\n *\n * #### Undefined Behavior\n * An `index` which is non-integral.\n *\n * #### Example\n * ```typescript\n * import { ArrayExt } from '@lumino/algorithm';\n *\n * let data = [0, 12, 23, 39, 14, 12, 75];\n * ArrayExt.removeAt(data, 2); // 23\n * ArrayExt.removeAt(data, -2); // 12\n * ArrayExt.removeAt(data, 10); // undefined;\n * ```\n */\n export function removeAt<T>(array: Array<T>, index: number): T | undefined {\n let n = array.length;\n if (index < 0) {\n index += n;\n }\n if (index < 0 || index >= n) {\n return undefined;\n }\n let value = array[index];\n for (let i = index + 1; i < n; ++i) {\n array[i - 1] = array[i];\n }\n array.length = n - 1;\n return value;\n }\n\n /**\n * Remove the first occurrence of a value from an array.\n *\n * @param array - The array of interest.\n *\n * @param value - The value to remove from the array. Values are\n * compared using strict `===` equality.\n *\n * @param start - The index of the first element in the range to be\n * searched, inclusive. The default value is `0`. Negative values\n * are taken as an offset from the end of the array.\n *\n * @param stop - The index of the last element in the range to be\n * searched, inclusive. The default value is `-1`. Negative values\n * are taken as an offset from the end of the array.\n *\n * @returns The index of the removed value, or `-1` if the value\n * is not contained in the array.\n *\n * #### Notes\n * If `stop < start` the search will wrap at the end of the array.\n *\n * #### Complexity\n * Linear.\n *\n * #### Example\n * ```typescript\n * import { ArrayExt } from '@lumino/algorithm';\n *\n * let data = [0, 12, 23, 39, 14, 12, 75];\n * ArrayExt.removeFirstOf(data, 12); // 1\n * ArrayExt.removeFirstOf(data, 17); // -1\n * ArrayExt.removeFirstOf(data, 39, 3); // -1\n * ArrayExt.removeFirstOf(data, 39, 3, 2); // 2\n * ```\n */\n export function removeFirstOf<T>(\n array: Array<T>,\n value: T,\n start = 0,\n stop = -1\n ): number {\n let index = firstIndexOf(array, value, start, stop);\n if (index !== -1) {\n removeAt(array, index);\n }\n return index;\n }\n\n /**\n * Remove the last occurrence of a value from an array.\n *\n * @param array - The array of interest.\n *\n * @param value - The value to remove from the array. Values are\n * compared using strict `===` equality.\n *\n * @param start - The index of the first element in the range to be\n * searched, inclusive. The default value is `-1`. Negative values\n * are taken as an offset from the end of the array.\n *\n * @param stop - The index of the last element in the range to be\n * searched, inclusive. The default value is `0`. Negative values\n * are taken as an offset from the end of the array.\n *\n * @returns The index of the removed value, or `-1` if the value\n * is not contained in the array.\n *\n * #### Notes\n * If `start < stop` the search will wrap at the end of the array.\n *\n * #### Complexity\n * Linear.\n *\n * #### Example\n * ```typescript\n * import { ArrayExt } from '@lumino/algorithm';\n *\n * let data = [0, 12, 23, 39, 14, 12, 75];\n * ArrayExt.removeLastOf(data, 12); // 5\n * ArrayExt.removeLastOf(data, 17); // -1\n * ArrayExt.removeLastOf(data, 39, 2); // -1\n * ArrayExt.removeLastOf(data, 39, 2, 3); // 3\n * ```\n */\n export function removeLastOf<T>(\n array: Array<T>,\n value: T,\n start = -1,\n stop = 0\n ): number {\n let index = lastIndexOf(array, value, start, stop);\n if (index !== -1) {\n removeAt(array, index);\n }\n return index;\n }\n\n /**\n * Remove all occurrences of a value from an array.\n *\n * @param array - The array of interest.\n *\n * @param value - The value to remove from the array. Values are\n * compared using strict `===` equality.\n *\n * @param start - The index of the first element in the range to be\n * searched, inclusive. The default value is `0`. Negative values\n * are taken as an offset from the end of the array.\n *\n * @param stop - The index of the last element in the range to be\n * searched, inclusive. The default value is `-1`. Negative values\n * are taken as an offset from the end of the array.\n *\n * @returns The number of elements removed from the array.\n *\n * #### Notes\n * If `stop < start` the search will conceptually wrap at the end of\n * the array, however the array will be traversed front-to-back.\n *\n * #### Complexity\n * Linear.\n *\n * #### Example\n * ```typescript\n * import { ArrayExt } from '@lumino/algorithm';\n *\n * let data = [14, 12, 23, 39, 14, 12, 19, 14];\n * ArrayExt.removeAllOf(data, 12); // 2\n * ArrayExt.removeAllOf(data, 17); // 0\n * ArrayExt.removeAllOf(data, 14, 1, 4); // 1\n * ```\n */\n export function removeAllOf<T>(\n array: Array<T>,\n value: T,\n start = 0,\n stop = -1\n ): number {\n let n = array.length;\n if (n === 0) {\n return 0;\n }\n if (start < 0) {\n start = Math.max(0, start + n);\n } else {\n start = Math.min(start, n - 1);\n }\n if (stop < 0) {\n stop = Math.max(0, stop + n);\n } else {\n stop = Math.min(stop, n - 1);\n }\n let count = 0;\n for (let i = 0; i < n; ++i) {\n if (start <= stop && i >= start && i <= stop && array[i] === value) {\n count++;\n } else if (\n stop < start &&\n (i <= stop || i >= start) &&\n array[i] === value\n ) {\n count++;\n } else if (count > 0) {\n array[i - count] = array[i];\n }\n }\n if (count > 0) {\n array.length = n - count;\n }\n return count;\n }\n\n /**\n * Remove the first occurrence of a value which matches a predicate.\n *\n * @param array - The array of interest.\n *\n * @param fn - The predicate function to apply to the values.\n *\n * @param start - The index of the first element in the range to be\n * searched, inclusive. The default value is `0`. Negative values\n * are taken as an offset from the end of the array.\n *\n * @param stop - The index of the last element in the range to be\n * searched, inclusive. The default value is `-1`. Negative values\n * are taken as an offset from the end of the array.\n *\n * @returns The removed `{ index, value }`, which will be `-1` and\n * `undefined` if the value is not contained in the array.\n *\n * #### Notes\n * If `stop < start` the search will wrap at the end of the array.\n *\n * #### Complexity\n * Linear.\n *\n * #### Example\n * ```typescript\n * import { ArrayExt } from '@lumino/algorithm';\n *\n * function isEven(value: number): boolean {\n * return value % 2 === 0;\n * }\n *\n * let data = [0, 12, 23, 39, 14, 12, 75];\n * ArrayExt.removeFirstWhere(data, isEven); // { index: 0, value: 0 }\n * ArrayExt.removeFirstWhere(data, isEven, 2); // { index: 3, value: 14 }\n * ArrayExt.removeFirstWhere(data, isEven, 4); // { index: -1, value: undefined }\n * ```\n */\n export function removeFirstWhere<T>(\n array: Array<T>,\n fn: (value: T, index: number) => boolean,\n start = 0,\n stop = -1\n ): { index: number; value: T | undefined } {\n let value: T | undefined;\n let index = findFirstIndex(array, fn, start, stop);\n if (index !== -1) {\n value = removeAt(array, index);\n }\n return { index, value };\n }\n\n /**\n * Remove the last occurrence of a value which matches a predicate.\n *\n * @param array - The array of interest.\n *\n * @param fn - The predicate function to apply to the values.\n *\n * @param start - The index of the first element in the range to be\n * searched, inclusive. The default value is `-1`. Negative values\n * are taken as an offset from the end of the array.\n *\n * @param stop - The index of the last element in the range to be\n * searched, inclusive. The default value is `0`. Negative values\n * are taken as an offset from the end of the array.\n *\n * @returns The removed `{ index, value }`, which will be `-1` and\n * `undefined` if the value is not contained in the array.\n *\n * #### Notes\n * If `start < stop` the search will wrap at the end of the array.\n *\n * #### Complexity\n * Linear.\n *\n * #### Example\n * ```typescript\n * import { ArrayExt } from '@lumino/algorithm';\n *\n * function isEven(value: number): boolean {\n * return value % 2 === 0;\n * }\n *\n * let data = [0, 12, 23, 39, 14, 12, 75];\n * ArrayExt.removeLastWhere(data, isEven); // { index: 5, value: 12 }\n * ArrayExt.removeLastWhere(data, isEven, 2); // { index: 1, value: 12 }\n * ArrayExt.removeLastWhere(data, isEven, 2, 1); // { index: -1, value: undefined }\n * ```\n */\n export function removeLastWhere<T>(\n array: Array<T>,\n fn: (value: T, index: number) => boolean,\n start = -1,\n stop = 0\n ): { index: number; value: T | undefined } {\n let value: T | undefined;\n let index = findLastIndex(array, fn, start, stop);\n if (index !== -1) {\n value = removeAt(array, index);\n }\n return { index, value };\n }\n\n /**\n * Remove all occurrences of values which match a predicate.\n *\n * @param array - The array of interest.\n *\n * @param fn - The predicate function to apply to the values.\n *\n * @param start - The index of the first element in the range to be\n * searched, inclusive. The default value is `0`. Negative values\n * are taken as an offset from the end of the array.\n *\n * @param stop - The index of the last element in the range to be\n * searched, inclusive. The default value is `-1`. Negative values\n * are taken as an offset from the end of the array.\n *\n * @returns The number of elements removed from the array.\n *\n * #### Notes\n * If `stop < start` the search will conceptually wrap at the end of\n * the array, however the array will be traversed front-to-back.\n *\n * #### Complexity\n * Linear.\n *\n * #### Example\n * ```typescript\n * import { ArrayExt } from '@lumino/algorithm';\n *\n * function isEven(value: number): boolean {\n * return value % 2 === 0;\n * }\n *\n * function isNegative(value: number): boolean {\n * return value < 0;\n * }\n *\n * let data = [0, 12, -13, -9, 23, 39, 14, -15, 12, 75];\n * ArrayExt.removeAllWhere(data, isEven); // 4\n * ArrayExt.removeAllWhere(data, isNegative, 0, 3); // 2\n * ```\n */\n export function removeAllWhere<T>(\n array: Array<T>,\n fn: (value: T, index: number) => boolean,\n start = 0,\n stop = -1\n ): number {\n let n = array.length;\n if (n === 0) {\n return 0;\n }\n if (start < 0) {\n start = Math.max(0, start + n);\n } else {\n start = Math.min(start, n - 1);\n }\n if (stop < 0) {\n stop = Math.max(0, stop + n);\n } else {\n stop = Math.min(stop, n - 1);\n }\n let count = 0;\n for (let i = 0; i < n; ++i) {\n if (start <= stop && i >= start && i <= stop && fn(array[i], i)) {\n count++;\n } else if (stop < start && (i <= stop || i >= start) && fn(array[i], i)) {\n count++;\n } else if (count > 0) {\n array[i - count] = array[i];\n }\n }\n if (count > 0) {\n array.length = n - count;\n }\n return count;\n }\n}\n","// Copyright (c) Jupyter Development Team.\n// Distributed under the terms of the Modified BSD License.\n/*-----------------------------------------------------------------------------\n| Copyright (c) 2014-2017, PhosphorJS Contributors\n|\n| Distributed under the terms of the BSD 3-Clause License.\n|\n| The full license is in the file LICENSE, distributed with this software.\n|----------------------------------------------------------------------------*/\n\n/**\n * An object which can produce an iterator over its values.\n */\nexport interface IIterable<T> {\n /**\n * Get an iterator over the object's values.\n *\n * @returns An iterator which yields the object's values.\n *\n * #### Notes\n * Depending on the iterable, the returned iterator may or may not be\n * a new object. A collection or other container-like object should\n * typically return a new iterator, while an iterator itself should\n * normally return `this`.\n */\n iter(): IIterator<T>;\n}\n\n/**\n * An object which traverses a collection of values.\n *\n * #### Notes\n * An `IIterator` is itself an `IIterable`. Most implementations of\n * `IIterator` should simply return `this` from the `iter()` method.\n */\nexport interface IIterator<T> extends IIterable<T> {\n /**\n * Create an independent clone of the iterator.\n *\n * @returns A new independent clone of the iterator.\n *\n * #### Notes\n * The cloned iterator can be consumed independently of the current\n * iterator. In essence, it is a copy of the iterator value stream\n * which starts at the current location.\n *\n * This can be useful for lookahead and stream duplication.\n */\n clone(): IIterator<T>;\n\n /**\n * Get the next value from the iterator.\n *\n * @returns The next value from the iterator, or `undefined`.\n *\n * #### Notes\n * The `undefined` value is used to signal the end of iteration and\n * should therefore not be used as a value in a collection.\n *\n * The use of the `undefined` sentinel is an explicit design choice\n * which favors performance over purity. The ES6 iterator design of\n * returning a `{ value, done }` pair is suboptimal, as it requires\n * an object allocation on each iteration; and an `isDone()` method\n * would increase implementation and runtime complexity.\n */\n next(): T | undefined;\n}\n\n/**\n * A type alias for an iterable or builtin array-like object.\n */\nexport type IterableOrArrayLike<T> = IIterable<T> | ArrayLike<T>;\n\n/**\n * Create an iterator for an iterable object.\n *\n * @param object - The iterable or array-like object of interest.\n *\n * @returns A new iterator for the given object.\n *\n * #### Notes\n * This function allows iteration algorithms to operate on user-defined\n * iterable types and builtin array-like objects in a uniform fashion.\n */\nexport function iter<T>(object: IterableOrArrayLike<T>): IIterator<T> {\n let it: IIterator<T>;\n if (typeof (object as any).iter === 'function') {\n it = (object as IIterable<T>).iter();\n } else {\n it = new ArrayIterator<T>(object as ArrayLike<T>);\n }\n return it;\n}\n\n/**\n * Create an iterator for the keys in an object.\n *\n * @param object - The object of interest.\n *\n * @returns A new iterator for the keys in the given object.\n *\n * #### Complexity\n * Linear.\n *\n * #### Example\n * ```typescript\n * import { each, keys } from '@lumino/algorithm';\n *\n * let data = { one: 1, two: 2, three: 3 };\n *\n * each(keys(data), key => { console.log(key); }); // 'one', 'two', 'three'\n * ```\n */\nexport function iterKeys<T>(object: {\n readonly [key: string]: T;\n}): IIterator<string> {\n return new KeyIterator(object);\n}\n\n/**\n * Create an iterator for the values in an object.\n *\n * @param object - The object of interest.\n *\n * @returns A new iterator for the values in the given object.\n *\n * #### Complexity\n * Linear.\n *\n * #### Example\n * ```typescript\n * import { each, values } from '@lumino/algorithm';\n *\n * let data = { one: 1, two: 2, three: 3 };\n *\n * each(values(data), value => { console.log(value); }); // 1, 2, 3\n * ```\n */\nexport function iterValues<T>(object: {\n readonly [key: string]: T;\n}): IIterator<T> {\n return new ValueIterator<T>(object);\n}\n\n/**\n * Create an iterator for the items in an object.\n *\n * @param object - The object of interest.\n *\n * @returns A new iterator for the items in the given object.\n *\n * #### Complexity\n * Linear.\n *\n * #### Example\n * ```typescript\n * import { each, items } from '@lumino/algorithm';\n *\n * let data = { one: 1, two: 2, three: 3 };\n *\n * each(items(data), value => { console.log(value); }); // ['one', 1], ['two', 2], ['three', 3]\n * ```\n */\nexport function iterItems<T>(object: {\n readonly [key: string]: T;\n}): IIterator<[string, T]> {\n return new ItemIterator<T>(object);\n}\n\n/**\n * Create an iterator for an iterator-like function.\n *\n * @param fn - A function which behaves like an iterator `next` method.\n *\n * @returns A new iterator for the given function.\n *\n * #### Notes\n * The returned iterator **cannot** be cloned.\n *\n * #### Example\n * ```typescript\n * import { each, iterFn } from '@lumino/algorithm';\n *\n * let it = iterFn((() => {\n * let i = 0;\n * return () => i > 3 ? undefined : i++;\n * })());\n *\n * each(it, v => { console.log(v); }); // 0, 1, 2, 3\n * ```\n */\nexport function iterFn<T>(fn: () => T | undefined): IIterator<T> {\n return new FnIterator<T>(fn);\n}\n\n/**\n * Invoke a function for each value in an iterable.\n *\n * @param object - The iterable or array-like object of interest.\n *\n * @param fn - The callback function to invoke for each value.\n *\n * #### Notes\n * Iteration can be terminated early by returning `false` from the\n * callback function.\n *\n * #### Complexity\n * Linear.\n *\n * #### Example\n * ```typescript\n * import { each } from '@lumino/algorithm';\n *\n * let data = [5, 7, 0, -2, 9];\n *\n * each(data, value => { console.log(value); });\n * ```\n */\nexport function each<T>(\n object: IterableOrArrayLike<T>,\n fn: (value: T, index: number) => boolean | void\n): void {\n let index = 0;\n let it = iter(object);\n let value: T | undefined;\n while ((value = it.next()) !== undefined) {\n if (fn(value, index++) === false) {\n return;\n }\n }\n}\n\n/**\n * Test whether all values in an iterable satisfy a predicate.\n *\n * @param object - The iterable or array-like object of interest.\n *\n * @param fn - The predicate function to invoke for each value.\n *\n * @returns `true` if all values pass the test, `false` otherwise.\n *\n * #### Notes\n * Iteration terminates on the first `false` predicate result.\n *\n * #### Complexity\n * Linear.\n *\n * #### Example\n * ```typescript\n * import { every } from '@lumino/algorithm';\n *\n * let data = [5, 7, 1];\n *\n * every(data, value => value % 2 === 0); // false\n * every(data, value => value % 2 === 1); // true\n * ```\n */\nexport function every<T>(\n object: IterableOrArrayLike<T>,\n fn: (value: T, index: number) => boolean\n): boolean {\n let index = 0;\n let it = iter(object);\n let value: T | undefined;\n while ((value = it.next()) !== undefined) {\n if (!fn(value, index++)) {\n return false;\n }\n }\n return true;\n}\n\n/**\n * Test whether any value in an iterable satisfies a predicate.\n *\n * @param object - The iterable or array-like object of interest.\n *\n * @param fn - The predicate function to invoke for each value.\n *\n * @returns `true` if any value passes the test, `false` otherwise.\n *\n * #### Notes\n * Iteration terminates on the first `true` predicate result.\n *\n * #### Complexity\n * Linear.\n *\n * #### Example\n * ```typescript\n * import { some } from '@lumino/algorithm';\n *\n * let data = [5, 7, 1];\n *\n * some(data, value => value === 7); // true\n * some(data, value => value === 3); // false\n * ```\n */\nexport function some<T>(\n object: IterableOrArrayLike<T>,\n fn: (value: T, index: number) => boolean\n): boolean {\n let index = 0;\n let it = iter(object);\n let value: T | undefined;\n while ((value = it.next()) !== undefined) {\n if (fn(value, index++)) {\n return true;\n }\n }\n return false;\n}\n\n/**\n * Create an array from an iterable of values.\n *\n * @param object - The iterable or array-like object of interest.\n *\n * @returns A new array of values from the given object.\n *\n * #### Example\n * ```typescript\n * import { iter, toArray } from '@lumino/algorithm';\n *\n * let data = [1, 2, 3, 4, 5, 6];\n *\n * let stream = iter(data);\n *\n * toArray(stream); // [1, 2, 3, 4, 5, 6];\n * ```\n */\nexport function toArray<T>(object: IterableOrArrayLike<T>): T[] {\n let index = 0;\n let result: T[] = [];\n let it = iter(object);\n let value: T | undefined;\n while ((value = it.next()) !== undefined) {\n result[index++] = value;\n }\n return result;\n}\n\n/**\n * Create an object from an iterable of key/value pairs.\n *\n * @param object - The iterable or array-like object of interest.\n *\n * @returns A new object mapping keys to values.\n *\n * #### Example\n * ```typescript\n * import { toObject } from '@lumino/algorithm';\n *\n * let data = [['one', 1], ['two', 2], ['three', 3]];\n *\n * toObject(data); // { one: 1, two: 2, three: 3 }\n * ```\n */\nexport function toObject<T>(\n object: IterableOrArrayLike<[string, T]>\n): { [key: string]: T } {\n let it = iter(object);\n let pair: [string, T] | undefined;\n let result: { [key: string]: T } = {};\n while ((pair = it.next()) !== undefined) {\n result[pair[0]] = pair[1];\n }\n return result;\n}\n\n/**\n * An iterator for an array-like object.\n *\n * #### Notes\n * This iterator can be used for any builtin JS array-like object.\n */\nexport class ArrayIterator<T> implements IIterator<T> {\n /**\n * Construct a new array iterator.\n *\n * @param source - The array-like object of interest.\n */\n constructor(source: ArrayLike<T>) {\n this._source = source;\n }\n\n /**\n * Get an iterator over the object's values.\n *\n * @returns An iterator which yields the object's values.\n */\n iter(): IIterator<T> {\n return this;\n }\n\n /**\n * Create an independent clone of the iterator.\n *\n * @returns A new independent clone of the iterator.\n */\n clone(): IIterator<T> {\n let result = new ArrayIterator<T>(this._source);\n result._index = this._index;\n return result;\n }\n\n /**\n * Get the next value from the iterator.\n *\n * @returns The next value from the iterator, or `undefined`.\n */\n next(): T | undefined {\n if (this._index >= this._source.length) {\n return undefined;\n }\n return this._source[this._index++];\n }\n\n private _index = 0;\n private _source: ArrayLike<T>;\n}\n\n/**\n * An iterator for the keys in an object.\n *\n * #### Notes\n * This iterator can be used for any JS object.\n */\nexport class KeyIterator implements IIterator<string> {\n /**\n * Construct a new key iterator.\n *\n * @param source - The object of interest.\n *\n * @param keys - The keys to iterate, if known.\n */\n constructor(\n source: { readonly [key: string]: any },\n keys = Object.keys(source)\n ) {\n this._source = source;\n this._keys = keys;\n }\n\n /**\n * Get an iterator over the object's values.\n *\n * @returns An iterator which yields the object's values.\n */\n iter(): IIterator<string> {\n return this;\n }\n\n /**\n * Create an independent clone of the iterator.\n *\n * @returns A new independent clone of the iterator.\n */\n clone(): IIterator<string> {\n let result = new KeyIterator(this._source, this._keys);\n result._index = this._index;\n return result;\n }\n\n /**\n * Get the next value from the iterator.\n *\n * @returns The next value from the iterator, or `undefined`.\n */\n next(): string | undefined {\n if (this._index >= this._keys.length) {\n return undefined;\n }\n let key = this._keys[this._index++];\n if (key in this._source) {\n return key;\n }\n return this.next();\n }\n\n private _index = 0;\n private _keys: string[];\n private _source: { readonly [key: string]: any };\n}\n\n/**\n * An iterator for the values in an object.\n *\n * #### Notes\n * This iterator can be used for any JS object.\n */\nexport class ValueIterator<T> implements IIterator<T> {\n /**\n * Construct a new value iterator.\n *\n * @param source - The object of interest.\n *\n * @param keys - The keys to iterate, if known.\n */\n constructor(\n source: { readonly [key: string]: T },\n keys = Object.keys(source)\n ) {\n this._source = source;\n this._keys = keys;\n }\n\n /**\n * Get an iterator over the object's values.\n *\n * @returns An iterator which yields the object's values.\n */\n iter(): IIterator<T> {\n return this;\n }\n\n /**\n * Create an independent clone of the iterator.\n *\n * @returns A new independent clone of the iterator.\n */\n clone(): IIterator<T> {\n let result = new ValueIterator<T>(this._source, this._keys);\n result._index = this._index;\n return result;\n }\n\n /**\n * Get the next value from the iterator.\n *\n * @returns The next value from the iterator, or `undefined`.\n */\n next(): T | undefined {\n if (this._index >= this._keys.length) {\n return undefined;\n }\n let key = this._keys[this._index++];\n if (key in this._source) {\n return this._source[key];\n }\n return this.next();\n }\n\n private _index = 0;\n private _keys: string[];\n private _source: { readonly [key: string]: T };\n}\n\n/**\n * An iterator for the items in an object.\n *\n * #### Notes\n * This iterator can be used for any JS object.\n */\nexport class ItemIterator<T> implements IIterator<[string, T]> {\n /**\n * Construct a new item iterator.\n *\n * @param source - The object of interest.\n *\n * @param keys - The keys to iterate, if known.\n */\n constructor(\n source: { readonly [key: string]: T },\n keys = Object.keys(source)\n ) {\n this._source = source;\n this._keys = keys;\n }\n\n /**\n * Get an iterator over the object's values.\n *\n * @returns An iterator which yields the object's values.\n */\n iter(): IIterator<[string, T]> {\n return this;\n }\n\n /**\n * Create an independent clone of the iterator.\n *\n * @returns A new independent clone of the iterator.\n */\n clone(): IIterator<[string, T]> {\n let result = new ItemIterator<T>(this._source, this._keys);\n result._index = this._index;\n return result;\n }\n\n /**\n * Get the next value from the iterator.\n *\n * @returns The next value from the iterator, or `undefined`.\n */\n next(): [string, T] | undefined {\n if (this._index >= this._keys.length) {\n return undefined;\n }\n let key = this._keys[this._index++];\n if (key in this._source) {\n return [key, this._source[key]];\n }\n return this.next();\n }\n\n private _index = 0;\n private _keys: string[];\n private _source: { readonly [key: string]: T };\n}\n\n/**\n * An iterator for an iterator-like function.\n */\nexport class FnIterator<T> implements IIterator<T> {\n /**\n * Construct a new function iterator.\n *\n * @param fn - The iterator-like function of interest.\n */\n constructor(fn: () => T | undefined) {\n this._fn = fn;\n }\n\n /**\n * Get an iterator over the object's values.\n *\n * @returns An iterator which yields the object's values.\n */\n iter(): IIterator<T> {\n return this;\n }\n\n /**\n * Create an independent clone of the iterator.\n *\n * @returns A new independent clone of the iterator.\n */\n clone(): IIterator<T> {\n throw new Error('An `FnIterator` cannot be cloned.');\n }\n\n /**\n * Get the next value from the iterator.\n *\n * @returns The next value from the iterator, or `undefined`.\n */\n next(): T | undefined {\n return this._fn.call(undefined);\n }\n\n private _fn: () => T | undefined;\n}\n","// Copyright (c) Jupyter Development Team.\n// Distributed under the terms of the Modified BSD License.\n/*-----------------------------------------------------------------------------\n| Copyright (c) 2014-2017, PhosphorJS Contributors\n|\n| Distributed under the terms of the BSD 3-Clause License.\n|\n| The full license is in the file LICENSE, distributed with this software.\n|----------------------------------------------------------------------------*/\nimport { IIterator, iter, IterableOrArrayLike } from './iter';\n\n/**\n * Chain together several iterables.\n *\n * @param objects - The iterable or array-like objects of interest.\n *\n * @returns An iterator which yields the values of the iterables\n * in the order in which they are supplied.\n *\n * #### Example\n * ```typescript\n * import { chain, toArray } from '@lumino/algorithm';\n *\n * let data1 = [1, 2, 3];\n * let data2 = [4, 5, 6];\n *\n * let stream = chain(data1, data2);\n *\n * toArray(stream); // [1, 2, 3, 4, 5, 6]\n * ```\n */\nexport function chain<T>(...objects: IterableOrArrayLike<T>[]): IIterator<T> {\n return new ChainIterator<T>(iter(objects.map(iter)));\n}\n\n/**\n * An iterator which chains together several iterators.\n */\nexport class ChainIterator<T> implements IIterator<T> {\n /**\n * Construct a new chain iterator.\n *\n * @param source - The iterator of iterators of interest.\n */\n constructor(source: IIterator<IIterator<T>>) {\n this._source = source;\n this._active = undefined;\n }\n\n /**\n * Get an iterator over the object's values.\n *\n * @returns An iterator which yields the object's values.\n */\n iter(): IIterator<T> {\n return this;\n }\n\n /**\n * Create an independent clone of the iterator.\n *\n * @returns A new independent clone of the iterator.\n */\n clone(): IIterator<T> {\n let result = new ChainIterator<T>(this._source.clone());\n result._active = this._active && this._active.clone();\n result._cloned = true;\n this._cloned = true;\n return result;\n }\n\n /**\n * Get the next value from the iterator.\n *\n * @returns The next value from the iterator, or `undefined`.\n */\n next(): T | undefined {\n if (this._active === undefined) {\n let active = this._source.next();\n if (active === undefined) {\n return undefined;\n }\n this._active = this._cloned ? active.clone() : active;\n }\n let value = this._active.next();\n if (value !== undefined) {\n return value;\n }\n this._active = undefined;\n return this.next();\n }\n\n private _source: IIterator<IIterator<T>>;\n private _active: IIterator<T> | undefined;\n private _cloned = false;\n}\n","// Copyright (c) Jupyter Development Team.\n// Distributed under the terms of the Modified BSD License.\n/*-----------------------------------------------------------------------------\n| Copyright (c) 2014-2017, PhosphorJS Contributors\n|\n| Distributed under the terms of the BSD 3-Clause License.\n|\n| The full license is in the file LICENSE, distributed with this software.\n|----------------------------------------------------------------------------*/\nimport { IIterator } from './iter';\n\n/**\n * Create an empty iterator.\n *\n * @returns A new iterator which yields nothing.\n *\n * #### Example\n * ```typescript\n * import { empty, toArray } from '@lumino/algorithm';\n *\n * let stream = empty<number>();\n *\n * toArray(stream); // []\n * ```\n */\nexport function empty<T>(): IIterator<T> {\n return new EmptyIterator<T>();\n}\n\n/**\n * An iterator which is always empty.\n */\nexport class EmptyIterator<T> implements IIterator<T> {\n /**\n * Get an iterator over the object's values.\n *\n * @returns An iterator which yields the object's values.\n */\n iter(): IIterator<T> {\n return this;\n }\n\n /**\n * Create an independent clone of the iterator.\n *\n * @returns A new independent clone of the iterator.\n */\n clone(): IIterator<T> {\n return new EmptyIterator<T>();\n }\n\n /**\n * Get the next value from the iterator.\n *\n * @returns The next value from the iterator, or `undefined`.\n */\n next(): T | undefined {\n return undefined;\n }\n}\n","// Copyright (c) Jupyter Development Team.\n// Distributed under the terms of the Modified BSD License.\n/*-----------------------------------------------------------------------------\n| Copyright (c) 2014-2017, PhosphorJS Contributors\n|\n| Distributed under the terms of the BSD 3-Clause License.\n|\n| The full license is in the file LICENSE, distributed with this software.\n|----------------------------------------------------------------------------*/\nimport { IIterator, iter, IterableOrArrayLike } from './iter';\n\n/**\n * Enumerate an iterable object.\n *\n * @param object - The iterable or array-like object of interest.\n *\n * @param start - The starting enum value. The default is `0`.\n *\n * @returns An iterator which yields the enumerated values.\n *\n * #### Example\n * ```typescript\n * import { enumerate, toArray } from '@lumino/algorithm';\n *\n * let data = ['foo', 'bar', 'baz'];\n *\n * let stream = enumerate(data, 1);\n *\n * toArray(stream); // [[1, 'foo'], [2, 'bar'], [3, 'baz']]\n * ```\n */\nexport function enumerate<T>(\n object: IterableOrArrayLike<T>,\n start = 0\n): IIterator<[number, T]> {\n return new EnumerateIterator<T>(iter(object), start);\n}\n\n/**\n * An iterator which enumerates the source values.\n */\nexport class EnumerateIterator<T> implements IIterator<[number, T]> {\n /**\n * Construct a new enumerate iterator.\n *\n * @param source - The iterator of values of interest.\n *\n * @param start - The starting enum value.\n */\n constructor(source: IIterator<T>, start: number) {\n this._source = source;\n this._index = start;\n }\n\n /**\n * Get an iterator over the object's values.\n *\n * @returns An iterator which yields the object's values.\n */\n iter(): IIterator<[number, T]> {\n return this;\n }\n\n /**\n * Create an independent clone of the iterator.\n *\n * @returns A new independent clone of the iterator.\n */\n clone(): IIterator<[number, T]> {\n return new EnumerateIterator<T>(this._source.clone(), this._index);\n }\n\n /**\n * Get the next value from the iterator.\n *\n * @returns The next value from the iterator, or `undefined`.\n */\n next(): [number, T] | undefined {\n let value = this._source.next();\n if (value === undefined) {\n return undefined;\n }\n return [this._index++, value];\n }\n\n private _source: IIterator<T>;\n private _index: number;\n}\n","// Copyright (c) Jupyter Development Team.\n// Distributed under the terms of the Modified BSD License.\n/*-----------------------------------------------------------------------------\n| Copyright (c) 2014-2017, PhosphorJS Contributors\n|\n| Distributed under the terms of the BSD 3-Clause License.\n|\n| The full license is in the file LICENSE, distributed with this software.\n|----------------------------------------------------------------------------*/\nimport { IIterator, iter, IterableOrArrayLike } from './iter';\n\n/**\n * Filter an iterable for values which pass a test.\n *\n * @param object - The iterable or array-like object of interest.\n *\n * @param fn - The predicate function to invoke for each value.\n *\n * @returns An iterator which yields the values which pass the test.\n *\n * #### Example\n * ```typescript\n * import { filter, toArray } from '@lumino/algorithm';\n *\n * let data = [1, 2, 3, 4, 5, 6];\n *\n * let stream = filter(data, value => value % 2 === 0);\n *\n * toArray(stream); // [2, 4, 6]\n * ```\n */\nexport function filter<T>(\n object: IterableOrArrayLike<T>,\n fn: (value: T, index: number) => boolean\n): IIterator<T> {\n return new FilterIterator<T>(iter(object), fn);\n}\n\n/**\n * An iterator which yields values which pass a test.\n */\nexport class FilterIterator<T> implements IIterator<T> {\n /**\n * Construct a new filter iterator.\n *\n * @param source - The iterator of values of interest.\n *\n * @param fn - The predicate function to invoke for each value.\n */\n constructor(source: IIterator<T>, fn: (value: T, index: number) => boolean) {\n this._source = source;\n this._fn = fn;\n }\n\n /**\n * Get an iterator over the object's values.\n *\n * @returns An iterator which yields the object's values.\n */\n iter(): IIterator<T> {\n return this;\n }\n\n /**\n * Create an independent clone of the iterator.\n *\n * @returns A new independent clone of the iterator.\n */\n clone(): IIterator<T> {\n let result = new FilterIterator<T>(this._source.clone(), this._fn);\n result._index = this._index;\n return result;\n }\n\n /**\n * Get the next value from the iterator.\n *\n * @returns The next value from the iterator, or `undefined`.\n */\n next(): T | undefined {\n let fn = this._fn;\n let it = this._source;\n let value: T | undefined;\n while ((value = it.next()) !== undefined) {\n if (fn(value, this._index++)) {\n return value;\n }\n }\n return undefined;\n }\n\n private _index = 0;\n private _source: IIterator<T>;\n private _fn: (value: T, index: number) => boolean;\n}\n","// Copyright (c) Jupyter Development Team.\n// Distributed under the terms of the Modified BSD License.\n/*-----------------------------------------------------------------------------\n| Copyright (c) 2014-2017, PhosphorJS Contributors\n|\n| Distributed under the terms of the BSD 3-Clause License.\n|\n| The full license is in the file LICENSE, distributed with this software.\n|----------------------------------------------------------------------------*/\nimport { iter, IterableOrArrayLike } from './iter';\n\n/**\n * Find the first value in an iterable which matches a predicate.\n *\n * @param object - The iterable or array-like object to search.\n *\n * @param fn - The predicate function to apply to the values.\n *\n * @returns The first matching value, or `undefined` if no matching\n * value is found.\n *\n * #### Complexity\n * Linear.\n *\n * #### Example\n * ```typescript\n * import { find } from '@lumino/algorithm';\n *\n * interface IAnimal { species: string, name: string };\n *\n * function isCat(value: IAnimal): boolean {\n * return value.species === 'cat';\n * }\n *\n * let data: IAnimal[] = [\n * { species: 'dog', name: 'spot' },\n * { species: 'cat', name: 'fluffy' },\n * { species: 'alligator', name: 'pocho' }\n * ];\n *\n * find(data, isCat).name; // 'fluffy'\n * ```\n */\nexport function find<T>(\n object: IterableOrArrayLike<T>,\n fn: (value: T, index: number) => boolean\n): T | undefined {\n let index = 0;\n let it = iter(object);\n let value: T | undefined;\n while ((value = it.next()) !== undefined) {\n if (fn(value, index++)) {\n return value;\n }\n }\n return undefined;\n}\n\n/**\n * Find the index of the first value which matches a predicate.\n *\n * @param object - The iterable or array-like object to search.\n *\n * @param fn - The predicate function to apply to the values.\n *\n * @returns The index of the first matching value, or `-1` if no\n * matching value is found.\n *\n * #### Complexity\n * Linear.\n *\n * #### Example\n * ```typescript\n * import { findIndex } from '@lumino/algorithm';\n *\n * interface IAnimal { species: string, name: string };\n *\n * function isCat(value: IAnimal): boolean {\n * return value.species === 'cat';\n * }\n *\n * let data: IAnimal[] = [\n * { species: 'dog', name: 'spot' },\n * { species: 'cat', name: 'fluffy' },\n * { species: 'alligator', name: 'pocho' }\n * ];\n *\n * findIndex(data, isCat); // 1\n * ```\n */\nexport function findIndex<T>(\n object: IterableOrArrayLike<T>,\n fn: (value: T, index: number) => boolean\n): number {\n let index = 0;\n let it = iter(object);\n let value: T | undefined;\n while ((value = it.next()) !== undefined) {\n if (fn(value, index++)) {\n return index - 1;\n }\n }\n return -1;\n}\n\n/**\n * Find the minimum value in an iterable.\n *\n * @param object - The iterable or array-like object to search.\n *\n * @param fn - The 3-way comparison function to apply to the values.\n * It should return `< 0` if the first value is less than the second.\n * `0` if the values are equivalent, or `> 0` if the first value is\n * greater than the second.\n *\n * @returns The minimum value in the iterable. If multiple values are\n * equivalent to the minimum, the left-most value is returned. If\n * the iterable is empty, this returns `undefined`.\n *\n * #### Complexity\n * Linear.\n *\n * #### Example\n * ```typescript\n * import { min } from '@lumino/algorithm';\n *\n * function numberCmp(a: number, b: number): number {\n * return a - b;\n * }\n *\n * min([7, 4, 0, 3, 9, 4], numberCmp); // 0\n * ```\n */\nexport function min<T>(\n object: IterableOrArrayLike<T>,\n fn: (first: T, second: T) => number\n): T | undefined {\n let it = iter(object);\n let value = it.next();\n if (value === undefined) {\n return undefined;\n }\n let result = value;\n while ((value = it.next()) !== undefined) {\n if (fn(value, result) < 0) {\n result = value;\n }\n }\n return result;\n}\n\n/**\n * Find the maximum value in an iterable.\n *\n * @param object - The iterable or array-like object to search.\n *\n * @param fn - The 3-way comparison function to apply to the values.\n * It should return `< 0` if the first value is less than the second.\n * `0` if the values are equivalent, or `> 0` if the first value is\n * greater than the second.\n *\n * @returns The maximum value in the iterable. If multiple values are\n * equivalent to the maximum, the left-most value is returned. If\n * the iterable is empty, this returns `undefined`.\n *\n * #### Complexity\n * Linear.\n *\n * #### Example\n * ```typescript\n * import { max } from '@lumino/algorithm';\n *\n * function numberCmp(a: number, b: number): number {\n * return a - b;\n * }\n *\n * max([7, 4, 0, 3, 9, 4], numberCmp); // 9\n * ```\n */\nexport function max<T>(\n object: IterableOrArrayLike<T>,\n fn: (first: T, second: T) => number\n): T | undefined {\n let it = iter(object);\n let value = it.next();\n if (value === undefined) {\n return undefined;\n }\n let result = value;\n while ((value = it.next()) !== undefined) {\n if (fn(value, result) > 0) {\n result = value;\n }\n }\n return result;\n}\n\n/**\n * Find the minimum and maximum values in an iterable.\n *\n * @param object - The iterable or array-like object to search.\n *\n * @param fn - The 3-way comparison function to apply to the values.\n * It should return `< 0` if the first value is less than the second.\n * `0` if the values are equivalent, or `> 0` if the first value is\n * greater than the second.\n *\n * @returns A 2-tuple of the `[min, max]` values in the iterable. If\n * multiple values are equivalent, the left-most values are returned.\n * If the iterable is empty, this returns `undefined`.\n *\n * #### Complexity\n * Linear.\n *\n * #### Example\n * ```typescript\n * import { minmax } from '@lumino/algorithm';\n *\n * function numberCmp(a: number, b: number): number {\n * return a - b;\n * }\n *\n * minmax([7, 4, 0, 3, 9, 4], numberCmp); // [0, 9]\n * ```\n */\nexport function minmax<T>(\n object: IterableOrArrayLike<T>,\n fn: (first: T, second: T) => number\n): [T, T] | undefined {\n let it = iter(object);\n let value = it.next();\n if (value === undefined) {\n return undefined;\n }\n let vmin = value;\n let vmax = value;\n while ((value = it.next()) !== undefined) {\n if (fn(value, vmin) < 0) {\n vmin = value;\n } else if (fn(value, vmax) > 0) {\n vmax = value;\n }\n }\n return [vmin, vmax];\n}\n","// Copyright (c) Jupyter Development Team.\n// Distributed under the terms of the Modified BSD License.\n/*-----------------------------------------------------------------------------\n| Copyright (c) 2014-2017, PhosphorJS Contributors\n|\n| Distributed under the terms of the BSD 3-Clause License.\n|\n| The full license is in the file LICENSE, distributed with this software.\n|----------------------------------------------------------------------------*/\nimport { IIterator, iter, IterableOrArrayLike } from './iter';\n\n/**\n * Transform the values of an iterable with a mapping function.\n *\n * @param object - The iterable or array-like object of interest.\n *\n * @param fn - The mapping function to invoke for each value.\n *\n * @returns An iterator which yields the transformed values.\n *\n * #### Example\n * ```typescript\n * import { map, toArray } from '@lumino/algorithm';\n *\n * let data = [1, 2, 3];\n *\n * let stream = map(data, value => value * 2);\n *\n * toArray(stream); // [2, 4, 6]\n * ```\n */\nexport function map<T, U>(\n object: IterableOrArrayLike<T>,\n fn: (value: T, index: number) => U\n): IIterator<U> {\n return new MapIterator<T, U>(iter(object), fn);\n}\n\n/**\n * An iterator which transforms values using a mapping function.\n */\nexport class MapIterator<T, U> implements IIterator<U> {\n /**\n * Construct a new map iterator.\n *\n * @param source - The iterator of values of interest.\n *\n * @param fn - The mapping function to invoke for each value.\n */\n constructor(source: IIterator<T>, fn: (value: T, index: number) => U) {\n this._source = source;\n this._fn = fn;\n }\n\n /**\n * Get an iterator over the object's values.\n *\n * @returns An iterator which yields the object's values.\n */\n iter(): IIterator<U> {\n return this;\n }\n\n /**\n * Create an independent clone of the iterator.\n *\n * @returns A new independent clone of the iterator.\n */\n clone(): IIterator<U> {\n let result = new MapIterator<T, U>(this._source.clone(), this._fn);\n result._index = this._index;\n return result;\n }\n\n /**\n * Get the next value from the iterator.\n *\n * @returns The next value from the iterator, or `undefined`.\n */\n next(): U | undefined {\n let value = this._source.next();\n if (value === undefined) {\n return undefined;\n }\n return this._fn.call(undefined, value, this._index++);\n }\n\n private _index = 0;\n private _source: IIterator<T>;\n private _fn: (value: T, index: number) => U;\n}\n","// Copyright (c) Jupyter Development Team.\n// Distributed under the terms of the Modified BSD License.\n/*-----------------------------------------------------------------------------\n| Copyright (c) 2014-2017, PhosphorJS Contributors\n|\n| Distributed under the terms of the BSD 3-Clause License.\n|\n| The full license is in the file LICENSE, distributed with this software.\n|----------------------------------------------------------------------------*/\nimport { IIterator } from './iter';\n\n/**\n * Create an iterator of evenly spaced values.\n *\n * @param start - The starting value for the range, inclusive.\n *\n * @param stop - The stopping value for the range, exclusive.\n *\n * @param step - The distance between each value.\n *\n * @returns An iterator which produces evenly spaced values.\n *\n * #### Notes\n * In the single argument form of `range(stop)`, `start` defaults to\n * `0` and `step` defaults to `1`.\n *\n * In the two argument form of `range(start, stop)`, `step` defaults\n * to `1`.\n */\nexport function range(\n start: number,\n stop?: number,\n step?: number\n): IIterator<number> {\n if (stop === undefined) {\n return new RangeIterator(0, start, 1);\n }\n if (step === undefined) {\n return new RangeIterator(start, stop, 1);\n }\n return new RangeIterator(start, stop, step);\n}\n\n/**\n * An iterator which produces a range of evenly spaced values.\n */\nexport class RangeIterator implements IIterator<number> {\n /**\n * Construct a new range iterator.\n *\n * @param start - The starting value for the range, inclusive.\n *\n * @param stop - The stopping value for the range, exclusive.\n *\n * @param step - The distance between each value.\n */\n constructor(start: number, stop: number, step: number) {\n this._start = start;\n this._stop = stop;\n this._step = step;\n this._length = Private.rangeLength(start, stop, step);\n }\n\n /**\n * Get an iterator over the object's values.\n *\n * @returns An iterator which yields the object's values.\n */\n iter(): IIterator<number> {\n return this;\n }\n\n /**\n * Create an independent clone of the iterator.\n *\n * @returns A new independent clone of the iterator.\n */\n clone(): IIterator<number> {\n let result = new RangeIterator(this._start, this._stop, this._step);\n result._index = this._index;\n return result;\n }\n\n /**\n * Get the next value from the iterator.\n *\n * @returns The next value from the iterator, or `undefined`.\n */\n next(): number | undefined {\n if (this._index >= this._length) {\n return undefined;\n }\n return this._start + this._step * this._index++;\n }\n\n private _index = 0;\n private _length: number;\n private _start: number;\n private _stop: number;\n private _step: number;\n}\n\n/**\n * The namespace for the module implementation details.\n */\nnamespace Private {\n /**\n * Compute the effective length of a range.\n *\n * @param start - The starting value for the range, inclusive.\n *\n * @param stop - The stopping value for the range, exclusive.\n *\n * @param step - The distance between each value.\n *\n * @returns The number of steps need to traverse the range.\n */\n export function rangeLength(\n start: number,\n stop: number,\n step: number\n ): number {\n if (step === 0) {\n return Infinity;\n }\n if (start > stop && step > 0) {\n return 0;\n }\n if (start < stop && step < 0) {\n return 0;\n }\n return Math.ceil((stop - start) / step);\n }\n}\n","// Copyright (c) Jupyter Development Team.\n// Distributed under the terms of the Modified BSD License.\n/*-----------------------------------------------------------------------------\n| Copyright (c) 2014-2017, PhosphorJS Contributors\n|\n| Distributed under the terms of the BSD 3-Clause License.\n|\n| The full license is in the file LICENSE, distributed with this software.\n|----------------------------------------------------------------------------*/\nimport { iter, IterableOrArrayLike } from './iter';\n\n/**\n * Summarize all values in an iterable using a reducer function.\n *\n * @param object - The iterable or array-like object of interest.\n *\n * @param fn - The reducer function to invoke for each value.\n *\n * @param initial - The initial value to start accumulation.\n *\n * @returns The final accumulated value.\n *\n * #### Notes\n * The `reduce` function follows the conventions of `Array#reduce`.\n *\n * If the iterator is empty, an initial value is required. That value\n * will be used as the return value. If no initial value is provided,\n * an error will be thrown.\n *\n * If the iterator contains a single item and no initial value is\n * provided, the single item is used as the return value.\n *\n * Otherwise, the reducer is invoked for each element in the iterable.\n * If an initial value is not provided, the first element will be used\n * as the initial accumulated value.\n *\n * #### Complexity\n * Linear.\n *\n * #### Example\n * ```typescript\n * import { reduce } from '@lumino/algorithm';\n *\n * let data = [1, 2, 3, 4, 5];\n *\n * let sum = reduce(data, (a, value) => a + value); // 15\n * ```\n */\nexport function reduce<T>(\n object: IterableOrArrayLike<T>,\n fn: (accumulator: T, value: T, index: number) => T\n): T;\nexport function reduce<T, U>(\n object: IterableOrArrayLike<T>,\n fn: (accumulator: U, value: T, index: number) => U,\n initial: U\n): U;\nexport function reduce<T>(\n object: IterableOrArrayLike<T>,\n fn: (accumulator: any, value: T, index: number) => any,\n initial?: any\n): any {\n // Setup the iterator and fetch the first value.\n let index = 0;\n let it = iter(object);\n let first = it.next();\n\n // An empty iterator and no initial value is an error.\n if (first === undefined && initial === undefined) {\n throw new TypeError('Reduce of empty iterable with no initial value.');\n }\n\n // If the iterator is empty, return the initial value.\n if (first === undefined) {\n return initial;\n }\n\n // If the iterator has a single item and no initial value, the\n // reducer is not invoked and the first item is the return value.\n let second = it.next();\n if (second === undefined && initial === undefined) {\n return first;\n }\n\n // If iterator has a single item and an initial value is provided,\n // the reducer is invoked and that result is the return value.\n if (second === undefined) {\n return fn(initial, first, index++);\n }\n\n // Setup the initial accumlated value.\n let accumulator: any;\n if (initial === undefined) {\n accumulator = fn(first, second, index++);\n } else {\n accumulator = fn(fn(initial, first, index++), second, index++);\n }\n\n // Iterate the rest of the values, updating the accumulator.\n let next: T | undefined;\n while ((next = it.next()) !== undefined) {\n accumulator = fn(accumulator, next, index++);\n }\n\n // Return the final accumulated value.\n return accumulator;\n}\n","// Copyright (c) Jupyter Development Team.\n// Distributed under the terms of the Modified BSD License.\n/*-----------------------------------------------------------------------------\n| Copyright (c) 2014-2017, PhosphorJS Contributors\n|\n| Distributed under the terms of the BSD 3-Clause License.\n|\n| The full license is in the file LICENSE, distributed with this software.\n|----------------------------------------------------------------------------*/\nimport { IIterator } from './iter';\n\n/**\n * Create an iterator which repeats a value a number of times.\n *\n * @param value - The value to repeat.\n *\n * @param count - The number of times to repeat the value.\n *\n * @returns A new iterator which repeats the specified value.\n *\n * #### Example\n * ```typescript\n * import { repeat, toArray } from '@lumino/algorithm';\n *\n * let stream = repeat(7, 3);\n *\n * toArray(stream); // [7, 7, 7]\n * ```\n */\nexport function repeat<T>(value: T, count: number): IIterator<T> {\n return new RepeatIterator<T>(value, count);\n}\n\n/**\n * Create an iterator which yields a value a single time.\n *\n * @param value - The value to wrap in an iterator.\n *\n * @returns A new iterator which yields the value a single time.\n *\n * #### Example\n * ```typescript\n * import { once, toArray } from '@lumino/algorithm';\n *\n * let stream = once(7);\n *\n * toArray(stream); // [7]\n * ```\n */\nexport function once<T>(value: T): IIterator<T> {\n return new RepeatIterator<T>(value, 1);\n}\n\n/**\n * An iterator which repeats a value a specified number of times.\n */\nexport class RepeatIterator<T> implements IIterator<T> {\n /**\n * Construct a new repeat iterator.\n *\n * @param value - The value to repeat.\n *\n * @param count - The number of times to repeat the value.\n */\n constructor(value: T, count: number) {\n this._value = value;\n this._count = count;\n }\n\n /**\n * Get an iterator over the object's values.\n *\n * @returns An iterator which yields the object's values.\n */\n iter(): IIterator<T> {\n return this;\n }\n\n /**\n * Create an independent clone of the iterator.\n *\n * @returns A new independent clone of the iterator.\n */\n clone(): IIterator<T> {\n return new RepeatIterator<T>(this._value, this._count);\n }\n\n /**\n * Get the next value from the iterator.\n *\n * @returns The next value from the iterator, or `undefined`.\n */\n next(): T | undefined {\n if (this._count <= 0) {\n return undefined;\n }\n this._count--;\n return this._value;\n }\n\n private _value: T;\n private _count: number;\n}\n","// Copyright (c) Jupyter Development Team.\n// Distributed under the terms of the Modified BSD License.\n/*-----------------------------------------------------------------------------\n| Copyright (c) 2014-2017, PhosphorJS Contributors\n|\n| Distributed under the terms of the BSD 3-Clause License.\n|\n| The full license is in the file LICENSE, distributed with this software.\n|----------------------------------------------------------------------------*/\nimport { IIterator } from './iter';\n\n/**\n * An object which can produce a reverse iterator over its values.\n */\nexport interface IRetroable<T> {\n /**\n * Get a reverse iterator over the object's values.\n *\n * @returns An iterator which yields the object's values in reverse.\n */\n retro(): IIterator<T>;\n}\n\n/**\n * A type alias for a retroable or builtin array-like object.\n */\nexport type RetroableOrArrayLike<T> = IRetroable<T> | ArrayLike<T>;\n\n/**\n * Create an iterator for a retroable object.\n *\n * @param object - The retroable or array-like object of interest.\n *\n * @returns An iterator which traverses the object's values in reverse.\n *\n * #### Example\n * ```typescript\n * import { retro, toArray } from '@lumino/algorithm';\n *\n * let data = [1, 2, 3, 4, 5, 6];\n *\n * let stream = retro(data);\n *\n * toArray(stream); // [6, 5, 4, 3, 2, 1]\n * ```\n */\nexport function retro<T>(object: RetroableOrArrayLike<T>): IIterator<T> {\n let it: IIterator<T>;\n if (typeof (object as any).retro === 'function') {\n it = (object as IRetroable<T>).retro();\n } else {\n it = new RetroArrayIterator<T>(object as ArrayLike<T>);\n }\n return it;\n}\n\n/**\n * An iterator which traverses an array-like object in reverse.\n *\n * #### Notes\n * This iterator can be used for any builtin JS array-like object.\n */\nexport class RetroArrayIterator<T> implements IIterator<T> {\n /**\n * Construct a new retro iterator.\n *\n * @param source - The array-like object of interest.\n */\n constructor(source: ArrayLike<T>) {\n this._source = source;\n this._index = source.length - 1;\n }\n\n /**\n * Get an iterator over the object's values.\n *\n * @returns An iterator which yields the object's values.\n */\n iter(): IIterator<T> {\n return this;\n }\n\n /**\n * Create an independent clone of the iterator.\n *\n * @returns A new independent clone of the iterator.\n */\n clone(): IIterator<T> {\n let result = new RetroArrayIterator<T>(this._source);\n result._index = this._index;\n return result;\n }\n\n /**\n * Get the next value from the iterator.\n *\n * @returns The next value from the iterator, or `undefined`.\n */\n next(): T | undefined {\n if (this._index < 0 || this._index >= this._source.length) {\n return undefined;\n }\n return this._source[this._index--];\n }\n\n private _index: number;\n private _source: ArrayLike<T>;\n}\n","// Copyright (c) Jupyter Development Team.\n// Distributed under the terms of the Modified BSD License.\n/*-----------------------------------------------------------------------------\n| Copyright (c) 2014-2017, PhosphorJS Contributors\n|\n| Distributed under the terms of the BSD 3-Clause License.\n|\n| The full license is in the file LICENSE, distributed with this software.\n|----------------------------------------------------------------------------*/\nimport { each, IterableOrArrayLike } from './iter';\n\n/**\n * Topologically sort an iterable of edges.\n *\n * @param edges - The iterable or array-like object of edges to sort.\n * An edge is represented as a 2-tuple of `[fromNode, toNode]`.\n *\n * @returns The topologically sorted array of nodes.\n *\n * #### Notes\n * If a cycle is present in the graph, the cycle will be ignored and\n * the return value will be only approximately sorted.\n *\n * #### Example\n * ```typescript\n * import { topologicSort } from '@lumino/algorithm';\n *\n * let data = [\n * ['d', 'e'],\n * ['c', 'd'],\n * ['a', 'b'],\n * ['b', 'c']\n * ];\n *\n * topologicSort(data); // ['a', 'b', 'c', 'd', 'e']\n * ```\n */\nexport function topologicSort<T>(edges: IterableOrArrayLike<[T, T]>): T[] {\n // Setup the shared sorting state.\n let sorted: T[] = [];\n let visited = new Set<T>();\n let graph = new Map<T, T[]>();\n\n // Add the edges to the graph.\n each(edges, addEdge);\n\n // Visit each node in the graph.\n graph.forEach((v, k) => {\n visit(k);\n });\n\n // Return the sorted results.\n return sorted;\n\n // Add an edge to the graph.\n function addEdge(edge: [T, T]): void {\n let [fromNode, toNode] = edge;\n let children = graph.get(toNode);\n if (children) {\n children.push(fromNode);\n } else {\n graph.set(toNode, [fromNode]);\n }\n }\n\n // Recursively visit the node.\n function visit(node: T): void {\n if (visited.has(node)) {\n return;\n }\n visited.add(node);\n let children = graph.get(node);\n if (children) {\n children.forEach(visit);\n }\n sorted.push(node);\n }\n}\n","// Copyright (c) Jupyter Development Team.\n// Distributed under the terms of the Modified BSD License.\n/*-----------------------------------------------------------------------------\n| Copyright (c) 2014-2017, PhosphorJS Contributors\n|\n| Distributed under the terms of the BSD 3-Clause License.\n|\n| The full license is in the file LICENSE, distributed with this software.\n|----------------------------------------------------------------------------*/\nimport { IIterator, iter, IterableOrArrayLike } from './iter';\n\n/**\n * Iterate over an iterable using a stepped increment.\n *\n * @param object - The iterable or array-like object of interest.\n *\n * @param step - The distance to step on each iteration. A value\n * of less than `1` will behave the same as a value of `1`.\n *\n * @returns An iterator which traverses the iterable step-wise.\n *\n * #### Example\n * ```typescript\n * import { stride, toArray } from '@lumino/algorithm';\n *\n * let data = [1, 2, 3, 4, 5, 6];\n *\n * let stream = stride(data, 2);\n *\n * toArray(stream); // [1, 3, 5];\n * ```\n */\nexport function stride<T>(\n object: IterableOrArrayLike<T>,\n step: number\n): IIterator<T> {\n return new StrideIterator<T>(iter(object), step);\n}\n\n/**\n * An iterator which traverses a source iterator step-wise.\n */\nexport class StrideIterator<T> implements IIterator<T> {\n /**\n * Construct a new stride iterator.\n *\n * @param source - The iterator of values of interest.\n *\n * @param step - The distance to step on each iteration. A value\n * of less than `1` will behave the same as a value of `1`.\n */\n constructor(source: IIterator<T>, step: number) {\n this._source = source;\n this._step = step;\n }\n\n /**\n * Get an iterator over the object's values.\n *\n * @returns An iterator which yields the object's values.\n */\n iter(): IIterator<T> {\n return this;\n }\n\n /**\n * Create an independent clone of the iterator.\n *\n * @returns A new independent clone of the iterator.\n */\n clone(): IIterator<T> {\n return new StrideIterator<T>(this._source.clone(), this._step);\n }\n\n /**\n * Get the next value from the iterator.\n *\n * @returns The next value from the iterator, or `undefined`.\n */\n next(): T | undefined {\n let value = this._source.next();\n for (let n = this._step - 1; n > 0; --n) {\n this._source.next();\n }\n return value;\n }\n\n private _source: IIterator<T>;\n private _step: number;\n}\n","// Copyright (c) Jupyter Development Team.\n// Distributed under the terms of the Modified BSD License.\n/*-----------------------------------------------------------------------------\n| Copyright (c) 2014-2017, PhosphorJS Contributors\n|\n| Distributed under the terms of the BSD 3-Clause License.\n|\n| The full license is in the file LICENSE, distributed with this software.\n|----------------------------------------------------------------------------*/\n\n/**\n * The namespace for string-specific algorithms.\n */\nexport namespace StringExt {\n /**\n * Find the indices of characters in a source text.\n *\n * @param source - The source text which should be searched.\n *\n * @param query - The characters to locate in the source text.\n *\n * @param start - The index to start the search.\n *\n * @returns The matched indices, or `null` if there is no match.\n *\n * #### Complexity\n * Linear on `sourceText`.\n *\n * #### Notes\n * In order for there to be a match, all of the characters in `query`\n * **must** appear in `source` in the order given by `query`.\n *\n * Characters are matched using strict `===` equality.\n */\n export function findIndices(\n source: string,\n query: string,\n start = 0\n ): number[] | null {\n let indices = new Array<number>(query.length);\n for (let i = 0, j = start, n = query.length; i < n; ++i, ++j) {\n j = source.indexOf(query[i], j);\n if (j === -1) {\n return null;\n }\n indices[i] = j;\n }\n return indices;\n }\n\n /**\n * The result of a string match function.\n */\n export interface IMatchResult {\n /**\n * A score which indicates the strength of the match.\n *\n * The documentation of a given match function should specify\n * whether a lower or higher score is a stronger match.\n */\n score: number;\n\n /**\n * The indices of the matched characters in the source text.\n *\n * The indices will appear in increasing order.\n */\n indices: number[];\n }\n\n /**\n * A string matcher which uses a sum-of-squares algorithm.\n *\n * @param source - The source text which should be searched.\n *\n * @param query - The characters to locate in the source text.\n *\n * @param start - The index to start the search.\n *\n * @returns The match result, or `null` if there is no match.\n * A lower `score` represents a stronger match.\n *\n * #### Complexity\n * Linear on `sourceText`.\n *\n * #### Notes\n * This scoring algorithm uses a sum-of-squares approach to determine\n * the score. In order for there to be a match, all of the characters\n * in `query` **must** appear in `source` in order. The index of each\n * matching character is squared and added to the score. This means\n * that early and consecutive character matches are preferred, while\n * late matches are heavily penalized.\n */\n export function matchSumOfSquares(\n source: string,\n query: string,\n start = 0\n ): IMatchResult | null {\n let indices = findIndices(source, query, start);\n if (!indices) {\n return null;\n }\n let score = 0;\n for (let i = 0, n = indices.length; i < n; ++i) {\n let j = indices[i] - start;\n score += j * j;\n }\n return { score, indices };\n }\n\n /**\n * A string matcher which uses a sum-of-deltas algorithm.\n *\n * @param source - The source text which should be searched.\n *\n * @param query - The characters to locate in the source text.\n *\n * @param start - The index to start the search.\n *\n * @returns The match result, or `null` if there is no match.\n * A lower `score` represents a stronger match.\n *\n * #### Complexity\n * Linear on `sourceText`.\n *\n * #### Notes\n * This scoring algorithm uses a sum-of-deltas approach to determine\n * the score. In order for there to be a match, all of the characters\n * in `query` **must** appear in `source` in order. The delta between\n * the indices are summed to create the score. This means that groups\n * of matched characters are preferred, while fragmented matches are\n * penalized.\n */\n export function matchSumOfDeltas(\n source: string,\n query: string,\n start = 0\n ): IMatchResult | null {\n let indices = findIndices(source, query, start);\n if (!indices) {\n return null;\n }\n let score = 0;\n let last = start - 1;\n for (let i = 0, n = indices.length; i < n; ++i) {\n let j = indices[i];\n score += j - last - 1;\n last = j;\n }\n return { score, indices };\n }\n\n /**\n * Highlight the matched characters of a source text.\n *\n * @param source - The text which should be highlighted.\n *\n * @param indices - The indices of the matched characters. They must\n * appear in increasing order and must be in bounds of the source.\n *\n * @param fn - The function to apply to the matched chunks.\n *\n * @returns An array of unmatched and highlighted chunks.\n */\n export function highlight<T>(\n source: string,\n indices: ReadonlyArray<number>,\n fn: (chunk: string) => T\n ): Array<string | T> {\n // Set up the result array.\n let result: Array<string | T> = [];\n\n // Set up the counter variables.\n let k = 0;\n let last = 0;\n let n = indices.length;\n\n // Iterator over each index.\n while (k < n) {\n // Set up the chunk indices.\n let i = indices[k];\n let j = indices[k];\n\n // Advance the right chunk index until it's non-contiguous.\n while (++k < n && indices[k] === j + 1) {\n j++;\n }\n\n // Extract the unmatched text.\n if (last < i) {\n result.push(source.slice(last, i));\n }\n\n // Extract and highlight the matched text.\n if (i < j + 1) {\n result.push(fn(source.slice(i, j + 1)));\n }\n\n // Update the last visited index.\n last = j + 1;\n }\n\n // Extract any remaining unmatched text.\n if (last < source.length) {\n result.push(source.slice(last));\n }\n\n // Return the highlighted result.\n return result;\n }\n\n /**\n * A 3-way string comparison function.\n *\n * @param a - The first string of interest.\n *\n * @param b - The second string of interest.\n *\n * @returns `-1` if `a < b`, else `1` if `a > b`, else `0`.\n */\n export function cmp(a: string, b: string): number {\n return a < b ? -1 : a > b ? 1 : 0;\n }\n}\n","// Copyright (c) Jupyter Development Team.\n// Distributed under the terms of the Modified BSD License.\n/*-----------------------------------------------------------------------------\n| Copyright (c) 2014-2017, PhosphorJS Contributors\n|\n| Distributed under the terms of the BSD 3-Clause License.\n|\n| The full license is in the file LICENSE, distributed with this software.\n|----------------------------------------------------------------------------*/\nimport { IIterator, iter, IterableOrArrayLike } from './iter';\n\n/**\n * Take a fixed number of items from an iterable.\n *\n * @param object - The iterable or array-like object of interest.\n *\n * @param count - The number of items to take from the iterable.\n *\n * @returns An iterator which yields the specified number of items\n * from the source iterable.\n *\n * #### Notes\n * The returned iterator will exhaust early if the source iterable\n * contains an insufficient number of items.\n */\nexport function take<T>(\n object: IterableOrArrayLike<T>,\n count: number\n): IIterator<T> {\n return new TakeIterator<T>(iter(object), count);\n}\n\n/**\n * An iterator which takes a fixed number of items from a source.\n */\nexport class TakeIterator<T> implements IIterator<T> {\n /**\n * Construct a new take iterator.\n *\n * @param source - The iterator of interest.\n *\n * @param count - The number of items to take from the source.\n */\n constructor(source: IIterator<T>, count: number) {\n this._source = source;\n this._count = count;\n }\n\n /**\n * Get an iterator over the object's values.\n *\n * @returns An iterator which yields the object's values.\n */\n iter(): IIterator<T> {\n return this;\n }\n\n /**\n * Create an independent clone of the iterator.\n *\n * @returns A new independent clone of the iterator.\n */\n clone(): IIterator<T> {\n return new TakeIterator<T>(this._source.clone(), this._count);\n }\n\n /**\n * Get the next value from the iterator.\n *\n * @returns The next value from the iterator, or `undefined`.\n */\n next(): T | undefined {\n if (this._count <= 0) {\n return undefined;\n }\n let value = this._source.next();\n if (value === undefined) {\n return undefined;\n }\n this._count--;\n return value;\n }\n\n private _count: number;\n private _source: IIterator<T>;\n}\n","// Copyright (c) Jupyter Development Team.\n// Distributed under the terms of the Modified BSD License.\n/*-----------------------------------------------------------------------------\n| Copyright (c) 2014-2017, PhosphorJS Contributors\n|\n| Distributed under the terms of the BSD 3-Clause License.\n|\n| The full license is in the file LICENSE, distributed with this software.\n|----------------------------------------------------------------------------*/\nimport { IIterator, iter, IterableOrArrayLike } from './iter';\n\n/**\n * Iterate several iterables in lockstep.\n *\n * @param objects - The iterable or array-like objects of interest.\n *\n * @returns An iterator which yields successive tuples of values where\n * each value is taken in turn from the provided iterables. It will\n * be as long as the shortest provided iterable.\n *\n * #### Example\n * ```typescript\n * import { zip, toArray } from '@lumino/algorithm';\n *\n * let data1 = [1, 2, 3];\n * let data2 = [4, 5, 6];\n *\n * let stream = zip(data1, data2);\n *\n * toArray(stream); // [[1, 4], [2, 5], [3, 6]]\n * ```\n */\nexport function zip<T>(...objects: IterableOrArrayLike<T>[]): IIterator<T[]> {\n return new ZipIterator<T>(objects.map(iter));\n}\n\n/**\n * An iterator which iterates several sources in lockstep.\n */\nexport class ZipIterator<T> implements IIterator<T[]> {\n /**\n * Construct a new zip iterator.\n *\n * @param source - The iterators of interest.\n */\n constructor(source: IIterator<T>[]) {\n this._source = source;\n }\n\n /**\n * Get an iterator over the object's values.\n *\n * @returns An iterator which yields the object's values.\n */\n iter(): IIterator<T[]> {\n return this;\n }\n\n /**\n * Create an independent clone of the iterator.\n *\n * @returns A new independent clone of the iterator.\n */\n clone(): IIterator<T[]> {\n return new ZipIterator<T>(this._source.map(it => it.clone()));\n }\n\n /**\n * Get the next value from the iterator.\n *\n * @returns The next value from the iterator, or `undefined`.\n */\n next(): T[] | undefined {\n let result = new Array<T>(this._source.length);\n for (let i = 0, n = this._source.length; i < n; ++i) {\n let value = this._source[i].next();\n if (value === undefined) {\n return undefined;\n }\n result[i] = value;\n }\n return result;\n }\n\n private _source: IIterator<T>[];\n}\n"],"names":["ArrayExt","StringExt"],"mappings":"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"} |