@lumino/algorithm/dist/index.min.js.map

{"version":3,"names":["every","object","fn","index","value","Private","ArrayExt","firstIndexOf","array","start","stop","span","n","length","Math","max","min","i","j","lastIndexOf","findFirstIndex","findLastIndex","d","reverse","a","b","removeAt","findFirstValue","undefined","findLastValue","lowerBound","begin","half","middle","upperBound","shallowEqual","slice","options","step","Error","floor","result","move","fromIndex","toIndex","rotate","delta","pivot","fill","insert","removeFirstOf","removeLastOf","removeAllOf","count","removeFirstWhere","removeLastWhere","removeAllWhere","rangeLength","Infinity","ceil","StringExt","findIndices","source","query","indices","Array","indexOf","matchSumOfSquares","score","matchSumOfDeltas","last","highlight","k","push","cmp","objects","vmin","vmax","empty","initial","it","Symbol","iterator","first","next","done","TypeError","accumulator","second","retro","item","from","key","edges","sorted","visited","Set","graph","Map","edge","addEdge","visit","fromNode","toNode","children","get","set","node","has","add","child","iters","map","obj","tuple"],"sources":["../src/iter.ts","../src/range.ts","../src/array.ts","../src/string.ts","../src/chain.ts","../src/empty.ts","../src/enumerate.ts","../src/filter.ts","../src/find.ts","../src/map.ts","../src/repeat.ts","../src/reduce.ts","../src/retro.ts","../src/stride.ts","../src/take.ts","../src/sort.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 * Create an array from an iterable of values.\n *\n * @deprecated\n *\n * @param object - The iterable object of interest.\n *\n * @returns A new array of values from the given object.\n *\n * #### Example\n * ```typescript\n * import { toArray } from '@lumino/algorithm';\n *\n * let stream = [1, 2, 3, 4, 5, 6][Symbol.iterator]();\n *\n * toArray(stream);  // [1, 2, 3, 4, 5, 6];\n * ```\n */\nexport function toArray<T>(object: Iterable<T>): T[] {\n  return Array.from(object);\n}\n\n/**\n * Create an object from an iterable of key/value pairs.\n *\n * @param object - The iterable 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: [string, number][] = [['one', 1], ['two', 2], ['three', 3]];\n *\n * toObject(data);  // { one: 1, two: 2, three: 3 }\n * ```\n */\nexport function toObject<T>(object: Iterable<[string, T]>): {\n  [key: string]: T;\n} {\n  const result: { [key: string]: T } = {};\n  for (const [key, value] of object) {\n    result[key] = value;\n  }\n  return result;\n}\n\n/**\n * Invoke a function for each value in an iterable.\n *\n * @deprecated\n *\n * @param object - The iterable 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: Iterable<T>,\n  fn: (value: T, index: number) => boolean | void\n): void {\n  let index = 0;\n  for (const value of object) {\n    if (false === fn(value, index++)) {\n      return;\n    }\n  }\n}\n\n/**\n * Test whether all values in an iterable satisfy a predicate.\n *\n * @param object - The iterable 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: Iterable<T>,\n  fn: (value: T, index: number) => boolean\n): boolean {\n  let index = 0;\n  for (const value of object) {\n    if (false === 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 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: Iterable<T>,\n  fn: (value: T, index: number) => boolean\n): boolean {\n  let index = 0;\n  for (const value of object) {\n    if (fn(value, index++)) {\n      return true;\n    }\n  }\n  return 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|----------------------------------------------------------------------------*/\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 *\n * #### Example\n * ```typescript\n * import { range } from '@lumino/algorithm';\n *\n * let stream = range(2, 4);\n *\n * Array.from(stream);  // [2, 3]\n * ```\n */\nexport function* range(\n  start: number,\n  stop?: number,\n  step?: number\n): IterableIterator<number> {\n  if (stop === undefined) {\n    stop = start;\n    start = 0;\n    step = 1;\n  } else if (step === undefined) {\n    step = 1;\n  }\n  const length = Private.rangeLength(start, stop, step);\n  for (let index = 0; index < length; index++) {\n    yield start + step * index;\n  }\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|----------------------------------------------------------------------------*/\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 * 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|----------------------------------------------------------------------------*/\n\n/**\n * Chain together several iterables.\n *\n * @deprecated\n *\n * @param objects - The iterable 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 } 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 * Array.from(stream);  // [1, 2, 3, 4, 5, 6]\n * ```\n */\nexport function* chain<T>(...objects: Iterable<T>[]): IterableIterator<T> {\n  for (const object of objects) {\n    yield* object;\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 * Create an empty iterator.\n *\n * @returns A new iterator which yields nothing.\n *\n * #### Example\n * ```typescript\n * import { empty } from '@lumino/algorithm';\n *\n * let stream = empty<number>();\n *\n * Array.from(stream);  // []\n * ```\n */\n// eslint-disable-next-line require-yield\nexport function* empty<T>(): IterableIterator<T> {\n  return;\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 * Enumerate an iterable object.\n *\n * @param object - The iterable 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 } from '@lumino/algorithm';\n *\n * let data = ['foo', 'bar', 'baz'];\n *\n * let stream = enumerate(data, 1);\n *\n * Array.from(stream);  // [[1, 'foo'], [2, 'bar'], [3, 'baz']]\n * ```\n */\nexport function* enumerate<T>(\n  object: Iterable<T>,\n  start = 0\n): IterableIterator<[number, T]> {\n  for (const value of object) {\n    yield [start++, value];\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 * Filter an iterable for values which pass a test.\n *\n * @param object - The iterable 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 } 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 * Array.from(stream);  // [2, 4, 6]\n * ```\n */\nexport function* filter<T>(\n  object: Iterable<T>,\n  fn: (value: T, index: number) => boolean\n): IterableIterator<T> {\n  let index = 0;\n  for (const value of object) {\n    if (fn(value, index++)) {\n      yield value;\n    }\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 * Find the first value in an iterable which matches a predicate.\n *\n * @param object - The iterable 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: Iterable<T>,\n  fn: (value: T, index: number) => boolean\n): T | undefined {\n  let index = 0;\n  for (const value of object) {\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 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: Iterable<T>,\n  fn: (value: T, index: number) => boolean\n): number {\n  let index = 0;\n  for (const value of object) {\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 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: Iterable<T>,\n  fn: (first: T, second: T) => number\n): T | undefined {\n  let result: T | undefined = undefined;\n  for (const value of object) {\n    if (result === undefined) {\n      result = value;\n      continue;\n    }\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 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: Iterable<T>,\n  fn: (first: T, second: T) => number\n): T | undefined {\n  let result: T | undefined = undefined;\n  for (const value of object) {\n    if (result === undefined) {\n      result = value;\n      continue;\n    }\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 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: Iterable<T>,\n  fn: (first: T, second: T) => number\n): [T, T] | undefined {\n  let empty = true;\n  let vmin: T;\n  let vmax: T;\n  for (const value of object) {\n    if (empty) {\n      vmin = value;\n      vmax = value;\n      empty = false;\n    } else if (fn(value, vmin!) < 0) {\n      vmin = value;\n    } else if (fn(value, vmax!) > 0) {\n      vmax = value;\n    }\n  }\n  return empty ? undefined : [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|----------------------------------------------------------------------------*/\n/**\n * Transform the values of an iterable with a mapping function.\n *\n * @param object - The iterable 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 } from '@lumino/algorithm';\n *\n * let data = [1, 2, 3];\n *\n * let stream = map(data, value => value * 2);\n *\n * Array.from(stream);  // [2, 4, 6]\n * ```\n */\nexport function* map<T, U>(\n  object: Iterable<T>,\n  fn: (value: T, index: number) => U\n): IterableIterator<U> {\n  let index = 0;\n  for (const value of object) {\n    yield fn(value, index++);\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 * Create an iterator which repeats a value a number of times.\n *\n * @deprecated\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 } from '@lumino/algorithm';\n *\n * let stream = repeat(7, 3);\n *\n * Array.from(stream);  // [7, 7, 7]\n * ```\n */\nexport function* repeat<T>(value: T, count: number): IterableIterator<T> {\n  while (0 < count--) {\n    yield value;\n  }\n}\n\n/**\n * Create an iterator which yields a value a single time.\n *\n * @deprecated\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 } from '@lumino/algorithm';\n *\n * let stream = once(7);\n *\n * Array.from(stream);  // [7]\n * ```\n */\nexport function* once<T>(value: T): IterableIterator<T> {\n  yield value;\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 * Summarize all values in an iterable using a reducer function.\n *\n * @param object - The iterable 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: Iterable<T>,\n  fn: (accumulator: T, value: T, index: number) => T\n): T;\nexport function reduce<T, U>(\n  object: Iterable<T>,\n  fn: (accumulator: U, value: T, index: number) => U,\n  initial: U\n): U;\nexport function reduce<T>(\n  object: Iterable<T>,\n  fn: (accumulator: any, value: T, index: number) => any,\n  initial?: unknown\n): any {\n  // Setup the iterator and fetch the first value.\n  const it = object[Symbol.iterator]();\n  let index = 0;\n  let first = it.next();\n\n  // An empty iterator and no initial value is an error.\n  if (first.done && 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.done) {\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.done && initial === undefined) {\n    return first.value;\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.done) {\n    return fn(initial, first.value, index++);\n  }\n\n  // Setup the initial accumlated value.\n  let accumulator: any;\n  if (initial === undefined) {\n    accumulator = fn(first.value, second.value, index++);\n  } else {\n    accumulator = fn(fn(initial, first.value, index++), second.value, index++);\n  }\n\n  // Iterate the rest of the values, updating the accumulator.\n  let next: IteratorResult<T>;\n  while (!(next = it.next()).done) {\n    accumulator = fn(accumulator, next.value, 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|----------------------------------------------------------------------------*/\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(): IterableIterator<T>;\n}\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 } from '@lumino/algorithm';\n *\n * let data = [1, 2, 3, 4, 5, 6];\n *\n * let stream = retro(data);\n *\n * Array.from(stream);  // [6, 5, 4, 3, 2, 1]\n * ```\n */\nexport function* retro<T>(\n  object: IRetroable<T> | ArrayLike<T>\n): IterableIterator<T> {\n  if (typeof (object as IRetroable<T>).retro === 'function') {\n    yield* (object as IRetroable<T>).retro();\n  } else {\n    for (let index = (object as ArrayLike<T>).length - 1; index > -1; index--) {\n      yield (object as ArrayLike<T>)[index];\n    }\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 * Iterate over an iterable using a stepped increment.\n *\n * @param object - The iterable 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 } from '@lumino/algorithm';\n *\n * let data = [1, 2, 3, 4, 5, 6];\n *\n * let stream = stride(data, 2);\n *\n * Array.from(stream);  // [1, 3, 5];\n * ```\n */\nexport function* stride<T>(\n  object: Iterable<T>,\n  step: number\n): IterableIterator<T> {\n  let count = 0;\n  for (const value of object) {\n    if (0 === count++ % step) {\n      yield value;\n    }\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 * Take a fixed number of items from an iterable.\n *\n * @param object - The iterable 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 *\n * #### Example\n * ```typescript\n * import { take } from '@lumino/algorithm';\n *\n * let stream = take([5, 4, 3, 2, 1, 0, -1], 3);\n *\n * Array.from(stream);  // [5, 4, 3]\n * ```\n */\nexport function* take<T>(\n  object: Iterable<T>,\n  count: number\n): IterableIterator<T> {\n  if (count < 1) {\n    return;\n  }\n  const it = object[Symbol.iterator]();\n  let item: IteratorResult<T>;\n  while (0 < count-- && !(item = it.next()).done) {\n    yield item.value;\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 * Topologically sort an iterable of edges.\n *\n * @param edges - The iterable 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: Iterable<[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  for (const edge of edges) {\n    addEdge(edge);\n  }\n\n  // Visit each node in the graph.\n  for (const [k] of graph) {\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      for (const child of children) {\n        visit(child);\n      }\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 { every } from './iter';\n\n/**\n * Iterate several iterables in lockstep.\n *\n * @param objects - The iterable 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 } 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 * Array.from(stream);  // [[1, 4], [2, 5], [3, 6]]\n * ```\n */\nexport function* zip<T>(...objects: Iterable<T>[]): IterableIterator<T[]> {\n  const iters = objects.map(obj => obj[Symbol.iterator]());\n  let tuple = iters.map(it => it.next());\n  for (; every(tuple, item => !item.done); tuple = iters.map(it => it.next())) {\n    yield tuple.map(item => item.value);\n  }\n}\n"],"mappings":"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"}