/// <reference path="types.ts"/>

/// <reference path="performance.ts" />

namespace ts {

/** The version of the TypeScript compiler release */

export const version = "2.2.0";

}

/* @internal */

namespace ts {

/**

* Ternary values are defined such that

* x & y is False if either x or y is False.

* x & y is Maybe if either x or y is Maybe, but neither x or y is False.

* x & y is True if both x and y are True.

* x | y is False if both x and y are False.

* x | y is Maybe if either x or y is Maybe, but neither x or y is True.

* x | y is True if either x or y is True.

*/

export const enum Ternary {

False = 0,

Maybe = 1,

True = -1

}

const createObject = Object.create;

// More efficient to create a collator once and use its `compare` than to call `a.localeCompare(b)` many times.

export const collator: { compare(a: string, b: string): number } = typeof Intl === "object" && typeof Intl.Collator === "function" ? new Intl.Collator() : undefined;

export function createMap<T>(template?: MapLike<T>): Map<T> {

const map: Map<T> = createObject(null); // tslint:disable-line:no-null-keyword

// Using 'delete' on an object causes V8 to put the object in dictionary mode.

// This disables creation of hidden classes, which are expensive when an object is

// constantly changing shape.

map["__"] = undefined;

delete map["__"];

// Copies keys/values from template. Note that for..in will not throw if

// template is undefined, and instead will just exit the loop.

for (const key in template) if (hasOwnProperty.call(template, key)) {

map[key] = template[key];

}

return map;

}

export function createFileMap<T>(keyMapper?: (key: string) => string): FileMap<T> {

let files = createMap<T>();

return {

get,

set,

contains,

remove,

forEachValue: forEachValueInMap,

getKeys,

clear,

};

function forEachValueInMap(f: (key: Path, value: T) => void) {

for (const key in files) {

f(<Path>key, files[key]);

}

}

function getKeys() {

const keys: Path[] = [];

for (const key in files) {

keys.push(<Path>key);

}

return keys;

}

// path should already be well-formed so it does not need to be normalized

function get(path: Path): T {

return files[toKey(path)];

}

function set(path: Path, value: T) {

files[toKey(path)] = value;

}

function contains(path: Path) {

return toKey(path) in files;

}

function remove(path: Path) {

const key = toKey(path);

delete files[key];

}

function clear() {

files = createMap<T>();

}

function toKey(path: Path): string {

return keyMapper ? keyMapper(path) : path;

}

}

export function toPath(fileName: string, basePath: string, getCanonicalFileName: (path: string) => string): Path {

const nonCanonicalizedPath = isRootedDiskPath(fileName)

? normalizePath(fileName)

: getNormalizedAbsolutePath(fileName, basePath);

return <Path>getCanonicalFileName(nonCanonicalizedPath);

}

export const enum Comparison {

LessThan = -1,

EqualTo = 0,

GreaterThan = 1

}

/**

* Iterates through 'array' by index and performs the callback on each element of array until the callback

* returns a truthy value, then returns that value.

* If no such value is found, the callback is applied to each element of array and undefined is returned.

*/

export function forEach<T, U>(array: T[] | undefined, callback: (element: T, index: number) => U | undefined): U | undefined {

if (array) {

for (let i = 0, len = array.length; i < len; i++) {

const result = callback(array[i], i);

if (result) {

return result;

}

}

}

return undefined;

}

export function zipWith<T, U>(arrayA: T[], arrayB: U[], callback: (a: T, b: U, index: number) => void): void {

Debug.assert(arrayA.length === arrayB.length);

for (let i = 0; i < arrayA.length; i++) {

callback(arrayA[i], arrayB[i], i);

}

}

/**

* Iterates through `array` by index and performs the callback on each element of array until the callback

* returns a falsey value, then returns false.

* If no such value is found, the callback is applied to each element of array and `true` is returned.

*/

export function every<T>(array: T[], callback: (element: T, index: number) => boolean): boolean {

if (array) {

for (let i = 0, len = array.length; i < len; i++) {

if (!callback(array[i], i)) {

return false;

}

}

}

return true;

}

/** Works like Array.prototype.find, returning `undefined` if no element satisfying the predicate is found. */

export function find<T>(array: T[], predicate: (element: T, index: number) => boolean): T | undefined {

for (let i = 0, len = array.length; i < len; i++) {

const value = array[i];

if (predicate(value, i)) {

return value;

}

}

return undefined;

}

/**

* Returns the first truthy result of `callback`, or else fails.

* This is like `forEach`, but never returns undefined.

*/

export function findMap<T, U>(array: T[], callback: (element: T, index: number) => U | undefined): U {

for (let i = 0, len = array.length; i < len; i++) {

const result = callback(array[i], i);

if (result) {

return result;

}

}

Debug.fail();

}

export function contains<T>(array: T[], value: T): boolean {

if (array) {

for (const v of array) {

if (v === value) {

return true;

}

}

}

return false;

}

export function indexOf<T>(array: T[], value: T): number {

if (array) {

for (let i = 0, len = array.length; i < len; i++) {

if (array[i] === value) {

return i;

}

}

}

return -1;

}

export function indexOfAnyCharCode(text: string, charCodes: number[], start?: number): number {

for (let i = start || 0, len = text.length; i < len; i++) {

if (contains(charCodes, text.charCodeAt(i))) {

return i;

}

}

return -1;

}

export function countWhere<T>(array: T[], predicate: (x: T, i: number) => boolean): number {

let count = 0;

if (array) {

for (let i = 0; i < array.length; i++) {

const v = array[i];

if (predicate(v, i)) {

count++;

}

}

}

return count;

}

/**

* Filters an array by a predicate function. Returns the same array instance if the predicate is

* true for all elements, otherwise returns a new array instance containing the filtered subset.

*/

export function filter<T, U extends T>(array: T[], f: (x: T) => x is U): U[];

export function filter<T>(array: T[], f: (x: T) => boolean): T[];

export function filter<T>(array: T[], f: (x: T) => boolean): T[] {

if (array) {

const len = array.length;

let i = 0;

while (i < len && f(array[i])) i++;

if (i < len) {

const result = array.slice(0, i);

i++;

while (i < len) {

const item = array[i];

if (f(item)) {

result.push(item);

}

i++;

}

return result;

}

}

return array;

}

export function removeWhere<T>(array: T[], f: (x: T) => boolean): boolean {

let outIndex = 0;

for (const item of array) {

if (!f(item)) {

array[outIndex] = item;

outIndex++;

}

}

if (outIndex !== array.length) {

array.length = outIndex;

return true;

}

return false;

}

export function filterMutate<T>(array: T[], f: (x: T) => boolean): void {

let outIndex = 0;

for (const item of array) {

if (f(item)) {

array[outIndex] = item;

outIndex++;

}

}

array.length = outIndex;

}

export function map<T, U>(array: T[], f: (x: T, i: number) => U): U[] {

let result: U[];

if (array) {

result = [];

for (let i = 0; i < array.length; i++) {

result.push(f(array[i], i));

}

}

return result;

}

// Maps from T to T and avoids allocation if all elements map to themselves

export function sameMap<T>(array: T[], f: (x: T, i: number) => T): T[] {

let result: T[];

if (array) {

for (let i = 0; i < array.length; i++) {

if (result) {

result.push(f(array[i], i));

}

else {

const item = array[i];

const mapped = f(item, i);

if (item !== mapped) {

result = array.slice(0, i);

result.push(mapped);

}

}

}

}

return result || array;

}

/**

* Flattens an array containing a mix of array or non-array elements.

*

* @param array The array to flatten.

*/

export function flatten<T>(array: (T | T[])[]): T[] {

let result: T[];

if (array) {

result = [];

for (const v of array) {

if (v) {

if (isArray(v)) {

addRange(result, v);

}

else {

result.push(v);

}

}

}

}

return result;

}

/**

* Maps an array. If the mapped value is an array, it is spread into the result.

*

* @param array The array to map.

* @param mapfn The callback used to map the result into one or more values.

*/

export function flatMap<T, U>(array: T[], mapfn: (x: T, i: number) => U | U[]): U[] {

let result: U[];

if (array) {

result = [];

for (let i = 0; i < array.length; i++) {

const v = mapfn(array[i], i);

if (v) {

if (isArray(v)) {

addRange(result, v);

}

else {

result.push(v);

}

}

}

}

return result;

}

/**

* Computes the first matching span of elements and returns a tuple of the first span

* and the remaining elements.

*/

export function span<T>(array: T[], f: (x: T, i: number) => boolean): [T[], T[]] {

if (array) {

for (let i = 0; i < array.length; i++) {

if (!f(array[i], i)) {

return [array.slice(0, i), array.slice(i)];

}

}

return [array.slice(0), []];

}

return undefined;

}

/**

* Maps contiguous spans of values with the same key.

*

* @param array The array to map.

* @param keyfn A callback used to select the key for an element.

* @param mapfn A callback used to map a contiguous chunk of values to a single value.

*/

export function spanMap<T, K, U>(array: T[], keyfn: (x: T, i: number) => K, mapfn: (chunk: T[], key: K, start: number, end: number) => U): U[] {

let result: U[];

if (array) {

result = [];

const len = array.length;

let previousKey: K;

let key: K;

let start = 0;

let pos = 0;

while (start < len) {

while (pos < len) {

const value = array[pos];

key = keyfn(value, pos);

if (pos === 0) {

previousKey = key;

}

else if (key !== previousKey) {

break;

}

pos++;

}

if (start < pos) {

const v = mapfn(array.slice(start, pos), previousKey, start, pos);

if (v) {

result.push(v);

}

start = pos;

}

previousKey = key;

pos++;

}

}

return result;

}

export function mapObject<T, U>(object: MapLike<T>, f: (key: string, x: T) => [string, U]): MapLike<U> {

let result: MapLike<U>;

if (object) {

result = {};

for (const v of getOwnKeys(object)) {

const [key, value]: [string, U] = f(v, object[v]) || [undefined, undefined];

if (key !== undefined) {

result[key] = value;

}

}

}

return result;

}

export function some<T>(array: T[], predicate?: (value: T) => boolean): boolean {

if (array) {

if (predicate) {

for (const v of array) {

if (predicate(v)) {

return true;

}

}

}

else {

return array.length > 0;

}

}

return false;

}

export function concatenate<T>(array1: T[], array2: T[]): T[] {

if (!some(array2)) return array1;

if (!some(array1)) return array2;

return [...array1, ...array2];

}

// TODO: fixme (N^2) - add optional comparer so collection can be sorted before deduplication.

export function deduplicate<T>(array: T[], areEqual?: (a: T, b: T) => boolean): T[] {

let result: T[];

if (array) {

result = [];

loop: for (const item of array) {

for (const res of result) {

if (areEqual ? areEqual(res, item) : res === item) {

continue loop;

}

}

result.push(item);

}

}

return result;

}

export function arrayIsEqualTo<T>(array1: ReadonlyArray<T>, array2: ReadonlyArray<T>, equaler?: (a: T, b: T) => boolean): boolean {

if (!array1 || !array2) {

return array1 === array2;

}

if (array1.length !== array2.length) {

return false;

}

for (let i = 0; i < array1.length; i++) {

const equals = equaler ? equaler(array1[i], array2[i]) : array1[i] === array2[i];

if (!equals) {

return false;

}

}

return true;

}

export function changesAffectModuleResolution(oldOptions: CompilerOptions, newOptions: CompilerOptions): boolean {

return !oldOptions ||

(oldOptions.module !== newOptions.module) ||

(oldOptions.moduleResolution !== newOptions.moduleResolution) ||

(oldOptions.noResolve !== newOptions.noResolve) ||

(oldOptions.target !== newOptions.target) ||

(oldOptions.noLib !== newOptions.noLib) ||

(oldOptions.jsx !== newOptions.jsx) ||

(oldOptions.allowJs !== newOptions.allowJs) ||

(oldOptions.rootDir !== newOptions.rootDir) ||

(oldOptions.configFilePath !== newOptions.configFilePath) ||

(oldOptions.baseUrl !== newOptions.baseUrl) ||

(oldOptions.maxNodeModuleJsDepth !== newOptions.maxNodeModuleJsDepth) ||

!arrayIsEqualTo(oldOptions.lib, newOptions.lib) ||

!arrayIsEqualTo(oldOptions.typeRoots, newOptions.typeRoots) ||

!arrayIsEqualTo(oldOptions.rootDirs, newOptions.rootDirs) ||

!equalOwnProperties(oldOptions.paths, newOptions.paths);

}

/**

* Compacts an array, removing any falsey elements.

*/

export function compact<T>(array: T[]): T[] {

let result: T[];

if (array) {

for (let i = 0; i < array.length; i++) {

const v = array[i];

if (result || !v) {

if (!result) {

result = array.slice(0, i);

}

if (v) {

result.push(v);

}

}

}

}

return result || array;

}

/**

* Gets the relative complement of `arrayA` with respect to `b`, returning the elements that

* are not present in `arrayA` but are present in `arrayB`. Assumes both arrays are sorted

* based on the provided comparer.

*/

export function relativeComplement<T>(arrayA: T[] | undefined, arrayB: T[] | undefined, comparer: (x: T, y: T) => Comparison = compareValues, offsetA = 0, offsetB = 0): T[] | undefined {

if (!arrayB || !arrayA || arrayB.length === 0 || arrayA.length === 0) return arrayB;

const result: T[] = [];

outer: for (; offsetB < arrayB.length; offsetB++) {

inner: for (; offsetA < arrayA.length; offsetA++) {

switch (comparer(arrayB[offsetB], arrayA[offsetA])) {

case Comparison.LessThan: break inner;

case Comparison.EqualTo: continue outer;

case Comparison.GreaterThan: continue inner;

}

}

result.push(arrayB[offsetB]);

}

return result;

}

export function sum(array: any[], prop: string): number {

let result = 0;

for (const v of array) {

result += v[prop];

}

return result;

}

/**

* Appends a value to an array, returning the array.

*

* @param to The array to which `value` is to be appended. If `to` is `undefined`, a new array

* is created if `value` was appended.

* @param value The value to append to the array. If `value` is `undefined`, nothing is

* appended.

*/

export function append<T>(to: T[] | undefined, value: T | undefined): T[] | undefined {

if (value === undefined) return to;

if (to === undefined) return [value];

to.push(value);

return to;

}

/**

* Appends a range of value to an array, returning the array.

*

* @param to The array to which `value` is to be appended. If `to` is `undefined`, a new array

* is created if `value` was appended.

* @param from The values to append to the array. If `from` is `undefined`, nothing is

* appended. If an element of `from` is `undefined`, that element is not appended.

*/

export function addRange<T>(to: T[] | undefined, from: T[] | undefined): T[] | undefined {

if (from === undefined) return to;

for (const v of from) {

to = append(to, v);

}

return to;

}

/**

* Stable sort of an array. Elements equal to each other maintain their relative position in the array.

*/

export function stableSort<T>(array: T[], comparer: (x: T, y: T) => Comparison = compareValues) {

return array

.map((_, i) => i) // create array of indices

.sort((x, y) => comparer(array[x], array[y]) || compareValues(x, y)) // sort indices by value then position

.map(i => array[i]); // get sorted array

}

export function rangeEquals<T>(array1: T[], array2: T[], pos: number, end: number) {

while (pos < end) {

if (array1[pos] !== array2[pos]) {

return false;

}

pos++;

}

return true;

}

/**

* Returns the first element of an array if non-empty, `undefined` otherwise.

*/

export function firstOrUndefined<T>(array: T[]): T {

return array && array.length > 0

? array[0]

: undefined;

}

/**

* Returns the last element of an array if non-empty, `undefined` otherwise.

*/

export function lastOrUndefined<T>(array: T[]): T {

return array && array.length > 0

? array[array.length - 1]

: undefined;

}

/**

* Returns the only element of an array if it contains only one element, `undefined` otherwise.

*/

export function singleOrUndefined<T>(array: T[]): T {

return array && array.length === 1

? array[0]

: undefined;

}

/**

* Returns the only element of an array if it contains only one element; otheriwse, returns the

* array.

*/

export function singleOrMany<T>(array: T[]): T | T[] {

return array && array.length === 1

? array[0]

: array;

}

export function replaceElement<T>(array: T[], index: number, value: T): T[] {

const result = array.slice(0);

result[index] = value;

return result;

}

/**

* Performs a binary search, finding the index at which 'value' occurs in 'array'.

* If no such index is found, returns the 2's-complement of first index at which

* number[index] exceeds number.

* @param array A sorted array whose first element must be no larger than number

* @param number The value to be searched for in the array.

*/

export function binarySearch<T>(array: T[], value: T, comparer?: (v1: T, v2: T) => number, offset?: number): number {

if (!array || array.length === 0) {

return -1;

}

let low = offset || 0;

let high = array.length - 1;

comparer = comparer !== undefined

? comparer

: (v1, v2) => (v1 < v2 ? -1 : (v1 > v2 ? 1 : 0));

while (low <= high) {

const middle = low + ((high - low) >> 1);

const midValue = array[middle];

if (comparer(midValue, value) === 0) {

return middle;

}

else if (comparer(midValue, value) > 0) {

high = middle - 1;

}

else {

low = middle + 1;

}

}

return ~low;

}

export function reduceLeft<T, U>(array: T[], f: (memo: U, value: T, i: number) => U, initial: U, start?: number, count?: number): U;

export function reduceLeft<T>(array: T[], f: (memo: T, value: T, i: number) => T): T;

export function reduceLeft<T>(array: T[], f: (memo: T, value: T, i: number) => T, initial?: T, start?: number, count?: number): T {

if (array && array.length > 0) {

const size = array.length;

if (size > 0) {

let pos = start === undefined || start < 0 ? 0 : start;

const end = count === undefined || pos + count > size - 1 ? size - 1 : pos + count;

let result: T;

if (arguments.length <= 2) {

result = array[pos];

pos++;

}

else {

result = initial;

}

while (pos <= end) {

result = f(result, array[pos], pos);

pos++;

}

return result;

}

}

return initial;

}

export function reduceRight<T, U>(array: T[], f: (memo: U, value: T, i: number) => U, initial: U, start?: number, count?: number): U;

export function reduceRight<T>(array: T[], f: (memo: T, value: T, i: number) => T): T;

export function reduceRight<T>(array: T[], f: (memo: T, value: T, i: number) => T, initial?: T, start?: number, count?: number): T {

if (array) {

const size = array.length;

if (size > 0) {

let pos = start === undefined || start > size - 1 ? size - 1 : start;

const end = count === undefined || pos - count < 0 ? 0 : pos - count;

let result: T;

if (arguments.length <= 2) {

result = array[pos];

pos--;

}

else {

result = initial;

}

while (pos >= end) {

result = f(result, array[pos], pos);

pos--;

}

return result;

}

}

return initial;

}

const hasOwnProperty = Object.prototype.hasOwnProperty;

/**

* Indicates whether a map-like contains an own property with the specified key.

*

* NOTE: This is intended for use only with MapLike<T> objects. For Map<T> objects, use

* the 'in' operator.

*

* @param map A map-like.

* @param key A property key.

*/

export function hasProperty<T>(map: MapLike<T>, key: string): boolean {

return hasOwnProperty.call(map, key);

}

/**

* Gets the value of an owned property in a map-like.

*

* NOTE: This is intended for use only with MapLike<T> objects. For Map<T> objects, use

* an indexer.

*

* @param map A map-like.

* @param key A property key.

*/

export function getProperty<T>(map: MapLike<T>, key: string): T | undefined {

return hasOwnProperty.call(map, key) ? map[key] : undefined;

}

/**

* Gets the owned, enumerable property keys of a map-like.

*

* NOTE: This is intended for use with MapLike<T> objects. For Map<T> objects, use

* Object.keys instead as it offers better performance.

*

* @param map A map-like.

*/

export function getOwnKeys<T>(map: MapLike<T>): string[] {

const keys: string[] = [];

for (const key in map) if (hasOwnProperty.call(map, key)) {

keys.push(key);

}

return keys;

}

/**

* Enumerates the properties of a Map<T>, invoking a callback and returning the first truthy result.

*

* @param map A map for which properties should be enumerated.

* @param callback A callback to invoke for each property.

*/

export function forEachProperty<T, U>(map: Map<T>, callback: (value: T, key: string) => U): U {

let result: U;

for (const key in map) {

if (result = callback(map[key], key)) break;

}

return result;

}

/**

* Returns true if a Map<T> has some matching property.

*

* @param map A map whose properties should be tested.

* @param predicate An optional callback used to test each property.

*/

export function someProperties<T>(map: Map<T>, predicate?: (value: T, key: string) => boolean) {

for (const key in map) {

if (!predicate || predicate(map[key], key)) return true;

}

return false;

}

/**

* Performs a shallow copy of the properties from a source Map<T> to a target MapLike<T>

*

* @param source A map from which properties should be copied.

* @param target A map to which properties should be copied.

*/

export function copyProperties<T>(source: Map<T>, target: MapLike<T>): void {

for (const key in source) {

target[key] = source[key];

}

}

export function appendProperty<T>(map: Map<T>, key: string | number, value: T): Map<T> {

if (key === undefined || value === undefined) return map;

if (map === undefined) map = createMap<T>();

map[key] = value;

return map;

}

export function assign<T1 extends MapLike<{}>, T2, T3>(t: T1, arg1: T2, arg2: T3): T1 & T2 & T3;

export function assign<T1 extends MapLike<{}>, T2>(t: T1, arg1: T2): T1 & T2;

export function assign<T1 extends MapLike<{}>>(t: T1, ...args: any[]): any;

export function assign<T1 extends MapLike<{}>>(t: T1, ...args: any[]) {

for (const arg of args) {

for (const p of getOwnKeys(arg)) {

t[p] = arg[p];

}

}

return t;

}

/**

* Reduce the properties of a map.

*

* NOTE: This is intended for use with Map<T> objects. For MapLike<T> objects, use

* reduceOwnProperties instead as it offers better runtime safety.

*

* @param map The map to reduce

* @param callback An aggregation function that is called for each entry in the map

* @param initial The initial value for the reduction.

*/

export function reduceProperties<T, U>(map: Map<T>, callback: (aggregate: U, value: T, key: string) => U, initial: U): U {

let result = initial;

for (const key in map) {

result = callback(result, map[key], String(key));

}

return result;

}

/**

* Reduce the properties defined on a map-like (but not from its prototype chain).

*

* NOTE: This is intended for use with MapLike<T> objects. For Map<T> objects, use

* reduceProperties instead as it offers better performance.

*

* @param map The map-like to reduce

* @param callback An aggregation function that is called for each entry in the map

* @param initial The initial value for the reduction.

*/

export function reduceOwnProperties<T, U>(map: MapLike<T>, callback: (aggregate: U, value: T, key: string) => U, initial: U): U {

let result = initial;

for (const key in map) if (hasOwnProperty.call(map, key)) {

result = callback(result, map[key], String(key));

}

return result;

}

/**

* Performs a shallow equality comparison of the contents of two map-likes.

*

* @param left A map-like whose properties should be compared.

* @param right A map-like whose properties should be compared.

*/

export function equalOwnProperties<T>(left: MapLike<T>, right: MapLike<T>, equalityComparer?: (left: T, right: T) => boolean) {

if (left === right) return true;

if (!left || !right) return false;

for (const key in left) if (hasOwnProperty.call(left, key)) {

if (!hasOwnProperty.call(right, key) === undefined) return false;

if (equalityComparer ? !equalityComparer(left[key], right[key]) : left[key] !== right[key]) return false;

}

for (const key in right) if (hasOwnProperty.call(right, key)) {

if (!hasOwnProperty.call(left, key)) return false;

}

return true;

}

/**

* Creates a map from the elements of an array.

*

* @param array the array of input elements.

* @param makeKey a function that produces a key for a given element.

*

* This function makes no effort to avoid collisions; if any two elements produce

* the same key with the given 'makeKey' function, then the element with the higher

* index in the array will be the one associated with the produced key.

*/

export function arrayToMap<T>(array: T[], makeKey: (value: T) => string): Map<T>;

export function arrayToMap<T, U>(array: T[], makeKey: (value: T) => string, makeValue: (value: T) => U): Map<U>;

export function arrayToMap<T, U>(array: T[], makeKey: (value: T) => string, makeValue?: (value: T) => U): Map<T | U> {

const result = createMap<T | U>();

for (const value of array) {

result[makeKey(value)] = makeValue ? makeValue(value) : value;

}

return result;

}

export function isEmpty<T>(map: Map<T>) {

for (const id in map) {

if (hasProperty(map, id)) {

return false;

}

}

return true;

}

export function cloneMap<T>(map: Map<T>) {

const clone = createMap<T>();

copyProperties(map, clone);

return clone;

}

export function clone<T>(object: T): T {

const result: any = {};

for (const id in object) {

if (hasOwnProperty.call(object, id)) {

result[id] = (<any>object)[id];

}

}

return result;

}

export function extend<T1, T2>(first: T1, second: T2): T1 & T2 {

const result: T1 & T2 = <any>{};

for (const id in second) if (hasOwnProperty.call(second, id)) {

(result as any)[id] = (second as any)[id];

}

for (const id in first) if (hasOwnProperty.call(first, id)) {

(result as any)[id] = (first as any)[id];

}

return result;

}

/**

* Adds the value to an array of values associated with the key, and returns the array.

* Creates the array if it does not already exist.

*/

export function multiMapAdd<V>(map: Map<V[]>, key: string | number, value: V): V[] {

const values = map[key];

if (values) {

values.push(value);

return values;

}

else {

return map[key] = [value];

}

}

/**

* Removes a value from an array of values associated with the key.

* Does not preserve the order of those values.

* Does nothing if `key` is not in `map`, or `value` is not in `map[key]`.

*/

export function multiMapRemove<V>(map: Map<V[]>, key: string, value: V): void {

const values = map[key];

if (values) {

unorderedRemoveItem(values, value);

if (!values.length) {

delete map[key];

}

}

}

/**

* Tests whether a value is an array.

*/

export function isArray(value: any): value is any[] {

return Array.isArray ? Array.isArray(value) : value instanceof Array;

}

/** Does nothing. */

export function noop(): void {}

/** Throws an error because a function is not implemented. */

export function notImplemented(): never {