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

{"version":3,"file":"index.es6.js","sources":["../src/array.ts","../src/chain.ts","../src/empty.ts","../src/enumerate.ts","../src/filter.ts","../src/find.ts","../src/iter.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 * 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/**\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 * 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 * 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 * 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 * 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 * 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 * 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|----------------------------------------------------------------------------*/\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 * 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 * 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|----------------------------------------------------------------------------*/\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"],"names":[],"mappings":"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"}