Bump eslint from 7.13.0 to 7.14.0

[rails.git] / vendor / assets / polyfill / es6.js

/* Polyfill service v3.38.0
 * For detailed credits and licence information see https://github.com/financial-times/polyfill-service.
 * 
 * Features requested: es6
 * 
 * - _ESAbstract.ArrayCreate, License: CC0 (required by "Array.from", "es6", "Array.of", "_ESAbstract.ArraySpeciesCreate", "Array.prototype.filter", "Symbol", "Map", "Set", "Symbol.hasInstance", "Symbol.isConcatSpreadable", "Symbol.iterator", "Array.prototype.@@iterator", "String.prototype.@@iterator", "Symbol.match", "Symbol.replace", "Symbol.search", "Symbol.species", "Symbol.split", "Symbol.toPrimitive", "Symbol.toStringTag", "Symbol.unscopables", "Array.prototype.map")
 * - _ESAbstract.Call, License: CC0 (required by "Array.from", "es6", "Array.prototype.find", "Array.prototype.findIndex", "WeakMap", "WeakSet", "_ESAbstract.GetIterator", "Map", "Set", "_ESAbstract.IteratorClose", "_ESAbstract.IteratorNext", "_ESAbstract.IteratorStep", "Array.prototype.forEach", "Object.setPrototypeOf", "Symbol", "Symbol.hasInstance", "Symbol.isConcatSpreadable", "Symbol.iterator", "Array.prototype.@@iterator", "String.prototype.@@iterator", "Symbol.match", "Symbol.replace", "Symbol.search", "Symbol.species", "Symbol.split", "Symbol.toPrimitive", "Symbol.toStringTag", "Symbol.unscopables", "Array.prototype.filter", "Array.prototype.map", "_ESAbstract.ToPrimitive", "_ESAbstract.ToString", "Array.of", "Array.prototype.fill", "String.prototype.codePointAt", "String.prototype.endsWith", "String.prototype.includes", "String.prototype.repeat", "String.prototype.startsWith", "_ESAbstract.OrdinaryToPrimitive")
 * - _ESAbstract.Get, License: CC0 (required by "Array.from", "es6", "Array.prototype.fill", "Array.prototype.find", "Array.prototype.findIndex", "Object.assign", "RegExp.prototype.flags", "WeakMap", "WeakSet", "_ESAbstract.IteratorValue", "Map", "Set", "_ESAbstract.IteratorComplete", "_ESAbstract.IteratorStep", "Array.prototype.forEach", "Object.setPrototypeOf", "Symbol", "Symbol.hasInstance", "Symbol.isConcatSpreadable", "Symbol.iterator", "Array.prototype.@@iterator", "String.prototype.@@iterator", "Symbol.match", "Symbol.replace", "Symbol.search", "Symbol.species", "Symbol.split", "Symbol.toPrimitive", "Symbol.toStringTag", "Symbol.unscopables", "_ESAbstract.IsRegExp", "String.prototype.endsWith", "String.prototype.includes", "String.prototype.startsWith", "Array.prototype.filter", "Array.prototype.map", "_ESAbstract.GetPrototypeFromConstructor", "_ESAbstract.OrdinaryCreateFromConstructor", "_ESAbstract.Construct", "Array.of", "Object.defineProperties", "Object.create", "_ESAbstract.GetIterator", "_ArrayIterator", "Array.prototype.entries", "Array.prototype.keys", "Array.prototype.values", "_Iterator", "_StringIterator", "_ESAbstract.ArraySpeciesCreate", "_ESAbstract.OrdinaryToPrimitive", "_ESAbstract.ToPrimitive", "_ESAbstract.ToString", "String.prototype.codePointAt", "String.prototype.repeat")
 * - _ESAbstract.HasProperty, License: CC0 (required by "Array.prototype.copyWithin", "es6", "Array.prototype.forEach", "Object.setPrototypeOf", "Symbol", "Map", "Array.from", "Set", "Symbol.hasInstance", "Symbol.isConcatSpreadable", "Symbol.iterator", "Array.prototype.@@iterator", "String.prototype.@@iterator", "Symbol.match", "Symbol.replace", "Symbol.search", "Symbol.species", "Symbol.split", "Symbol.toPrimitive", "Symbol.toStringTag", "Symbol.unscopables", "Array.prototype.filter", "Array.prototype.map")
 * - _ESAbstract.IsArray, License: CC0 (required by "String.fromCodePoint", "es6", "WeakMap", "WeakSet", "Array.isArray", "Map", "Array.from", "Set", "_ESAbstract.ArraySpeciesCreate", "Array.prototype.filter", "Symbol", "Symbol.hasInstance", "Symbol.isConcatSpreadable", "Symbol.iterator", "Array.prototype.@@iterator", "String.prototype.@@iterator", "Symbol.match", "Symbol.replace", "Symbol.search", "Symbol.species", "Symbol.split", "Symbol.toPrimitive", "Symbol.toStringTag", "Symbol.unscopables", "Array.prototype.map")
 * - _ESAbstract.IsCallable, License: CC0 (required by "Array.from", "es6", "Array.prototype.find", "Array.prototype.findIndex", "Map", "Set", "WeakMap", "WeakSet", "_ESAbstract.GetMethod", "Array.prototype.forEach", "Object.setPrototypeOf", "Symbol", "Symbol.hasInstance", "Symbol.isConcatSpreadable", "Symbol.iterator", "Array.prototype.@@iterator", "String.prototype.@@iterator", "Symbol.match", "Symbol.replace", "Symbol.search", "Symbol.species", "Symbol.split", "Symbol.toPrimitive", "Symbol.toStringTag", "Symbol.unscopables", "Array.prototype.filter", "Array.prototype.map", "Function.prototype.bind", "_ESAbstract.Construct", "Array.of", "Object.getOwnPropertyDescriptor", "Object.assign", "_ESAbstract.OrdinaryToPrimitive", "_ESAbstract.ToPrimitive", "_ESAbstract.ToString", "Array.prototype.fill", "String.prototype.codePointAt", "String.prototype.endsWith", "String.prototype.includes", "String.prototype.repeat", "String.prototype.startsWith")
 * - _ESAbstract.RequireObjectCoercible, License: CC0 (required by "String.prototype.@@iterator", "es6", "String.prototype.codePointAt", "String.prototype.endsWith", "String.prototype.includes", "String.prototype.repeat", "String.prototype.startsWith")
 * - _ESAbstract.SameValueNonNumber, License: CC0 (required by "_ESAbstract.SameValueZero", "Map", "es6", "Array.from", "Set", "WeakSet", "_ESAbstract.SameValue", "Object.is", "String.fromCodePoint", "WeakMap")
 * - _ESAbstract.ToBoolean, License: CC0 (required by "Array.prototype.find", "es6", "Array.prototype.findIndex", "RegExp.prototype.flags", "_ESAbstract.IteratorComplete", "Map", "Array.from", "Set", "_ESAbstract.IteratorStep", "WeakMap", "WeakSet", "_ESAbstract.IsRegExp", "String.prototype.endsWith", "String.prototype.includes", "String.prototype.startsWith", "Array.prototype.filter", "Symbol", "Symbol.hasInstance", "Symbol.isConcatSpreadable", "Symbol.iterator", "Array.prototype.@@iterator", "String.prototype.@@iterator", "Symbol.match", "Symbol.replace", "Symbol.search", "Symbol.species", "Symbol.split", "Symbol.toPrimitive", "Symbol.toStringTag", "Symbol.unscopables")
 * - _ESAbstract.ToInteger, License: CC0 (required by "Array.prototype.copyWithin", "es6", "Array.prototype.fill", "Number.isInteger", "Number.isSafeInteger", "String.fromCodePoint", "String.prototype.codePointAt", "String.prototype.endsWith", "String.prototype.includes", "String.prototype.repeat", "String.prototype.startsWith", "_ESAbstract.ToLength", "Array.from", "Array.prototype.find", "Array.prototype.findIndex")
 * - _ESAbstract.ToLength, License: CC0 (required by "Array.from", "es6", "Array.prototype.fill", "Array.prototype.find", "Array.prototype.findIndex", "Array.prototype.forEach", "Object.setPrototypeOf", "Symbol", "Map", "Set", "Symbol.hasInstance", "Symbol.isConcatSpreadable", "Symbol.iterator", "Array.prototype.@@iterator", "String.prototype.@@iterator", "Symbol.match", "Symbol.replace", "Symbol.search", "Symbol.species", "Symbol.split", "Symbol.toPrimitive", "Symbol.toStringTag", "Symbol.unscopables", "Array.prototype.filter", "Array.prototype.map")
 * - _ESAbstract.ToNumber, License: CC0 (required by "String.fromCodePoint", "es6")
 * - _ESAbstract.ToObject, License: CC0 (required by "Array.from", "es6", "Array.prototype.entries", "Array.prototype.fill", "Array.prototype.find", "Array.prototype.findIndex", "Array.prototype.keys", "Array.prototype.values", "Array.prototype.@@iterator", "Object.assign", "Array.prototype.forEach", "Object.setPrototypeOf", "Symbol", "Map", "Set", "Symbol.hasInstance", "Symbol.isConcatSpreadable", "Symbol.iterator", "String.prototype.@@iterator", "Symbol.match", "Symbol.replace", "Symbol.search", "Symbol.species", "Symbol.split", "Symbol.toPrimitive", "Symbol.toStringTag", "Symbol.unscopables", "Array.prototype.filter", "Array.prototype.map", "_ESAbstract.GetV", "_ESAbstract.GetMethod", "_ESAbstract.GetIterator", "WeakMap", "WeakSet", "Object.defineProperties", "Object.create", "_ArrayIterator", "_ESAbstract.OrdinaryCreateFromConstructor", "_ESAbstract.Construct", "Array.of", "_Iterator", "_StringIterator")
 * - _ESAbstract.GetV, License: CC0 (required by "_ESAbstract.GetMethod", "Array.from", "es6", "Map", "Set", "_ESAbstract.GetIterator", "WeakMap", "WeakSet")
 * - _ESAbstract.GetMethod, License: CC0 (required by "Array.from", "es6", "Map", "Set", "_ESAbstract.IsConstructor", "Array.of", "_ESAbstract.GetIterator", "WeakMap", "WeakSet", "_ESAbstract.IteratorClose", "_ESAbstract.ToPrimitive", "_ESAbstract.ToString", "Array.prototype.fill", "Array.prototype.find", "Array.prototype.findIndex", "String.prototype.@@iterator", "String.prototype.codePointAt", "String.prototype.endsWith", "String.prototype.includes", "String.prototype.repeat", "String.prototype.startsWith")
 * - _ESAbstract.ToUint32, License: CC0 (required by "Math.clz32", "es6", "Math.imul")
 * - _ESAbstract.Type, License: CC0 (required by "Map", "es6", "Array.from", "Number.isFinite", "Number.isInteger", "Number.isNaN", "Number.isSafeInteger", "Object.seal", "RegExp.prototype.flags", "WeakMap", "WeakSet", "_ESAbstract.IsConstructor", "Array.of", "_ESAbstract.GetIterator", "Set", "_ESAbstract.IteratorClose", "_ESAbstract.ToString", "Array.prototype.fill", "Array.prototype.find", "Array.prototype.findIndex", "String.prototype.@@iterator", "String.prototype.codePointAt", "String.prototype.endsWith", "String.prototype.includes", "String.prototype.repeat", "String.prototype.startsWith", "_ESAbstract.IteratorValue", "_ESAbstract.CreateIterResultObject", "_ESAbstract.IteratorComplete", "_ESAbstract.IteratorStep", "_ESAbstract.IteratorNext", "_ESAbstract.SameValueZero", "Object.create", "Object.setPrototypeOf", "Symbol", "Symbol.hasInstance", "Symbol.isConcatSpreadable", "Symbol.iterator", "Array.prototype.@@iterator", "Symbol.match", "Symbol.replace", "Symbol.search", "Symbol.species", "Symbol.split", "Symbol.toPrimitive", "Symbol.toStringTag", "Symbol.unscopables", "_ArrayIterator", "Array.prototype.entries", "Array.prototype.keys", "Array.prototype.values", "_ESAbstract.OrdinaryCreateFromConstructor", "_ESAbstract.Construct", "_ESAbstract.SameValue", "Object.is", "String.fromCodePoint", "_ESAbstract.IsRegExp", "_ESAbstract.ToPrimitive", "_ESAbstract.GetPrototypeFromConstructor", "Object.defineProperties", "_Iterator", "_StringIterator", "_ESAbstract.ArraySpeciesCreate", "Array.prototype.filter", "Array.prototype.map", "_ESAbstract.OrdinaryToPrimitive")
 * - _ESAbstract.GetPrototypeFromConstructor, License: CC0 (required by "_ESAbstract.OrdinaryCreateFromConstructor", "Map", "es6", "Array.from", "Set", "WeakMap", "WeakSet", "_ESAbstract.Construct", "Array.of")
 * - _ESAbstract.IsConstructor, License: CC0 (required by "Array.from", "es6", "Array.of", "_ESAbstract.Construct", "_ESAbstract.ArraySpeciesCreate", "Array.prototype.filter", "Symbol", "Map", "Set", "Symbol.hasInstance", "Symbol.isConcatSpreadable", "Symbol.iterator", "Array.prototype.@@iterator", "String.prototype.@@iterator", "Symbol.match", "Symbol.replace", "Symbol.search", "Symbol.species", "Symbol.split", "Symbol.toPrimitive", "Symbol.toStringTag", "Symbol.unscopables", "Array.prototype.map")
 * - _ESAbstract.IsRegExp, License: CC0 (required by "String.prototype.endsWith", "es6", "String.prototype.includes", "String.prototype.startsWith")
 * - _ESAbstract.IteratorClose, License: CC0 (required by "Array.from", "es6", "Map", "Set", "WeakMap", "WeakSet")
 * - _ESAbstract.IteratorComplete, License: CC0 (required by "Map", "es6", "Array.from", "Set", "_ESAbstract.IteratorStep", "WeakMap", "WeakSet")
 * - _ESAbstract.IteratorNext, License: CC0 (required by "Map", "es6", "Array.from", "Set", "_ESAbstract.IteratorStep", "WeakMap", "WeakSet")
 * - _ESAbstract.IteratorStep, License: CC0 (required by "Array.from", "es6", "Map", "Set", "WeakMap", "WeakSet")
 * - _ESAbstract.IteratorValue, License: CC0 (required by "Array.from", "es6", "Map", "Set", "WeakMap", "WeakSet")
 * - _ESAbstract.OrdinaryToPrimitive, License: CC0 (required by "_ESAbstract.ToPrimitive", "_ESAbstract.ToString", "Array.from", "es6", "Array.of", "Array.prototype.fill", "Array.prototype.find", "Array.prototype.findIndex", "String.prototype.@@iterator", "String.prototype.codePointAt", "String.prototype.endsWith", "String.prototype.includes", "String.prototype.repeat", "String.prototype.startsWith")
 * - _ESAbstract.SameValue, License: CC0 (required by "Object.is", "es6", "String.fromCodePoint", "WeakMap")
 * - _ESAbstract.SameValueZero, License: CC0 (required by "Map", "es6", "Array.from", "Set", "WeakSet")
 * - _ESAbstract.ToPrimitive, License: CC0 (required by "_ESAbstract.ToString", "Array.from", "es6", "Array.of", "Array.prototype.fill", "Array.prototype.find", "Array.prototype.findIndex", "String.prototype.@@iterator", "String.prototype.codePointAt", "String.prototype.endsWith", "String.prototype.includes", "String.prototype.repeat", "String.prototype.startsWith")
 * - _ESAbstract.ToString, License: CC0 (required by "Array.from", "es6", "Array.of", "Array.prototype.fill", "Array.prototype.find", "Array.prototype.findIndex", "String.prototype.@@iterator", "String.prototype.codePointAt", "String.prototype.endsWith", "String.prototype.includes", "String.prototype.repeat", "String.prototype.startsWith", "Array.prototype.forEach", "Object.setPrototypeOf", "Symbol", "Map", "Set", "Symbol.hasInstance", "Symbol.isConcatSpreadable", "Symbol.iterator", "Array.prototype.@@iterator", "Symbol.match", "Symbol.replace", "Symbol.search", "Symbol.species", "Symbol.split", "Symbol.toPrimitive", "Symbol.toStringTag", "Symbol.unscopables", "Array.prototype.filter", "Array.prototype.map")
 * - _ESAbstract.UTF16Decode, License: CC0 (required by "String.prototype.codePointAt", "es6")
 * - _ESAbstract.UTF16Encoding, License: CC0 (required by "String.fromCodePoint", "es6")
 * - _TypedArray, License: MIT (required by "Math.fround", "es6")
 * - Object.defineProperty, License: CC0 (required by "Function.prototype.name", "es6", "Map", "Array.from", "Number.Epsilon", "Number.MAX_SAFE_INTEGER", "Number.MIN_SAFE_INTEGER", "Object.setPrototypeOf", "RegExp.prototype.flags", "Set", "Symbol.hasInstance", "Symbol.isConcatSpreadable", "Symbol.iterator", "Array.prototype.@@iterator", "String.prototype.@@iterator", "Symbol.match", "Symbol.replace", "Symbol.search", "Symbol.species", "Symbol.split", "Symbol.toPrimitive", "Symbol.toStringTag", "Symbol.unscopables", "Symbol", "WeakMap", "WeakSet", "_ESAbstract.CreateMethodProperty", "Array.of", "Array.prototype.copyWithin", "Array.prototype.entries", "Array.prototype.fill", "Array.prototype.find", "Array.prototype.findIndex", "Array.prototype.keys", "Array.prototype.values", "Math.acosh", "Math.asinh", "Math.atanh", "Math.cbrt", "Math.clz32", "Math.cosh", "Math.expm1", "Math.fround", "Math.hypot", "Math.imul", "Math.log10", "Math.log1p", "Math.log2", "Math.sign", "Math.sinh", "Math.tanh", "Math.trunc", "Number.isFinite", "Number.isInteger", "Number.isNaN", "Number.isSafeInteger", "Number.parseFloat", "Number.parseInt", "Object.assign", "Object.is", "Object.seal", "String.fromCodePoint", "String.prototype.codePointAt", "String.prototype.endsWith", "String.prototype.includes", "String.prototype.repeat", "String.prototype.startsWith", "_ArrayIterator", "_ESAbstract.OrdinaryCreateFromConstructor", "_ESAbstract.Construct", "_StringIterator", "_ESAbstract.CreateDataProperty", "_ESAbstract.CreateDataPropertyOrThrow", "_ESAbstract.CreateIterResultObject", "_Iterator", "Object.defineProperties", "Object.create", "_ESAbstract.GetIterator")
 * - _ESAbstract.CreateDataProperty, License: CC0 (required by "_ESAbstract.CreateDataPropertyOrThrow", "Array.from", "es6", "Array.of", "_ESAbstract.CreateIterResultObject", "Map", "Set")
 * - _ESAbstract.CreateDataPropertyOrThrow, License: CC0 (required by "Array.from", "es6", "Array.of", "Array.prototype.filter", "Symbol", "Map", "Set", "Symbol.hasInstance", "Symbol.isConcatSpreadable", "Symbol.iterator", "Array.prototype.@@iterator", "String.prototype.@@iterator", "Symbol.match", "Symbol.replace", "Symbol.search", "Symbol.species", "Symbol.split", "Symbol.toPrimitive", "Symbol.toStringTag", "Symbol.unscopables", "Array.prototype.map")
 * - _ESAbstract.CreateIterResultObject, License: CC0 (required by "Map", "es6", "Array.from", "Set")
 * - _ESAbstract.CreateMethodProperty, License: CC0 (required by "Array.from", "es6", "Array.of", "Array.prototype.@@iterator", "Array.prototype.copyWithin", "Array.prototype.entries", "Array.prototype.fill", "Array.prototype.find", "Array.prototype.findIndex", "Array.prototype.keys", "Array.prototype.values", "Map", "Math.acosh", "Math.asinh", "Math.atanh", "Math.cbrt", "Math.clz32", "Math.cosh", "Math.expm1", "Math.fround", "Math.hypot", "Math.imul", "Math.log10", "Math.log1p", "Math.log2", "Math.sign", "Math.sinh", "Math.tanh", "Math.trunc", "Number.isFinite", "Number.isInteger", "Number.isNaN", "Number.isSafeInteger", "Number.parseFloat", "Number.parseInt", "Object.assign", "Object.is", "Object.seal", "Object.setPrototypeOf", "Set", "String.fromCodePoint", "String.prototype.@@iterator", "String.prototype.codePointAt", "String.prototype.endsWith", "String.prototype.includes", "String.prototype.repeat", "String.prototype.startsWith", "WeakMap", "WeakSet", "Array.isArray", "Object.create", "Symbol", "Symbol.hasInstance", "Symbol.isConcatSpreadable", "Symbol.iterator", "Symbol.match", "Symbol.replace", "Symbol.search", "Symbol.species", "Symbol.split", "Symbol.toPrimitive", "Symbol.toStringTag", "Symbol.unscopables", "_ESAbstract.GetIterator", "_ArrayIterator", "_ESAbstract.OrdinaryCreateFromConstructor", "_ESAbstract.Construct", "Object.getOwnPropertyDescriptor", "Object.keys", "Array.prototype.forEach", "Object.getPrototypeOf", "Object.getOwnPropertyNames", "Array.prototype.filter", "Array.prototype.map", "Object.freeze", "Function.prototype.bind", "Object.defineProperties", "_Iterator", "_StringIterator")
 * - Array.isArray, License: CC0 (required by "Map", "es6", "Array.from", "Set", "WeakMap")
 * - Array.prototype.copyWithin, License: MIT (required by "es6")
 * - Array.prototype.fill, License: CC0 (required by "es6")
 * - Array.prototype.find, License: CC0 (required by "es6")
 * - Array.prototype.findIndex, License: CC0 (required by "es6")
 * - Array.prototype.forEach, License: CC0 (required by "Object.setPrototypeOf", "es6", "Symbol", "Map", "Array.from", "Set", "Symbol.hasInstance", "Symbol.isConcatSpreadable", "Symbol.iterator", "Array.prototype.@@iterator", "String.prototype.@@iterator", "Symbol.match", "Symbol.replace", "Symbol.search", "Symbol.species", "Symbol.split", "Symbol.toPrimitive", "Symbol.toStringTag", "Symbol.unscopables")
 * - Function.prototype.bind, License: MIT (required by "_ESAbstract.Construct", "Array.from", "es6", "Array.of", "Object.getOwnPropertyDescriptor", "Object.assign", "Object.setPrototypeOf", "Symbol", "Map", "Set", "Symbol.hasInstance", "Symbol.isConcatSpreadable", "Symbol.iterator", "Array.prototype.@@iterator", "String.prototype.@@iterator", "Symbol.match", "Symbol.replace", "Symbol.search", "Symbol.species", "Symbol.split", "Symbol.toPrimitive", "Symbol.toStringTag", "Symbol.unscopables", "_Iterator", "_ArrayIterator", "Array.prototype.entries", "Array.prototype.keys", "Array.prototype.values", "_StringIterator")
 * - Math.acosh, License: CC0 (required by "es6")
 * - Math.asinh, License: CC0 (required by "es6")
 * - Math.atanh, License: CC0 (required by "es6")
 * - Math.cbrt, License: CC0 (required by "es6")
 * - Math.clz32, License: CC0 (required by "es6")
 * - Math.cosh, License: CC0 (required by "es6")
 * - Math.expm1, License: CC0 (required by "es6")
 * - Math.fround, License: CC0 (required by "es6")
 * - Math.hypot, License: CC0 (required by "es6")
 * - Math.imul, License: CC0 (required by "es6")
 * - Math.log10, License: CC0 (required by "es6")
 * - Math.log1p, License: CC0 (required by "es6")
 * - Math.log2, License: CC0 (required by "es6")
 * - Math.sign, License: CC0 (required by "es6")
 * - Math.sinh, License: CC0 (required by "es6")
 * - Math.tanh, License: CC0 (required by "es6")
 * - Math.trunc, License: CC0 (required by "es6")
 * - Number.isFinite, License: MIT (required by "es6")
 * - Number.isInteger, License: MIT (required by "es6")
 * - Number.isNaN, License: MIT (required by "es6")
 * - Number.isSafeInteger, License: MIT (required by "es6")
 * - Number.parseFloat, License: MIT (required by "es6")
 * - Number.parseInt, License: MIT (required by "es6")
 * - Function.prototype.name, License: MIT (required by "es6")
 * - Number.Epsilon, License: MIT (required by "es6")
 * - Number.MAX_SAFE_INTEGER, License: MIT (required by "es6")
 * - Number.MIN_SAFE_INTEGER, License: MIT (required by "es6")
 * - Object.freeze, License: CC0 (required by "Symbol", "es6", "Map", "Array.from", "Set", "Symbol.hasInstance", "Symbol.isConcatSpreadable", "Symbol.iterator", "Array.prototype.@@iterator", "String.prototype.@@iterator", "Symbol.match", "Symbol.replace", "Symbol.search", "Symbol.species", "Symbol.split", "Symbol.toPrimitive", "Symbol.toStringTag", "Symbol.unscopables")
 * - Object.getOwnPropertyDescriptor, License: CC0 (required by "Object.assign", "es6", "Object.setPrototypeOf", "Symbol", "Map", "Array.from", "Set", "Symbol.hasInstance", "Symbol.isConcatSpreadable", "Symbol.iterator", "Array.prototype.@@iterator", "String.prototype.@@iterator", "Symbol.match", "Symbol.replace", "Symbol.search", "Symbol.species", "Symbol.split", "Symbol.toPrimitive", "Symbol.toStringTag", "Symbol.unscopables", "Object.defineProperties", "Object.create", "_ESAbstract.GetIterator", "WeakMap", "WeakSet", "_ArrayIterator", "Array.prototype.entries", "Array.prototype.keys", "Array.prototype.values", "_ESAbstract.OrdinaryCreateFromConstructor", "_ESAbstract.Construct", "Array.of", "_Iterator", "_StringIterator")
 * - Object.getOwnPropertyNames, License: CC0 (required by "Object.setPrototypeOf", "es6", "Symbol", "Map", "Array.from", "Set", "Symbol.hasInstance", "Symbol.isConcatSpreadable", "Symbol.iterator", "Array.prototype.@@iterator", "String.prototype.@@iterator", "Symbol.match", "Symbol.replace", "Symbol.search", "Symbol.species", "Symbol.split", "Symbol.toPrimitive", "Symbol.toStringTag", "Symbol.unscopables")
 * - Object.getPrototypeOf, License: CC0 (required by "Object.setPrototypeOf", "es6", "_ESAbstract.OrdinaryCreateFromConstructor", "Map", "Array.from", "Set", "WeakMap", "WeakSet", "_ESAbstract.Construct", "Array.of")
 * - Object.is, License: CC0 (required by "es6")
 * - Object.keys, License: MIT (required by "Object.assign", "es6", "Symbol", "Map", "Array.from", "Set", "Symbol.hasInstance", "Symbol.isConcatSpreadable", "Symbol.iterator", "Array.prototype.@@iterator", "String.prototype.@@iterator", "Symbol.match", "Symbol.replace", "Symbol.search", "Symbol.species", "Symbol.split", "Symbol.toPrimitive", "Symbol.toStringTag", "Symbol.unscopables", "Object.defineProperties", "Object.create", "Object.setPrototypeOf", "_ESAbstract.GetIterator", "WeakMap", "WeakSet", "_ArrayIterator", "Array.prototype.entries", "Array.prototype.keys", "Array.prototype.values", "_ESAbstract.OrdinaryCreateFromConstructor", "_ESAbstract.Construct", "Array.of", "_Iterator", "_StringIterator")
 * - Object.assign, License: CC0 (required by "es6", "_Iterator", "_ArrayIterator", "Array.prototype.entries", "Array.prototype.keys", "Array.prototype.values", "Array.prototype.@@iterator", "_StringIterator", "String.prototype.@@iterator")
 * - Object.defineProperties, License: CC0 (required by "Object.create", "Map", "es6", "Array.from", "Object.setPrototypeOf", "Set", "Symbol", "Symbol.hasInstance", "Symbol.isConcatSpreadable", "Symbol.iterator", "Array.prototype.@@iterator", "String.prototype.@@iterator", "Symbol.match", "Symbol.replace", "Symbol.search", "Symbol.species", "Symbol.split", "Symbol.toPrimitive", "Symbol.toStringTag", "Symbol.unscopables", "_ESAbstract.GetIterator", "WeakMap", "WeakSet", "_ArrayIterator", "Array.prototype.entries", "Array.prototype.keys", "Array.prototype.values", "_ESAbstract.OrdinaryCreateFromConstructor", "_ESAbstract.Construct", "Array.of", "_Iterator", "_StringIterator")
 * - Object.create, License: CC0 (required by "Map", "es6", "Array.from", "Object.setPrototypeOf", "Set", "Symbol", "Symbol.hasInstance", "Symbol.isConcatSpreadable", "Symbol.iterator", "Array.prototype.@@iterator", "String.prototype.@@iterator", "Symbol.match", "Symbol.replace", "Symbol.search", "Symbol.species", "Symbol.split", "Symbol.toPrimitive", "Symbol.toStringTag", "Symbol.unscopables", "_ESAbstract.GetIterator", "WeakMap", "WeakSet", "_ArrayIterator", "Array.prototype.entries", "Array.prototype.keys", "Array.prototype.values", "_ESAbstract.OrdinaryCreateFromConstructor", "_ESAbstract.Construct", "Array.of", "_StringIterator")
 * - _ESAbstract.OrdinaryCreateFromConstructor, License: CC0 (required by "Map", "es6", "Array.from", "Set", "WeakMap", "WeakSet", "_ESAbstract.Construct", "Array.of")
 * - _ESAbstract.Construct, License: CC0 (required by "Array.from", "es6", "Array.of", "_ESAbstract.ArraySpeciesCreate", "Array.prototype.filter", "Symbol", "Map", "Set", "Symbol.hasInstance", "Symbol.isConcatSpreadable", "Symbol.iterator", "Array.prototype.@@iterator", "String.prototype.@@iterator", "Symbol.match", "Symbol.replace", "Symbol.search", "Symbol.species", "Symbol.split", "Symbol.toPrimitive", "Symbol.toStringTag", "Symbol.unscopables", "Array.prototype.map")
 * - _ESAbstract.ArraySpeciesCreate, License: CC0 (required by "Array.prototype.filter", "Symbol", "es6", "Map", "Array.from", "Set", "Symbol.hasInstance", "Symbol.isConcatSpreadable", "Symbol.iterator", "Array.prototype.@@iterator", "String.prototype.@@iterator", "Symbol.match", "Symbol.replace", "Symbol.search", "Symbol.species", "Symbol.split", "Symbol.toPrimitive", "Symbol.toStringTag", "Symbol.unscopables", "Array.prototype.map")
 * - Array.prototype.filter, License: CC0 (required by "Symbol", "es6", "Map", "Array.from", "Set", "Symbol.hasInstance", "Symbol.isConcatSpreadable", "Symbol.iterator", "Array.prototype.@@iterator", "String.prototype.@@iterator", "Symbol.match", "Symbol.replace", "Symbol.search", "Symbol.species", "Symbol.split", "Symbol.toPrimitive", "Symbol.toStringTag", "Symbol.unscopables")
 * - Array.prototype.map, License: CC0 (required by "Symbol", "es6", "Map", "Array.from", "Set", "Symbol.hasInstance", "Symbol.isConcatSpreadable", "Symbol.iterator", "Array.prototype.@@iterator", "String.prototype.@@iterator", "Symbol.match", "Symbol.replace", "Symbol.search", "Symbol.species", "Symbol.split", "Symbol.toPrimitive", "Symbol.toStringTag", "Symbol.unscopables")
 * - Array.of, License: CC0 (required by "es6")
 * - Object.seal, License: MIT (required by "es6")
 * - Object.setPrototypeOf, License: MIT (required by "es6", "_ArrayIterator", "Array.prototype.entries", "Array.prototype.keys", "Array.prototype.values", "Array.prototype.@@iterator", "_StringIterator", "String.prototype.@@iterator")
 * - Promise, License: MIT (required by "es6")
 * - RegExp.prototype.flags, License: MIT (required by "es6")
 * - String.fromCodePoint, License: MIT (required by "es6")
 * - String.prototype.codePointAt, License: MIT (required by "es6")
 * - String.prototype.endsWith, License: CC0 (required by "es6")
 * - String.prototype.includes, License: CC0 (required by "es6", "_ArrayIterator", "Array.prototype.entries", "Array.prototype.keys", "Array.prototype.values", "Array.prototype.@@iterator")
 * - String.prototype.repeat, License: CC0 (required by "es6")
 * - String.prototype.startsWith, License: CC0 (required by "es6")
 * - Symbol, License: MIT (required by "es6", "Map", "Array.from", "Set", "Symbol.hasInstance", "Symbol.isConcatSpreadable", "Symbol.iterator", "Array.prototype.@@iterator", "String.prototype.@@iterator", "Symbol.match", "Symbol.replace", "Symbol.search", "Symbol.species", "Symbol.split", "Symbol.toPrimitive", "Symbol.toStringTag", "Symbol.unscopables", "WeakMap", "WeakSet", "_Iterator", "_ArrayIterator", "Array.prototype.entries", "Array.prototype.keys", "Array.prototype.values", "_StringIterator")
 * - Symbol.hasInstance, License: MIT (required by "es6")
 * - Symbol.isConcatSpreadable, License: MIT (required by "es6")
 * - Symbol.iterator, License: MIT (required by "es6", "Array.from", "Array.prototype.@@iterator", "Map", "Set", "String.prototype.@@iterator", "_ESAbstract.GetIterator", "WeakMap", "WeakSet", "_Iterator", "_ArrayIterator", "Array.prototype.entries", "Array.prototype.keys", "Array.prototype.values", "_StringIterator")
 * - _ESAbstract.GetIterator, License: CC0 (required by "Array.from", "es6", "Map", "Set", "WeakMap", "WeakSet")
 * - Symbol.match, License: MIT (required by "es6")
 * - Symbol.replace, License: MIT (required by "es6")
 * - Symbol.search, License: MIT (required by "es6")
 * - Symbol.species, License: MIT (required by "es6", "Map", "Array.from", "Set")
 * - Map, License: CC0 (required by "es6", "Array.from")
 * - Set, License: CC0 (required by "es6", "Array.from")
 * - Array.from, License: CC0 (required by "es6")
 * - Symbol.split, License: MIT (required by "es6")
 * - Symbol.toPrimitive, License: MIT (required by "es6")
 * - Symbol.toStringTag, License: MIT (required by "es6", "_Iterator", "_ArrayIterator", "Array.prototype.entries", "Array.prototype.keys", "Array.prototype.values", "Array.prototype.@@iterator", "_StringIterator", "String.prototype.@@iterator")
 * - _Iterator, License: MIT (required by "_ArrayIterator", "Array.prototype.entries", "es6", "Array.prototype.keys", "Array.prototype.values", "Array.prototype.@@iterator", "_StringIterator", "String.prototype.@@iterator")
 * - _ArrayIterator, License: MIT (required by "Array.prototype.entries", "es6", "Array.prototype.keys", "Array.prototype.values", "Array.prototype.@@iterator")
 * - Array.prototype.entries, License: CC0 (required by "es6")
 * - Array.prototype.keys, License: CC0 (required by "es6")
 * - Array.prototype.values, License: MIT (required by "es6", "Array.prototype.@@iterator")
 * - Array.prototype.@@iterator, License: CC0 (required by "es6")
 * - _StringIterator, License: MIT (required by "String.prototype.@@iterator", "es6")
 * - String.prototype.@@iterator, License: CC0 (required by "es6")
 * - Symbol.unscopables, License: MIT (required by "es6")
 * - WeakMap, License: MIT (required by "es6")
 * - WeakSet, License: MIT (required by "es6") */

(function(undefined) {

// _ESAbstract.ArrayCreate
// 9.4.2.2. ArrayCreate ( length [ , proto ] )
function ArrayCreate(length /* [, proto] */) { // eslint-disable-line no-unused-vars
        // 1. Assert: length is an integer Number ≥ 0.
        // 2. If length is -0, set length to +0.
        if (1 / length === -Infinity) {
                length = 0;
        }
        // 3. If length>2^32-1, throw a RangeError exception.
        if (length > (Math.pow(2, 32) - 1)) {
                throw new RangeError('Invalid array length');
        }
        // 4. If proto is not present, set proto to the intrinsic object %ArrayPrototype%.
        // 5. Let A be a newly created Array exotic object.
        var A = [];
        // 6. Set A's essential internal methods except for [[DefineOwnProperty]] to the default ordinary object definitions specified in 9.1.
        // 7. Set A.[[DefineOwnProperty]] as specified in 9.4.2.1.
        // 8. Set A.[[Prototype]] to proto.
        // 9. Set A.[[Extensible]] to true.
        // 10. Perform ! OrdinaryDefineOwnProperty(A, "length", PropertyDescriptor{[[Value]]: length, [[Writable]]: true, [[Enumerable]]: false, [[Configurable]]: false}).
        A.length = length;
        // 11. Return A.
        return A;
}

// _ESAbstract.Call
/* global IsCallable */
// 7.3.12. Call ( F, V [ , argumentsList ] )
function Call(F, V /* [, argumentsList] */) { // eslint-disable-line no-unused-vars
        // 1. If argumentsList is not present, set argumentsList to a new empty List.
        var argumentsList = arguments.length > 2 ? arguments[2] : [];
        // 2. If IsCallable(F) is false, throw a TypeError exception.
        if (IsCallable(F) === false) {
                throw new TypeError(Object.prototype.toString.call(F) + 'is not a function.');
        }
        // 3. Return ? F.[[Call]](V, argumentsList).
        return F.apply(V, argumentsList);
}

// _ESAbstract.Get
// 7.3.1. Get ( O, P )
function Get(O, P) { // eslint-disable-line no-unused-vars
        // 1. Assert: Type(O) is Object.
        // 2. Assert: IsPropertyKey(P) is true.
        // 3. Return ? O.[[Get]](P, O).
        return O[P];
}

// _ESAbstract.HasProperty
// 7.3.10. HasProperty ( O, P )
function HasProperty(O, P) { // eslint-disable-line no-unused-vars
        // Assert: Type(O) is Object.
        // Assert: IsPropertyKey(P) is true.
        // Return ? O.[[HasProperty]](P).
        return P in O;
}

// _ESAbstract.IsArray
// 7.2.2. IsArray ( argument )
function IsArray(argument) { // eslint-disable-line no-unused-vars
        // 1. If Type(argument) is not Object, return false.
        // 2. If argument is an Array exotic object, return true.
        // 3. If argument is a Proxy exotic object, then
                // a. If argument.[[ProxyHandler]] is null, throw a TypeError exception.
                // b. Let target be argument.[[ProxyTarget]].
                // c. Return ? IsArray(target).
        // 4. Return false.

        // Polyfill.io - We can skip all the above steps and check the string returned from Object.prototype.toString().
        return Object.prototype.toString.call(argument) === '[object Array]';
}

// _ESAbstract.IsCallable
// 7.2.3. IsCallable ( argument )
function IsCallable(argument) { // eslint-disable-line no-unused-vars
        // 1. If Type(argument) is not Object, return false.
        // 2. If argument has a [[Call]] internal method, return true.
        // 3. Return false.

        // Polyfill.io - Only function objects have a [[Call]] internal method. This means we can simplify this function to check that the argument has a type of function.
        return typeof argument === 'function';
}

// _ESAbstract.RequireObjectCoercible
// 7.2.1. RequireObjectCoercible ( argument )
// The abstract operation ToObject converts argument to a value of type Object according to Table 12:
// Table 12: ToObject Conversions
/*
|----------------------------------------------------------------------------------------------------------------------------------------------------|
| Argument Type | Result                                                                                                                             |
|----------------------------------------------------------------------------------------------------------------------------------------------------|
| Undefined     | Throw a TypeError exception.                                                                                                       |
| Null          | Throw a TypeError exception.                                                                                                       |
| Boolean       | Return argument.                                                                                                                   |
| Number        | Return argument.                                                                                                                   |
| String        | Return argument.                                                                                                                   |
| Symbol        | Return argument.                                                                                                                   |
| Object        | Return argument.                                                                                                                   |
|----------------------------------------------------------------------------------------------------------------------------------------------------|
*/
function RequireObjectCoercible(argument) { // eslint-disable-line no-unused-vars
        if (argument === null || argument === undefined) {
                throw TypeError();
        }
  return argument;
}

// _ESAbstract.SameValueNonNumber
// 7.2.12. SameValueNonNumber ( x, y )
function SameValueNonNumber(x, y) { // eslint-disable-line no-unused-vars
        // 1. Assert: Type(x) is not Number.
        // 2. Assert: Type(x) is the same as Type(y).
        // 3. If Type(x) is Undefined, return true.
        // 4. If Type(x) is Null, return true.
        // 5. If Type(x) is String, then
                // a. If x and y are exactly the same sequence of code units (same length and same code units at corresponding indices), return true; otherwise, return false.
        // 6. If Type(x) is Boolean, then
                // a. If x and y are both true or both false, return true; otherwise, return false.
        // 7. If Type(x) is Symbol, then
                // a. If x and y are both the same Symbol value, return true; otherwise, return false.
        // 8. If x and y are the same Object value, return true. Otherwise, return false.

        // Polyfill.io - We can skip all above steps because the === operator does it all for us.
        return x === y;
}

// _ESAbstract.ToBoolean
// 7.1.2. ToBoolean ( argument )
// The abstract operation ToBoolean converts argument to a value of type Boolean according to Table 9:
/*
--------------------------------------------------------------------------------------------------------------
| Argument Type | Result                                                                                     |
--------------------------------------------------------------------------------------------------------------
| Undefined     | Return false.                                                                              |
| Null          | Return false.                                                                              |
| Boolean       | Return argument.                                                                           |
| Number        | If argument is +0, -0, or NaN, return false; otherwise return true.                        |
| String        | If argument is the empty String (its length is zero), return false; otherwise return true. |
| Symbol        | Return true.                                                                               |
| Object        | Return true.                                                                               |
--------------------------------------------------------------------------------------------------------------
*/
function ToBoolean(argument) { // eslint-disable-line no-unused-vars
        return Boolean(argument);
}

// _ESAbstract.ToInteger
// 7.1.4. ToInteger ( argument )
function ToInteger(argument) { // eslint-disable-line no-unused-vars
        // 1. Let number be ? ToNumber(argument).
        var number = Number(argument);
        // 2. If number is NaN, return +0.
        if (isNaN(number)) {
                return 0;
        }
        // 3. If number is +0, -0, +∞, or -∞, return number.
        if (1/number === Infinity || 1/number === -Infinity || number === Infinity || number === -Infinity) {
                return number;
        }
        // 4. Return the number value that is the same sign as number and whose magnitude is floor(abs(number)).
        return ((number < 0) ? -1 : 1) * Math.floor(Math.abs(number));
}

// _ESAbstract.ToLength
/* global ToInteger */
// 7.1.15. ToLength ( argument )
function ToLength(argument) { // eslint-disable-line no-unused-vars
        // 1. Let len be ? ToInteger(argument).
        var len = ToInteger(argument);
        // 2. If len ≤ +0, return +0.
        if (len <= 0) {
                return 0;
        }
        // 3. Return min(len, 253-1).
        return Math.min(len, Math.pow(2, 53) -1);
}

// _ESAbstract.ToNumber
// 7.1.3. ToNumber ( argument )
function ToNumber(argument) { // eslint-disable-line no-unused-vars
        return Number(argument);
}

// _ESAbstract.ToObject
// 7.1.13 ToObject ( argument )
// The abstract operation ToObject converts argument to a value of type Object according to Table 12:
// Table 12: ToObject Conversions
/*
|----------------------------------------------------------------------------------------------------------------------------------------------------|
| Argument Type | Result                                                                                                                             |
|----------------------------------------------------------------------------------------------------------------------------------------------------|
| Undefined     | Throw a TypeError exception.                                                                                                       |
| Null          | Throw a TypeError exception.                                                                                                       |
| Boolean       | Return a new Boolean object whose [[BooleanData]] internal slot is set to argument. See 19.3 for a description of Boolean objects. |
| Number        | Return a new Number object whose [[NumberData]] internal slot is set to argument. See 20.1 for a description of Number objects.    |
| String        | Return a new String object whose [[StringData]] internal slot is set to argument. See 21.1 for a description of String objects.    |
| Symbol        | Return a new Symbol object whose [[SymbolData]] internal slot is set to argument. See 19.4 for a description of Symbol objects.    |
| Object        | Return argument.                                                                                                                   |
|----------------------------------------------------------------------------------------------------------------------------------------------------|
*/
function ToObject(argument) { // eslint-disable-line no-unused-vars
        if (argument === null || argument === undefined) {
                throw TypeError();
        }
  return Object(argument);
}

// _ESAbstract.GetV
/* global ToObject */
// 7.3.2 GetV (V, P)
function GetV(v, p) { // eslint-disable-line no-unused-vars
        // 1. Assert: IsPropertyKey(P) is true.
        // 2. Let O be ? ToObject(V).
        var o = ToObject(v);
        // 3. Return ? O.[[Get]](P, V).
        return o[p];
}

// _ESAbstract.GetMethod
/* global GetV, IsCallable */
// 7.3.9. GetMethod ( V, P )
function GetMethod(V, P) { // eslint-disable-line no-unused-vars
        // 1. Assert: IsPropertyKey(P) is true.
        // 2. Let func be ? GetV(V, P).
        var func = GetV(V, P);
        // 3. If func is either undefined or null, return undefined.
        if (func === null || func === undefined) {
                return undefined;
        }
        // 4. If IsCallable(func) is false, throw a TypeError exception.
        if (IsCallable(func) === false) {
                throw new TypeError('Method not callable: ' + P);
        }
        // 5. Return func.
        return func;
}

// _ESAbstract.ToUint32
// 7.1.6. ToUint32 ( argument )
function ToUint32(argument) { // eslint-disable-line no-unused-vars
        // 1. Let number be ? ToNumber(argument).
        var number = Number(argument);
        // 2. If number is NaN, +0, -0, +∞, or -∞, return +0.
        if (isNaN(number) || 1/number === Infinity || 1/number === -Infinity || number === Infinity || number === -Infinity) {
                return 0;
        }
        // 3. Let int be the mathematical value that is the same sign as number and whose magnitude is floor(abs(number)).
        var int = ((number < 0) ? -1 : 1) * Math.floor(Math.abs(number));
        // 4. Let int32bit be int modulo 2^32.
        var int32bit = int >>> 0;
        // 5. Return int32bit.
        return int32bit;
}

// _ESAbstract.Type
// "Type(x)" is used as shorthand for "the type of x"...
function Type(x) { // eslint-disable-line no-unused-vars
        switch (typeof x) {
                case 'undefined':
                        return 'undefined';
                case 'boolean':
                        return 'boolean';
                case 'number':
                        return 'number';
                case 'string':
                        return 'string';
                case 'symbol':
                        return 'symbol';
                default:
                        // typeof null is 'object'
                        if (x === null) return 'null';
                        // Polyfill.io - This is here because a Symbol polyfill will have a typeof `object`.
                        if ('Symbol' in this && x instanceof this.Symbol) return 'symbol';
                        return 'object';
        }
}

// _ESAbstract.GetPrototypeFromConstructor
/* global Get, Type */
// 9.1.14. GetPrototypeFromConstructor ( constructor, intrinsicDefaultProto )
function GetPrototypeFromConstructor(constructor, intrinsicDefaultProto) { // eslint-disable-line no-unused-vars
        // 1. Assert: intrinsicDefaultProto is a String value that is this specification's name of an intrinsic object. The corresponding object must be an intrinsic that is intended to be used as the [[Prototype]] value of an object.
        // 2. Assert: IsCallable(constructor) is true.
        // 3. Let proto be ? Get(constructor, "prototype").
        var proto = Get(constructor, "prototype");
        // 4. If Type(proto) is not Object, then
        if (Type(proto) !== 'object') {
                // a. Let realm be ? GetFunctionRealm(constructor).
                // b. Set proto to realm's intrinsic object named intrinsicDefaultProto.
                proto = intrinsicDefaultProto;
        }
        // 5. Return proto.
        return proto;
}

// _ESAbstract.IsConstructor
/* global Type */
// 7.2.4. IsConstructor ( argument )
function IsConstructor(argument) { // eslint-disable-line no-unused-vars
        // 1. If Type(argument) is not Object, return false.
        if (Type(argument) !== 'object') {
                return false;
        }
        // 2. If argument has a [[Construct]] internal method, return true.
        // 3. Return false.

        // Polyfill.io - `new argument` is the only way  to truly test if a function is a constructor.
        // We choose to not use`new argument` because the argument could have side effects when called.
        // Instead we check to see if the argument is a function and if it has a prototype.
        // Arrow functions do not have a [[Construct]] internal method, nor do they have a prototype.
        return typeof argument === 'function' && !!argument.prototype;
}

// _ESAbstract.IsRegExp
/* global Type, Get, ToBoolean */
// 7.2.8. IsRegExp ( argument )
function IsRegExp(argument) { // eslint-disable-line no-unused-vars
        // 1. If Type(argument) is not Object, return false.
        if (Type(argument) !== 'object') {
                return false;
        }
        // 2. Let matcher be ? Get(argument, @@match).
        var matcher = 'Symbol' in this && 'match' in this.Symbol ? Get(argument, this.Symbol.match) : undefined;
        // 3. If matcher is not undefined, return ToBoolean(matcher).
        if (matcher !== undefined) {
                return ToBoolean(matcher);
        }
        // 4. If argument has a [[RegExpMatcher]] internal slot, return true.
        try {
                var lastIndex = argument.lastIndex;
                argument.lastIndex = 0;
                RegExp.prototype.exec.call(argument);
                return true;
        } catch (e) {} finally {
                argument.lastIndex = lastIndex;
        }
        // 5. Return false.
        return false;
}

// _ESAbstract.IteratorClose
/* global GetMethod, Type, Call */
// 7.4.6. IteratorClose ( iteratorRecord, completion )
function IteratorClose(iteratorRecord, completion) { // eslint-disable-line no-unused-vars
        // 1. Assert: Type(iteratorRecord.[[Iterator]]) is Object.
        if (Type(iteratorRecord['[[Iterator]]']) !== 'object') {
                throw new Error(Object.prototype.toString.call(iteratorRecord['[[Iterator]]']) + 'is not an Object.');
        }
        // 2. Assert: completion is a Completion Record.
        // Polyfill.io - Ignoring this step as there is no way to check if something is a Completion Record in userland JavaScript.

        // 3. Let iterator be iteratorRecord.[[Iterator]].
        var iterator = iteratorRecord['[[Iterator]]'];
        // 4. Let return be ? GetMethod(iterator, "return").
        // Polyfill.io - We name it  returnMethod because return is a keyword and can not be used as an identifier (E.G. variable name, function name etc).
        var returnMethod = GetMethod(iterator, "return");
        // 5. If return is undefined, return Completion(completion).
        if (returnMethod === undefined) {
                return completion;
        }
        // 6. Let innerResult be Call(return, iterator, « »).
        try {
                var innerResult = Call(returnMethod, iterator);
        } catch (error) {
                var innerException = error;
        }
        // 7. If completion.[[Type]] is throw, return Completion(completion).
        if (completion) {
                return completion;
        }
        // 8. If innerResult.[[Type]] is throw, return Completion(innerResult).
        if (innerException) {
                throw innerException;
        }
        // 9. If Type(innerResult.[[Value]]) is not Object, throw a TypeError exception.
        if (Type(innerResult) !== 'object') {
                throw new TypeError("Iterator's return method returned a non-object.");
        }
        // 10. Return Completion(completion).
        return completion;
}

// _ESAbstract.IteratorComplete
/* global Type, ToBoolean, Get */
// 7.4.3 IteratorComplete ( iterResult )
function IteratorComplete(iterResult) { // eslint-disable-line no-unused-vars
        // 1. Assert: Type(iterResult) is Object.
        if (Type(iterResult) !== 'object') {
                throw new Error(Object.prototype.toString.call(iterResult) + 'is not an Object.');
        }
        // 2. Return ToBoolean(? Get(iterResult, "done")).
        return ToBoolean(Get(iterResult, "done"));
}

// _ESAbstract.IteratorNext
/* global Call, Type */
// 7.4.2. IteratorNext ( iteratorRecord [ , value ] )
function IteratorNext(iteratorRecord /* [, value] */) { // eslint-disable-line no-unused-vars
        // 1. If value is not present, then
        if (arguments.length < 2) {
                // a. Let result be ? Call(iteratorRecord.[[NextMethod]], iteratorRecord.[[Iterator]], « »).
                var result = Call(iteratorRecord['[[NextMethod]]'], iteratorRecord['[[Iterator]]']);
        // 2. Else,
        } else {
                // a. Let result be ? Call(iteratorRecord.[[NextMethod]], iteratorRecord.[[Iterator]], « value »).
                result = Call(iteratorRecord['[[NextMethod]]'], iteratorRecord['[[Iterator]]'], [arguments[1]]);
        }
        // 3. If Type(result) is not Object, throw a TypeError exception.
        if (Type(result) !== 'object') {
                throw new TypeError('bad iterator');
        }
        // 4. Return result.
        return result;
}

// _ESAbstract.IteratorStep
/* global IteratorNext, IteratorComplete */
// 7.4.5. IteratorStep ( iteratorRecord )
function IteratorStep(iteratorRecord) { // eslint-disable-line no-unused-vars
        // 1. Let result be ? IteratorNext(iteratorRecord).
        var result = IteratorNext(iteratorRecord);
        // 2. Let done be ? IteratorComplete(result).
        var done = IteratorComplete(result);
        // 3. If done is true, return false.
        if (done === true) {
                return false;
        }
        // 4. Return result.
        return result;
}

// _ESAbstract.IteratorValue
/* global Type, Get */
// 7.4.4 IteratorValue ( iterResult )
function IteratorValue(iterResult) { // eslint-disable-line no-unused-vars
        // Assert: Type(iterResult) is Object.
        if (Type(iterResult) !== 'object') {
                throw new Error(Object.prototype.toString.call(iterResult) + 'is not an Object.');
        }
        // Return ? Get(iterResult, "value").
        return Get(iterResult, "value");
}

// _ESAbstract.OrdinaryToPrimitive
/* global Get, IsCallable, Call, Type */
// 7.1.1.1. OrdinaryToPrimitive ( O, hint )
function OrdinaryToPrimitive(O, hint) { // eslint-disable-line no-unused-vars
        // 1. Assert: Type(O) is Object.
        // 2. Assert: Type(hint) is String and its value is either "string" or "number".
        // 3. If hint is "string", then
        if (hint === 'string') {
                // a. Let methodNames be « "toString", "valueOf" ».
                var methodNames = ['toString', 'valueOf'];
                // 4. Else,
        } else {
                // a. Let methodNames be « "valueOf", "toString" ».
                methodNames = ['valueOf', 'toString'];
        }
        // 5. For each name in methodNames in List order, do
        for (var i = 0; i < methodNames.length; ++i) {
                var name = methodNames[i];
                // a. Let method be ? Get(O, name).
                var method = Get(O, name);
                // b. If IsCallable(method) is true, then
                if (IsCallable(method)) {
                        // i. Let result be ? Call(method, O).
                        var result = Call(method, O);
                        // ii. If Type(result) is not Object, return result.
                        if (Type(result) !== 'object') {
                                return result;
                        }
                }
        }
        // 6. Throw a TypeError exception.
        throw new TypeError('Cannot convert to primitive.');
}

// _ESAbstract.SameValue
/* global Type, SameValueNonNumber */
// 7.2.10. SameValue ( x, y )
function SameValue(x, y) { // eslint-disable-line no-unused-vars
        // 1. If Type(x) is different from Type(y), return false.
        if (Type(x) !== Type(y)) {
                return false;
        }
        // 2. If Type(x) is Number, then
        if (Type(x) === 'number') {
                // a. If x is NaN and y is NaN, return true.
                if (isNaN(x) && isNaN(y)) {
                        return true;
                }
                // Polyfill.io - 0 === -0 is true, but they are not the same value.
                // b. If x is +0 and y is -0, return false.
                // c. If x is -0 and y is +0, return false.
                if (x === 0 && y === 0 && 1/x !== 1/y) {
                        return false;
                }
                // d. If x is the same Number value as y, return true.
                if (x === y) {
                        return true;
                }
                // e. Return false.
                return false;
        }
        // 3. Return SameValueNonNumber(x, y).
        return SameValueNonNumber(x, y);
}

// _ESAbstract.SameValueZero
/* global Type, SameValueNonNumber */
// 7.2.11. SameValueZero ( x, y )
function SameValueZero (x, y) { // eslint-disable-line no-unused-vars
        // 1. If Type(x) is different from Type(y), return false.
        if (Type(x) !== Type(y)) {
                return false;
        }
        // 2. If Type(x) is Number, then
        if (Type(x) === 'number') {
                // a. If x is NaN and y is NaN, return true.
                if (isNaN(x) && isNaN(y)) {
                        return true;
                }
                // b. If x is +0 and y is -0, return true.
                if (1/x === Infinity && 1/y === -Infinity) {
                        return true;
                }
                // c. If x is -0 and y is +0, return true.
                if (1/x === -Infinity && 1/y === Infinity) {
                        return true;
                }
                // d. If x is the same Number value as y, return true.
                if (x === y) {
                        return true;
                }
                // e. Return false.
                return false;
        }
        // 3. Return SameValueNonNumber(x, y).
        return SameValueNonNumber(x, y);
}

// _ESAbstract.ToPrimitive
/* global Type, GetMethod, Call, OrdinaryToPrimitive */
// 7.1.1. ToPrimitive ( input [ , PreferredType ] )
function ToPrimitive(input /* [, PreferredType] */) { // eslint-disable-line no-unused-vars
        var PreferredType = arguments.length > 1 ? arguments[1] : undefined;
        // 1. Assert: input is an ECMAScript language value.
        // 2. If Type(input) is Object, then
        if (Type(input) === 'object') {
                // a. If PreferredType is not present, let hint be "default".
                if (arguments.length < 2) {
                        var hint = 'default';
                        // b. Else if PreferredType is hint String, let hint be "string".
                } else if (PreferredType === String) {
                        hint = 'string';
                        // c. Else PreferredType is hint Number, let hint be "number".
                } else if (PreferredType === Number) {
                        hint = 'number';
                }
                // d. Let exoticToPrim be ? GetMethod(input, @@toPrimitive).
                var exoticToPrim = typeof this.Symbol === 'function' && typeof this.Symbol.toPrimitive === 'symbol' ? GetMethod(input, this.Symbol.toPrimitive) : undefined;
                // e. If exoticToPrim is not undefined, then
                if (exoticToPrim !== undefined) {
                        // i. Let result be ? Call(exoticToPrim, input, « hint »).
                        var result = Call(exoticToPrim, input, [hint]);
                        // ii. If Type(result) is not Object, return result.
                        if (Type(result) !== 'object') {
                                return result;
                        }
                        // iii. Throw a TypeError exception.
                        throw new TypeError('Cannot convert exotic object to primitive.');
                }
                // f. If hint is "default", set hint to "number".
                if (hint === 'default') {
                        hint = 'number';
                }
                // g. Return ? OrdinaryToPrimitive(input, hint).
                return OrdinaryToPrimitive(input, hint);
        }
        // 3. Return input
        return input;
}

// _ESAbstract.ToString
/* global Type, ToPrimitive */
// 7.1.12. ToString ( argument )
// The abstract operation ToString converts argument to a value of type String according to Table 11:
// Table 11: ToString Conversions
/*
|---------------|--------------------------------------------------------|
| Argument Type | Result                                                 |
|---------------|--------------------------------------------------------|
| Undefined     | Return "undefined".                                    |
|---------------|--------------------------------------------------------|
| Null          | Return "null".                                         |
|---------------|--------------------------------------------------------|
| Boolean       | If argument is true, return "true".                    |
|               | If argument is false, return "false".                  |
|---------------|--------------------------------------------------------|
| Number        | Return NumberToString(argument).                       |
|---------------|--------------------------------------------------------|
| String        | Return argument.                                       |
|---------------|--------------------------------------------------------|
| Symbol        | Throw a TypeError exception.                           |
|---------------|--------------------------------------------------------|
| Object        | Apply the following steps:                             |
|               | Let primValue be ? ToPrimitive(argument, hint String). |
|               | Return ? ToString(primValue).                          |
|---------------|--------------------------------------------------------|
*/
function ToString(argument) { // eslint-disable-line no-unused-vars
        switch(Type(argument)) {
                case 'symbol':
                        throw new TypeError('Cannot convert a Symbol value to a string');
                        break;
                case 'object':
                        var primValue = ToPrimitive(argument, 'string');
                        return ToString(primValue);
                default:
                        return String(argument);
        }
}

// _ESAbstract.UTF16Decode
// 10.1.2. Static Semantics: UTF16Decode( lead, trail )
function UTF16Decode(lead, trail) { // eslint-disable-line no-unused-vars
        // 1. Assert: 0xD800 ≤ lead ≤ 0xDBFF and 0xDC00 ≤ trail ≤ 0xDFFF.
        // 2. Let cp be (lead - 0xD800) × 0x400 + (trail - 0xDC00) + 0x10000.
        var cp = (lead - 0xD800) * 0x400 + (trail - 0xDC00) + 0x10000;
        // 3. Return the code point cp.
        return cp;
}

// _ESAbstract.UTF16Encoding
// 10.1.1. Static Semantics: UTF16Encoding ( cp )
function UTF16Encoding(cp) { // eslint-disable-line no-unused-vars
        // 1. Assert: 0 ≤ cp ≤ 0x10FFFF.
        // 2. If cp ≤ 0xFFFF, return cp.
        if (cp <= 0xFFFF) {
                return cp;
        } else {
                // 3. Let cu1 be floor((cp - 0x10000) / 0x400) + 0xD800.
                var cu1 = Math.floor((cp - 0x10000) / 0x400) + 0xD800;
                // 4. Let cu2 be ((cp - 0x10000) modulo 0x400) + 0xDC00.
                var cu2 = ((cp - 0x10000) % 0x400) + 0xDC00;
                // 5. Return the code unit sequence consisting of cu1 followed by cu2.
                return [cu1, cu2];
        }
}

// _TypedArray
/*
 Copyright (c) 2010, Linden Research, Inc.
 Copyright (c) 2014, Joshua Bell

 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
 in the Software without restriction, including without limitation the rights
 to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 copies of the Software, and to permit persons to whom the Software is
 furnished to do so, subject to the following conditions:

 The above copyright notice and this permission notice shall be included in
 all copies or substantial portions of the Software.

 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 THE SOFTWARE.
 $/LicenseInfo$
 */

// Original can be found at:
//   https://bitbucket.org/lindenlab/llsd
// Modifications by Joshua Bell inexorabletash@gmail.com
//   https://github.com/inexorabletash/polyfill

// ES3/ES5 implementation of the Krhonos Typed Array Specification
//   Ref: http://www.khronos.org/registry/typedarray/specs/latest/
//   Date: 2011-02-01
//
// Variations:
//  * Allows typed_array.get/set() as alias for subscripts (typed_array[])
//  * Gradually migrating structure from Khronos spec to ES2015 spec
//
// Caveats:
//  * Beyond 10000 or so entries, polyfilled array accessors (ta[0],
//    etc) become memory-prohibitive, so array creation will fail. Set
//    self.TYPED_ARRAY_POLYFILL_NO_ARRAY_ACCESSORS=true to disable
//    creation of accessors. Your code will need to use the
//    non-standard get()/set() instead, and will need to add those to
//    native arrays for interop.
(function(global) {
  'use strict';
  var undefined = (void 0); // Paranoia

  // Beyond this value, index getters/setters (i.e. array[0], array[1]) are so slow to
  // create, and consume so much memory, that the browser appears frozen.
  var MAX_ARRAY_LENGTH = 1e5;

  // Approximations of internal ECMAScript conversion functions
  function Type(v) {
    switch(typeof v) {
    case 'undefined': return 'undefined';
    case 'boolean': return 'boolean';
    case 'number': return 'number';
    case 'string': return 'string';
    default: return v === null ? 'null' : 'object';
    }
  }

  // Class returns internal [[Class]] property, used to avoid cross-frame instanceof issues:
  function Class(v) { return Object.prototype.toString.call(v).replace(/^\[object *|\]$/g, ''); }
  function IsCallable(o) { return typeof o === 'function'; }
  function ToObject(v) {
    if (v === null || v === undefined) throw TypeError();
    return Object(v);
  }
  function ToInt32(v) { return v >> 0; }
  function ToUint32(v) { return v >>> 0; }

  // Snapshot intrinsics
  var LN2 = Math.LN2,
      abs = Math.abs,
      floor = Math.floor,
      log = Math.log,
      max = Math.max,
      min = Math.min,
      pow = Math.pow,
      round = Math.round;

  // emulate ES5 getter/setter API using legacy APIs
  // http://blogs.msdn.com/b/ie/archive/2010/09/07/transitioning-existing-code-to-the-es5-getter-setter-apis.aspx
  // (second clause tests for Object.defineProperty() in IE<9 that only supports extending DOM prototypes, but
  // note that IE<9 does not support __defineGetter__ or __defineSetter__ so it just renders the method harmless)

  (function() {
    var orig = Object.defineProperty;
    var dom_only = !(function(){try{return Object.defineProperty({},'x',{});}catch(_){return false;}}());

    if (!orig || dom_only) {
      Object.defineProperty = function (o, prop, desc) {
        // In IE8 try built-in implementation for defining properties on DOM prototypes.
        if (orig)
          try { return orig(o, prop, desc); } catch (_) {}
        if (o !== Object(o))
          throw TypeError('Object.defineProperty called on non-object');
        if (Object.prototype.__defineGetter__ && ('get' in desc))
          Object.prototype.__defineGetter__.call(o, prop, desc.get);
        if (Object.prototype.__defineSetter__ && ('set' in desc))
          Object.prototype.__defineSetter__.call(o, prop, desc.set);
        if ('value' in desc)
          o[prop] = desc.value;
        return o;
      };
    }
  }());

  // ES5: Make obj[index] an alias for obj._getter(index)/obj._setter(index, value)
  // for index in 0 ... obj.length
  function makeArrayAccessors(obj) {
    if ('TYPED_ARRAY_POLYFILL_NO_ARRAY_ACCESSORS' in global)
      return;

    if (obj.length > MAX_ARRAY_LENGTH) throw RangeError('Array too large for polyfill');

    function makeArrayAccessor(index) {
      Object.defineProperty(obj, index, {
        'get': function() { return obj._getter(index); },
        'set': function(v) { obj._setter(index, v); },
        enumerable: true,
        configurable: false
      });
    }

    var i;
    for (i = 0; i < obj.length; i += 1) {
      makeArrayAccessor(i);
    }
  }

  // Internal conversion functions:
  //    pack<Type>()   - take a number (interpreted as Type), output a byte array
  //    unpack<Type>() - take a byte array, output a Type-like number

  function as_signed(value, bits) { var s = 32 - bits; return (value << s) >> s; }
  function as_unsigned(value, bits) { var s = 32 - bits; return (value << s) >>> s; }

  function packI8(n) { return [n & 0xff]; }
  function unpackI8(bytes) { return as_signed(bytes[0], 8); }

  function packU8(n) { return [n & 0xff]; }
  function unpackU8(bytes) { return as_unsigned(bytes[0], 8); }

  function packU8Clamped(n) { n = round(Number(n)); return [n < 0 ? 0 : n > 0xff ? 0xff : n & 0xff]; }

  function packI16(n) { return [n & 0xff, (n >> 8) & 0xff]; }
  function unpackI16(bytes) { return as_signed(bytes[1] << 8 | bytes[0], 16); }

  function packU16(n) { return [n & 0xff, (n >> 8) & 0xff]; }
  function unpackU16(bytes) { return as_unsigned(bytes[1] << 8 | bytes[0], 16); }

  function packI32(n) { return [n & 0xff, (n >> 8) & 0xff, (n >> 16) & 0xff, (n >> 24) & 0xff]; }
  function unpackI32(bytes) { return as_signed(bytes[3] << 24 | bytes[2] << 16 | bytes[1] << 8 | bytes[0], 32); }

  function packU32(n) { return [n & 0xff, (n >> 8) & 0xff, (n >> 16) & 0xff, (n >> 24) & 0xff]; }
  function unpackU32(bytes) { return as_unsigned(bytes[3] << 24 | bytes[2] << 16 | bytes[1] << 8 | bytes[0], 32); }

  function packIEEE754(v, ebits, fbits) {

    var bias = (1 << (ebits - 1)) - 1;

    function roundToEven(n) {
      var w = floor(n), f = n - w;
      if (f < 0.5)
        return w;
      if (f > 0.5)
        return w + 1;
      return w % 2 ? w + 1 : w;
    }

    // Compute sign, exponent, fraction
    var s, e, f;
    if (v !== v) {
      // NaN
      // http://dev.w3.org/2006/webapi/WebIDL/#es-type-mapping
      e = (1 << ebits) - 1; f = pow(2, fbits - 1); s = 0;
    } else if (v === Infinity || v === -Infinity) {
      e = (1 << ebits) - 1; f = 0; s = (v < 0) ? 1 : 0;
    } else if (v === 0) {
      e = 0; f = 0; s = (1 / v === -Infinity) ? 1 : 0;
    } else {
      s = v < 0;
      v = abs(v);

      if (v >= pow(2, 1 - bias)) {
        // Normalized
        e = min(floor(log(v) / LN2), 1023);
        var significand = v / pow(2, e);
        if (significand < 1) {
          e -= 1;
          significand *= 2;
        }
        if (significand >= 2) {
          e += 1;
          significand /= 2;
        }
        var d = pow(2, fbits);
        f = roundToEven(significand * d) - d;
        e += bias;
        if (f / d >= 1) {
          e += 1;
          f = 0;
        }
        if (e > 2 * bias) {
          // Overflow
          e = (1 << ebits) - 1;
          f = 0;
        }
      } else {
        // Denormalized
        e = 0;
        f = roundToEven(v / pow(2, 1 - bias - fbits));
      }
    }

    // Pack sign, exponent, fraction
    var bits = [], i;
    for (i = fbits; i; i -= 1) { bits.push(f % 2 ? 1 : 0); f = floor(f / 2); }
    for (i = ebits; i; i -= 1) { bits.push(e % 2 ? 1 : 0); e = floor(e / 2); }
    bits.push(s ? 1 : 0);
    bits.reverse();
    var str = bits.join('');

    // Bits to bytes
    var bytes = [];
    while (str.length) {
      bytes.unshift(parseInt(str.substring(0, 8), 2));
      str = str.substring(8);
    }
    return bytes;
  }

  function unpackIEEE754(bytes, ebits, fbits) {
    // Bytes to bits
    var bits = [], i, j, b, str,
        bias, s, e, f;

    for (i = 0; i < bytes.length; ++i) {
      b = bytes[i];
      for (j = 8; j; j -= 1) {
        bits.push(b % 2 ? 1 : 0); b = b >> 1;
      }
    }
    bits.reverse();
    str = bits.join('');

    // Unpack sign, exponent, fraction
    bias = (1 << (ebits - 1)) - 1;
    s = parseInt(str.substring(0, 1), 2) ? -1 : 1;
    e = parseInt(str.substring(1, 1 + ebits), 2);
    f = parseInt(str.substring(1 + ebits), 2);

    // Produce number
    if (e === (1 << ebits) - 1) {
      return f !== 0 ? NaN : s * Infinity;
    } else if (e > 0) {
      // Normalized
      return s * pow(2, e - bias) * (1 + f / pow(2, fbits));
    } else if (f !== 0) {
      // Denormalized
      return s * pow(2, -(bias - 1)) * (f / pow(2, fbits));
    } else {
      return s < 0 ? -0 : 0;
    }
  }

  function unpackF64(b) { return unpackIEEE754(b, 11, 52); }
  function packF64(v) { return packIEEE754(v, 11, 52); }
  function unpackF32(b) { return unpackIEEE754(b, 8, 23); }
  function packF32(v) { return packIEEE754(v, 8, 23); }

  //
  // 3 The ArrayBuffer Type
  //

  (function() {

    function ArrayBuffer(length) {
      length = ToInt32(length);
      if (length < 0) throw RangeError('ArrayBuffer size is not a small enough positive integer.');
      Object.defineProperty(this, 'byteLength', {value: length});
      Object.defineProperty(this, '_bytes', {value: Array(length)});

      for (var i = 0; i < length; i += 1)
        this._bytes[i] = 0;
    }

    global.ArrayBuffer = global.ArrayBuffer || ArrayBuffer;

    //
    // 5 The Typed Array View Types
    //

    function $TypedArray$() {

      // %TypedArray% ( length )
      if (!arguments.length || typeof arguments[0] !== 'object') {
        return (function(length) {
          length = ToInt32(length);
          if (length < 0) throw RangeError('length is not a small enough positive integer.');
          Object.defineProperty(this, 'length', {value: length});
          Object.defineProperty(this, 'byteLength', {value: length * this.BYTES_PER_ELEMENT});
          Object.defineProperty(this, 'buffer', {value: new ArrayBuffer(this.byteLength)});
          Object.defineProperty(this, 'byteOffset', {value: 0});

         }).apply(this, arguments);
      }

      // %TypedArray% ( typedArray )
      if (arguments.length >= 1 &&
          Type(arguments[0]) === 'object' &&
          arguments[0] instanceof $TypedArray$) {
        return (function(typedArray){
          if (this.constructor !== typedArray.constructor) throw TypeError();

          var byteLength = typedArray.length * this.BYTES_PER_ELEMENT;
          Object.defineProperty(this, 'buffer', {value: new ArrayBuffer(byteLength)});
          Object.defineProperty(this, 'byteLength', {value: byteLength});
          Object.defineProperty(this, 'byteOffset', {value: 0});
          Object.defineProperty(this, 'length', {value: typedArray.length});

          for (var i = 0; i < this.length; i += 1)
            this._setter(i, typedArray._getter(i));

        }).apply(this, arguments);
      }

      // %TypedArray% ( array )
      if (arguments.length >= 1 &&
          Type(arguments[0]) === 'object' &&
          !(arguments[0] instanceof $TypedArray$) &&
          !(arguments[0] instanceof ArrayBuffer || Class(arguments[0]) === 'ArrayBuffer')) {
        return (function(array) {

          var byteLength = array.length * this.BYTES_PER_ELEMENT;
          Object.defineProperty(this, 'buffer', {value: new ArrayBuffer(byteLength)});
          Object.defineProperty(this, 'byteLength', {value: byteLength});
          Object.defineProperty(this, 'byteOffset', {value: 0});
          Object.defineProperty(this, 'length', {value: array.length});

          for (var i = 0; i < this.length; i += 1) {
            var s = array[i];
            this._setter(i, Number(s));
          }
        }).apply(this, arguments);
      }

      // %TypedArray% ( buffer, byteOffset=0, length=undefined )
      if (arguments.length >= 1 &&
          Type(arguments[0]) === 'object' &&
          (arguments[0] instanceof ArrayBuffer || Class(arguments[0]) === 'ArrayBuffer')) {
        return (function(buffer, byteOffset, length) {

          byteOffset = ToUint32(byteOffset);
          if (byteOffset > buffer.byteLength)
            throw RangeError('byteOffset out of range');

          // The given byteOffset must be a multiple of the element
          // size of the specific type, otherwise an exception is raised.
          if (byteOffset % this.BYTES_PER_ELEMENT)
            throw RangeError('buffer length minus the byteOffset is not a multiple of the element size.');

          if (length === undefined) {
            var byteLength = buffer.byteLength - byteOffset;
            if (byteLength % this.BYTES_PER_ELEMENT)
              throw RangeError('length of buffer minus byteOffset not a multiple of the element size');
            length = byteLength / this.BYTES_PER_ELEMENT;

          } else {
            length = ToUint32(length);
            byteLength = length * this.BYTES_PER_ELEMENT;
          }

          if ((byteOffset + byteLength) > buffer.byteLength)
            throw RangeError('byteOffset and length reference an area beyond the end of the buffer');

          Object.defineProperty(this, 'buffer', {value: buffer});
          Object.defineProperty(this, 'byteLength', {value: byteLength});
          Object.defineProperty(this, 'byteOffset', {value: byteOffset});
          Object.defineProperty(this, 'length', {value: length});

        }).apply(this, arguments);
      }

      // %TypedArray% ( all other argument combinations )
      throw TypeError();
    }

    // Properties of the %TypedArray Instrinsic Object

    // %TypedArray%.from ( source , mapfn=undefined, thisArg=undefined )
    Object.defineProperty($TypedArray$, 'from', {value: function(iterable) {
      return new this(iterable);
    }});

    // %TypedArray%.of ( ...items )
    Object.defineProperty($TypedArray$, 'of', {value: function(/*...items*/) {
      return new this(arguments);
    }});

    // %TypedArray%.prototype
    var $TypedArrayPrototype$ = {};
    $TypedArray$.prototype = $TypedArrayPrototype$;

    // WebIDL: getter type (unsigned long index);
    Object.defineProperty($TypedArray$.prototype, '_getter', {value: function(index) {
      if (arguments.length < 1) throw SyntaxError('Not enough arguments');

      index = ToUint32(index);
      if (index >= this.length)
        return undefined;

      var bytes = [], i, o;
      for (i = 0, o = this.byteOffset + index * this.BYTES_PER_ELEMENT;
           i < this.BYTES_PER_ELEMENT;
           i += 1, o += 1) {
        bytes.push(this.buffer._bytes[o]);
      }
      return this._unpack(bytes);
    }});

    // NONSTANDARD: convenience alias for getter: type get(unsigned long index);
    Object.defineProperty($TypedArray$.prototype, 'get', {value: $TypedArray$.prototype._getter});

    // WebIDL: setter void (unsigned long index, type value);
    Object.defineProperty($TypedArray$.prototype, '_setter', {value: function(index, value) {
      if (arguments.length < 2) throw SyntaxError('Not enough arguments');

      index = ToUint32(index);
      if (index >= this.length)
        return;

      var bytes = this._pack(value), i, o;
      for (i = 0, o = this.byteOffset + index * this.BYTES_PER_ELEMENT;
           i < this.BYTES_PER_ELEMENT;
           i += 1, o += 1) {
        this.buffer._bytes[o] = bytes[i];
      }
    }});

    // get %TypedArray%.prototype.buffer
    // get %TypedArray%.prototype.byteLength
    // get %TypedArray%.prototype.byteOffset
    // -- applied directly to the object in the constructor

    // %TypedArray%.prototype.constructor
    Object.defineProperty($TypedArray$.prototype, 'constructor', {value: $TypedArray$});

    // %TypedArray%.prototype.copyWithin (target, start, end = this.length )
    Object.defineProperty($TypedArray$.prototype, 'copyWithin', {value: function(target, start) {
      var end = arguments[2];

      var o = ToObject(this);
      var lenVal = o.length;
      var len = ToUint32(lenVal);
      len = max(len, 0);
      var relativeTarget = ToInt32(target);
      var to;
      if (relativeTarget < 0)
        to = max(len + relativeTarget, 0);
      else
        to = min(relativeTarget, len);
      var relativeStart = ToInt32(start);
      var from;
      if (relativeStart < 0)
        from = max(len + relativeStart, 0);
      else
        from = min(relativeStart, len);
      var relativeEnd;
      if (end === undefined)
        relativeEnd = len;
      else
        relativeEnd = ToInt32(end);
      var final;
      if (relativeEnd < 0)
        final = max(len + relativeEnd, 0);
      else
        final = min(relativeEnd, len);
      var count = min(final - from, len - to);
      var direction;
      if (from < to && to < from + count) {
        direction = -1;
        from = from + count - 1;
        to = to + count - 1;
      } else {
        direction = 1;
      }
      while (count > 0) {
        o._setter(to, o._getter(from));
        from = from + direction;
        to = to + direction;
        count = count - 1;
      }
      return o;
    }});

    // %TypedArray%.prototype.entries ( )
    // -- defined in es6.js to shim browsers w/ native TypedArrays

    // %TypedArray%.prototype.every ( callbackfn, thisArg = undefined )
    Object.defineProperty($TypedArray$.prototype, 'every', {value: function(callbackfn) {
      if (this === undefined || this === null) throw TypeError();
      var t = Object(this);
      var len = ToUint32(t.length);
      if (!IsCallable(callbackfn)) throw TypeError();
      var thisArg = arguments[1];
      for (var i = 0; i < len; i++) {
        if (!callbackfn.call(thisArg, t._getter(i), i, t))
          return false;
      }
      return true;
    }});

    // %TypedArray%.prototype.fill (value, start = 0, end = this.length )
    Object.defineProperty($TypedArray$.prototype, 'fill', {value: function(value) {
      var start = arguments[1],
          end = arguments[2];

      var o = ToObject(this);
      var lenVal = o.length;
      var len = ToUint32(lenVal);
      len = max(len, 0);
      var relativeStart = ToInt32(start);
      var k;
      if (relativeStart < 0)
        k = max((len + relativeStart), 0);
      else
        k = min(relativeStart, len);
      var relativeEnd;
      if (end === undefined)
        relativeEnd = len;
      else
        relativeEnd = ToInt32(end);
      var final;
      if (relativeEnd < 0)
        final = max((len + relativeEnd), 0);
      else
        final = min(relativeEnd, len);
      while (k < final) {
        o._setter(k, value);
        k += 1;
      }
      return o;
    }});

    // %TypedArray%.prototype.filter ( callbackfn, thisArg = undefined )
    Object.defineProperty($TypedArray$.prototype, 'filter', {value: function(callbackfn) {
      if (this === undefined || this === null) throw TypeError();
      var t = Object(this);
      var len = ToUint32(t.length);
      if (!IsCallable(callbackfn)) throw TypeError();
      var res = [];
      var thisp = arguments[1];
      for (var i = 0; i < len; i++) {
        var val = t._getter(i); // in case fun mutates this
        if (callbackfn.call(thisp, val, i, t))
          res.push(val);
      }
      return new this.constructor(res);
    }});

    // %TypedArray%.prototype.find (predicate, thisArg = undefined)
    Object.defineProperty($TypedArray$.prototype, 'find', {value: function(predicate) {
      var o = ToObject(this);
      var lenValue = o.length;
      var len = ToUint32(lenValue);
      if (!IsCallable(predicate)) throw TypeError();
      var t = arguments.length > 1 ? arguments[1] : undefined;
      var k = 0;
      while (k < len) {
        var kValue = o._getter(k);
        var testResult = predicate.call(t, kValue, k, o);
        if (Boolean(testResult))
          return kValue;
        ++k;
      }
      return undefined;
    }});

    // %TypedArray%.prototype.findIndex ( predicate, thisArg = undefined )
    Object.defineProperty($TypedArray$.prototype, 'findIndex', {value: function(predicate) {
      var o = ToObject(this);
      var lenValue = o.length;
      var len = ToUint32(lenValue);
      if (!IsCallable(predicate)) throw TypeError();
      var t = arguments.length > 1 ? arguments[1] : undefined;
      var k = 0;
      while (k < len) {
        var kValue = o._getter(k);
        var testResult = predicate.call(t, kValue, k, o);
        if (Boolean(testResult))
          return k;
        ++k;
      }
      return -1;
    }});

    // %TypedArray%.prototype.forEach ( callbackfn, thisArg = undefined )
    Object.defineProperty($TypedArray$.prototype, 'forEach', {value: function(callbackfn) {
      if (this === undefined || this === null) throw TypeError();
      var t = Object(this);
      var len = ToUint32(t.length);
      if (!IsCallable(callbackfn)) throw TypeError();
      var thisp = arguments[1];
      for (var i = 0; i < len; i++)
        callbackfn.call(thisp, t._getter(i), i, t);
    }});

    // %TypedArray%.prototype.indexOf (searchElement, fromIndex = 0 )
    Object.defineProperty($TypedArray$.prototype, 'indexOf', {value: function(searchElement) {
      if (this === undefined || this === null) throw TypeError();
      var t = Object(this);
      var len = ToUint32(t.length);
      if (len === 0) return -1;
      var n = 0;
      if (arguments.length > 0) {
        n = Number(arguments[1]);
        if (n !== n) {
          n = 0;
        } else if (n !== 0 && n !== (1 / 0) && n !== -(1 / 0)) {
          n = (n > 0 || -1) * floor(abs(n));
        }
      }
      if (n >= len) return -1;
      var k = n >= 0 ? n : max(len - abs(n), 0);
      for (; k < len; k++) {
        if (t._getter(k) === searchElement) {
          return k;
        }
      }
      return -1;
    }});

    // %TypedArray%.prototype.join ( separator )
    Object.defineProperty($TypedArray$.prototype, 'join', {value: function(separator) {
      if (this === undefined || this === null) throw TypeError();
      var t = Object(this);
      var len = ToUint32(t.length);
      var tmp = Array(len);
      for (var i = 0; i < len; ++i)
        tmp[i] = t._getter(i);
      return tmp.join(separator === undefined ? ',' : separator); // Hack for IE7
    }});

    // %TypedArray%.prototype.keys ( )
    // -- defined in es6.js to shim browsers w/ native TypedArrays

    // %TypedArray%.prototype.lastIndexOf ( searchElement, fromIndex = this.length-1 )
    Object.defineProperty($TypedArray$.prototype, 'lastIndexOf', {value: function(searchElement) {
      if (this === undefined || this === null) throw TypeError();
      var t = Object(this);
      var len = ToUint32(t.length);
      if (len === 0) return -1;
      var n = len;
      if (arguments.length > 1) {
        n = Number(arguments[1]);
        if (n !== n) {
          n = 0;
        } else if (n !== 0 && n !== (1 / 0) && n !== -(1 / 0)) {
          n = (n > 0 || -1) * floor(abs(n));
        }
      }
      var k = n >= 0 ? min(n, len - 1) : len - abs(n);
      for (; k >= 0; k--) {
        if (t._getter(k) === searchElement)
          return k;
      }
      return -1;
    }});

    // get %TypedArray%.prototype.length
    // -- applied directly to the object in the constructor

    // %TypedArray%.prototype.map ( callbackfn, thisArg = undefined )
    Object.defineProperty($TypedArray$.prototype, 'map', {value: function(callbackfn) {
      if (this === undefined || this === null) throw TypeError();
      var t = Object(this);
      var len = ToUint32(t.length);
      if (!IsCallable(callbackfn)) throw TypeError();
      var res = []; res.length = len;
      var thisp = arguments[1];
      for (var i = 0; i < len; i++)
        res[i] = callbackfn.call(thisp, t._getter(i), i, t);
      return new this.constructor(res);
    }});

    // %TypedArray%.prototype.reduce ( callbackfn [, initialValue] )
    Object.defineProperty($TypedArray$.prototype, 'reduce', {value: function(callbackfn) {
      if (this === undefined || this === null) throw TypeError();
      var t = Object(this);
      var len = ToUint32(t.length);
      if (!IsCallable(callbackfn)) throw TypeError();
      // no value to return if no initial value and an empty array
      if (len === 0 && arguments.length === 1) throw TypeError();
      var k = 0;
      var accumulator;
      if (arguments.length >= 2) {
        accumulator = arguments[1];
      } else {
        accumulator = t._getter(k++);
      }
      while (k < len) {
        accumulator = callbackfn.call(undefined, accumulator, t._getter(k), k, t);
        k++;
      }
      return accumulator;
    }});

    // %TypedArray%.prototype.reduceRight ( callbackfn [, initialValue] )
    Object.defineProperty($TypedArray$.prototype, 'reduceRight', {value: function(callbackfn) {
      if (this === undefined || this === null) throw TypeError();
      var t = Object(this);
      var len = ToUint32(t.length);
      if (!IsCallable(callbackfn)) throw TypeError();
      // no value to return if no initial value, empty array
      if (len === 0 && arguments.length === 1) throw TypeError();
      var k = len - 1;
      var accumulator;
      if (arguments.length >= 2) {
        accumulator = arguments[1];
      } else {
        accumulator = t._getter(k--);
      }
      while (k >= 0) {
        accumulator = callbackfn.call(undefined, accumulator, t._getter(k), k, t);
        k--;
      }
      return accumulator;
    }});

    // %TypedArray%.prototype.reverse ( )
    Object.defineProperty($TypedArray$.prototype, 'reverse', {value: function() {
      if (this === undefined || this === null) throw TypeError();
      var t = Object(this);
      var len = ToUint32(t.length);
      var half = floor(len / 2);
      for (var i = 0, j = len - 1; i < half; ++i, --j) {
        var tmp = t._getter(i);
        t._setter(i, t._getter(j));
        t._setter(j, tmp);
      }
      return t;
    }});

    // %TypedArray%.prototype.set(array, offset = 0 )
    // %TypedArray%.prototype.set(typedArray, offset = 0 )
    // WebIDL: void set(TypedArray array, optional unsigned long offset);
    // WebIDL: void set(sequence<type> array, optional unsigned long offset);
    Object.defineProperty($TypedArray$.prototype, 'set', {value: function(index, value) {
      if (arguments.length < 1) throw SyntaxError('Not enough arguments');
      var array, sequence, offset, len,
          i, s, d,
          byteOffset, byteLength, tmp;

      if (typeof arguments[0] === 'object' && arguments[0].constructor === this.constructor) {
        // void set(TypedArray array, optional unsigned long offset);
        array = arguments[0];
        offset = ToUint32(arguments[1]);

        if (offset + array.length > this.length) {
          throw RangeError('Offset plus length of array is out of range');
        }

        byteOffset = this.byteOffset + offset * this.BYTES_PER_ELEMENT;
        byteLength = array.length * this.BYTES_PER_ELEMENT;

        if (array.buffer === this.buffer) {
          tmp = [];
          for (i = 0, s = array.byteOffset; i < byteLength; i += 1, s += 1) {
            tmp[i] = array.buffer._bytes[s];
          }
          for (i = 0, d = byteOffset; i < byteLength; i += 1, d += 1) {
            this.buffer._bytes[d] = tmp[i];
          }
        } else {
          for (i = 0, s = array.byteOffset, d = byteOffset;
               i < byteLength; i += 1, s += 1, d += 1) {
            this.buffer._bytes[d] = array.buffer._bytes[s];
          }
        }
      } else if (typeof arguments[0] === 'object' && typeof arguments[0].length !== 'undefined') {
        // void set(sequence<type> array, optional unsigned long offset);
        sequence = arguments[0];
        len = ToUint32(sequence.length);
        offset = ToUint32(arguments[1]);

        if (offset + len > this.length) {
          throw RangeError('Offset plus length of array is out of range');
        }

        for (i = 0; i < len; i += 1) {
          s = sequence[i];
          this._setter(offset + i, Number(s));
        }
      } else {
        throw TypeError('Unexpected argument type(s)');
      }
    }});

    // %TypedArray%.prototype.slice ( start, end )
    Object.defineProperty($TypedArray$.prototype, 'slice', {value: function(start, end) {
      var o = ToObject(this);
      var lenVal = o.length;
      var len = ToUint32(lenVal);
      var relativeStart = ToInt32(start);
      var k = (relativeStart < 0) ? max(len + relativeStart, 0) : min(relativeStart, len);
      var relativeEnd = (end === undefined) ? len : ToInt32(end);
      var final = (relativeEnd < 0) ? max(len + relativeEnd, 0) : min(relativeEnd, len);
      var count = final - k;
      var c = o.constructor;
      var a = new c(count);
      var n = 0;
      while (k < final) {
        var kValue = o._getter(k);
        a._setter(n, kValue);
        ++k;
        ++n;
      }
      return a;
    }});

    // %TypedArray%.prototype.some ( callbackfn, thisArg = undefined )
    Object.defineProperty($TypedArray$.prototype, 'some', {value: function(callbackfn) {
      if (this === undefined || this === null) throw TypeError();
      var t = Object(this);
      var len = ToUint32(t.length);
      if (!IsCallable(callbackfn)) throw TypeError();
      var thisp = arguments[1];
      for (var i = 0; i < len; i++) {
        if (callbackfn.call(thisp, t._getter(i), i, t)) {
          return true;
        }
      }
      return false;
    }});

    // %TypedArray%.prototype.sort ( comparefn )
    Object.defineProperty($TypedArray$.prototype, 'sort', {value: function(comparefn) {
      if (this === undefined || this === null) throw TypeError();
      var t = Object(this);
      var len = ToUint32(t.length);
      var tmp = Array(len);
      for (var i = 0; i < len; ++i)
        tmp[i] = t._getter(i);
      function sortCompare(x, y) {
        if (x !== x && y !== y) return +0;
        if (x !== x) return 1;
        if (y !== y) return -1;
        if (comparefn !== undefined) {
          return comparefn(x, y);
        }
        if (x < y) return -1;
        if (x > y) return 1;
        return +0;
      }
      tmp.sort(sortCompare);
      for (i = 0; i < len; ++i)
        t._setter(i, tmp[i]);
      return t;
    }});

    // %TypedArray%.prototype.subarray(begin = 0, end = this.length )
    // WebIDL: TypedArray subarray(long begin, optional long end);
    Object.defineProperty($TypedArray$.prototype, 'subarray', {value: function(start, end) {
      function clamp(v, min, max) { return v < min ? min : v > max ? max : v; }

      start = ToInt32(start);
      end = ToInt32(end);

      if (arguments.length < 1) { start = 0; }
      if (arguments.length < 2) { end = this.length; }

      if (start < 0) { start = this.length + start; }
      if (end < 0) { end = this.length + end; }

      start = clamp(start, 0, this.length);
      end = clamp(end, 0, this.length);

      var len = end - start;
      if (len < 0) {
        len = 0;
      }

      return new this.constructor(
        this.buffer, this.byteOffset + start * this.BYTES_PER_ELEMENT, len);
    }});

    // %TypedArray%.prototype.toLocaleString ( )
    // %TypedArray%.prototype.toString ( )
    // %TypedArray%.prototype.values ( )
    // %TypedArray%.prototype [ @@iterator ] ( )
    // get %TypedArray%.prototype [ @@toStringTag ]
    // -- defined in es6.js to shim browsers w/ native TypedArrays

    function makeTypedArray(elementSize, pack, unpack) {
      // Each TypedArray type requires a distinct constructor instance with
      // identical logic, which this produces.
      var TypedArray = function() {
        Object.defineProperty(this, 'constructor', {value: TypedArray});
        $TypedArray$.apply(this, arguments);
        makeArrayAccessors(this);
      };
      if ('__proto__' in TypedArray) {
        TypedArray.__proto__ = $TypedArray$;
      } else {
        TypedArray.from = $TypedArray$.from;
        TypedArray.of = $TypedArray$.of;
      }

      TypedArray.BYTES_PER_ELEMENT = elementSize;

      var TypedArrayPrototype = function() {};
      TypedArrayPrototype.prototype = $TypedArrayPrototype$;

      TypedArray.prototype = new TypedArrayPrototype();

      Object.defineProperty(TypedArray.prototype, 'BYTES_PER_ELEMENT', {value: elementSize});
      Object.defineProperty(TypedArray.prototype, '_pack', {value: pack});
      Object.defineProperty(TypedArray.prototype, '_unpack', {value: unpack});

      return TypedArray;
    }

    var Int8Array = makeTypedArray(1, packI8, unpackI8);
    var Uint8Array = makeTypedArray(1, packU8, unpackU8);
    var Uint8ClampedArray = makeTypedArray(1, packU8Clamped, unpackU8);
    var Int16Array = makeTypedArray(2, packI16, unpackI16);
    var Uint16Array = makeTypedArray(2, packU16, unpackU16);
    var Int32Array = makeTypedArray(4, packI32, unpackI32);
    var Uint32Array = makeTypedArray(4, packU32, unpackU32);
    var Float32Array = makeTypedArray(4, packF32, unpackF32);
    var Float64Array = makeTypedArray(8, packF64, unpackF64);

    global.Int8Array = global.Int8Array || Int8Array;
    global.Uint8Array = global.Uint8Array || Uint8Array;
    global.Uint8ClampedArray = global.Uint8ClampedArray || Uint8ClampedArray;
    global.Int16Array = global.Int16Array || Int16Array;
    global.Uint16Array = global.Uint16Array || Uint16Array;
    global.Int32Array = global.Int32Array || Int32Array;
    global.Uint32Array = global.Uint32Array || Uint32Array;
    global.Float32Array = global.Float32Array || Float32Array;
    global.Float64Array = global.Float64Array || Float64Array;
  }());

  //
  // 6 The DataView View Type
  //

  (function() {
    function r(array, index) {
      return IsCallable(array.get) ? array.get(index) : array[index];
    }

    var IS_BIG_ENDIAN = (function() {
      var u16array = new Uint16Array([0x1234]),
          u8array = new Uint8Array(u16array.buffer);
      return r(u8array, 0) === 0x12;
    }());

    // DataView(buffer, byteOffset=0, byteLength=undefined)
    // WebIDL: Constructor(ArrayBuffer buffer,
    //                     optional unsigned long byteOffset,
    //                     optional unsigned long byteLength)
    function DataView(buffer, byteOffset, byteLength) {
      if (!(buffer instanceof ArrayBuffer || Class(buffer) === 'ArrayBuffer')) throw TypeError();

      byteOffset = ToUint32(byteOffset);
      if (byteOffset > buffer.byteLength)
        throw RangeError('byteOffset out of range');

      if (byteLength === undefined)
        byteLength = buffer.byteLength - byteOffset;
      else
        byteLength = ToUint32(byteLength);

      if ((byteOffset + byteLength) > buffer.byteLength)
        throw RangeError('byteOffset and length reference an area beyond the end of the buffer');

      Object.defineProperty(this, 'buffer', {value: buffer});
      Object.defineProperty(this, 'byteLength', {value: byteLength});
      Object.defineProperty(this, 'byteOffset', {value: byteOffset});
    };

    // get DataView.prototype.buffer
    // get DataView.prototype.byteLength
    // get DataView.prototype.byteOffset
    // -- applied directly to instances by the constructor

    function makeGetter(arrayType) {
      return function GetViewValue(byteOffset, littleEndian) {
        byteOffset = ToUint32(byteOffset);

        if (byteOffset + arrayType.BYTES_PER_ELEMENT > this.byteLength)
          throw RangeError('Array index out of range');

        byteOffset += this.byteOffset;

        var uint8Array = new Uint8Array(this.buffer, byteOffset, arrayType.BYTES_PER_ELEMENT),
            bytes = [];
        for (var i = 0; i < arrayType.BYTES_PER_ELEMENT; i += 1)
          bytes.push(r(uint8Array, i));

        if (Boolean(littleEndian) === Boolean(IS_BIG_ENDIAN))
          bytes.reverse();

        return r(new arrayType(new Uint8Array(bytes).buffer), 0);
      };
    }

    Object.defineProperty(DataView.prototype, 'getUint8', {value: makeGetter(Uint8Array)});
    Object.defineProperty(DataView.prototype, 'getInt8', {value: makeGetter(Int8Array)});
    Object.defineProperty(DataView.prototype, 'getUint16', {value: makeGetter(Uint16Array)});
    Object.defineProperty(DataView.prototype, 'getInt16', {value: makeGetter(Int16Array)});
    Object.defineProperty(DataView.prototype, 'getUint32', {value: makeGetter(Uint32Array)});
    Object.defineProperty(DataView.prototype, 'getInt32', {value: makeGetter(Int32Array)});
    Object.defineProperty(DataView.prototype, 'getFloat32', {value: makeGetter(Float32Array)});
    Object.defineProperty(DataView.prototype, 'getFloat64', {value: makeGetter(Float64Array)});

    function makeSetter(arrayType) {
      return function SetViewValue(byteOffset, value, littleEndian) {
        byteOffset = ToUint32(byteOffset);
        if (byteOffset + arrayType.BYTES_PER_ELEMENT > this.byteLength)
          throw RangeError('Array index out of range');

        // Get bytes
        var typeArray = new arrayType([value]),
            byteArray = new Uint8Array(typeArray.buffer),
            bytes = [], i, byteView;

        for (i = 0; i < arrayType.BYTES_PER_ELEMENT; i += 1)
          bytes.push(r(byteArray, i));

        // Flip if necessary
        if (Boolean(littleEndian) === Boolean(IS_BIG_ENDIAN))
          bytes.reverse();

        // Write them
        byteView = new Uint8Array(this.buffer, byteOffset, arrayType.BYTES_PER_ELEMENT);
        byteView.set(bytes);
      };
    }

    Object.defineProperty(DataView.prototype, 'setUint8', {value: makeSetter(Uint8Array)});
    Object.defineProperty(DataView.prototype, 'setInt8', {value: makeSetter(Int8Array)});
    Object.defineProperty(DataView.prototype, 'setUint16', {value: makeSetter(Uint16Array)});
    Object.defineProperty(DataView.prototype, 'setInt16', {value: makeSetter(Int16Array)});
    Object.defineProperty(DataView.prototype, 'setUint32', {value: makeSetter(Uint32Array)});
    Object.defineProperty(DataView.prototype, 'setInt32', {value: makeSetter(Int32Array)});
    Object.defineProperty(DataView.prototype, 'setFloat32', {value: makeSetter(Float32Array)});
    Object.defineProperty(DataView.prototype, 'setFloat64', {value: makeSetter(Float64Array)});

    global.DataView = global.DataView || DataView;

  }());

}(self));
if (!("defineProperty"in Object&&function(){try{var e={}
return Object.defineProperty(e,"test",{value:42}),!0}catch(t){return!1}}()
)) {

// Object.defineProperty
(function (nativeDefineProperty) {

        var supportsAccessors = Object.prototype.hasOwnProperty('__defineGetter__');
        var ERR_ACCESSORS_NOT_SUPPORTED = 'Getters & setters cannot be defined on this javascript engine';
        var ERR_VALUE_ACCESSORS = 'A property cannot both have accessors and be writable or have a value';

        // Polyfill.io - This does not use CreateMethodProperty because our CreateMethodProperty function uses Object.defineProperty.
        Object['defineProperty'] = function defineProperty(object, property, descriptor) {

                // Where native support exists, assume it
                if (nativeDefineProperty && (object === window || object === document || object === Element.prototype || object instanceof Element)) {
                        return nativeDefineProperty(object, property, descriptor);
                }

                if (object === null || !(object instanceof Object || typeof object === 'object')) {
                        throw new TypeError('Object.defineProperty called on non-object');
                }

                if (!(descriptor instanceof Object)) {
                        throw new TypeError('Property description must be an object');
                }

                var propertyString = String(property);
                var hasValueOrWritable = 'value' in descriptor || 'writable' in descriptor;
                var getterType = 'get' in descriptor && typeof descriptor.get;
                var setterType = 'set' in descriptor && typeof descriptor.set;

                // handle descriptor.get
                if (getterType) {
                        if (getterType !== 'function') {
                                throw new TypeError('Getter must be a function');
                        }
                        if (!supportsAccessors) {
                                throw new TypeError(ERR_ACCESSORS_NOT_SUPPORTED);
                        }
                        if (hasValueOrWritable) {
                                throw new TypeError(ERR_VALUE_ACCESSORS);
                        }
                        Object.__defineGetter__.call(object, propertyString, descriptor.get);
                } else {
                        object[propertyString] = descriptor.value;
                }

                // handle descriptor.set
                if (setterType) {
                        if (setterType !== 'function') {
                                throw new TypeError('Setter must be a function');
                        }
                        if (!supportsAccessors) {
                                throw new TypeError(ERR_ACCESSORS_NOT_SUPPORTED);
                        }
                        if (hasValueOrWritable) {
                                throw new TypeError(ERR_VALUE_ACCESSORS);
                        }
                        Object.__defineSetter__.call(object, propertyString, descriptor.set);
                }

                // OK to define value unconditionally - if a getter has been specified as well, an error would be thrown above
                if ('value' in descriptor) {
                        object[propertyString] = descriptor.value;
                }

                return object;
        };
}(Object.defineProperty));

}


// _ESAbstract.CreateDataProperty
// 7.3.4. CreateDataProperty ( O, P, V )
// NOTE
// This abstract operation creates a property whose attributes are set to the same defaults used for properties created by the ECMAScript language assignment operator.
// Normally, the property will not already exist. If it does exist and is not configurable or if O is not extensible, [[DefineOwnProperty]] will return false.
function CreateDataProperty(O, P, V) { // eslint-disable-line no-unused-vars
        // 1. Assert: Type(O) is Object.
        // 2. Assert: IsPropertyKey(P) is true.
        // 3. Let newDesc be the PropertyDescriptor{ [[Value]]: V, [[Writable]]: true, [[Enumerable]]: true, [[Configurable]]: true }.
        var newDesc = {
                value: V,
                writable: true,
                enumerable: true,
                configurable: true
        };
        // 4. Return ? O.[[DefineOwnProperty]](P, newDesc).
        try {
                Object.defineProperty(O, P, newDesc);
                return true;
        } catch (e) {
                return false;
        }
}

// _ESAbstract.CreateDataPropertyOrThrow
/* global CreateDataProperty */
// 7.3.6. CreateDataPropertyOrThrow ( O, P, V )
function CreateDataPropertyOrThrow(O, P, V) { // eslint-disable-line no-unused-vars
        // 1. Assert: Type(O) is Object.
        // 2. Assert: IsPropertyKey(P) is true.
        // 3. Let success be ? CreateDataProperty(O, P, V).
        var success = CreateDataProperty(O, P, V);
        // 4. If success is false, throw a TypeError exception.
        if (!success) {
                throw new TypeError('Cannot assign value `' + Object.prototype.toString.call(V) + '` to property `' + Object.prototype.toString.call(P) + '` on object `' + Object.prototype.toString.call(O) + '`');
        }
        // 5. Return success.
        return success;
}

// _ESAbstract.CreateIterResultObject
/* global Type, CreateDataProperty */
// 7.4.7. CreateIterResultObject ( value, done )
function CreateIterResultObject(value, done) { // eslint-disable-line no-unused-vars
        // 1. Assert: Type(done) is Boolean.
        if (Type(done) !== 'boolean') {
                throw new Error();
        }
        // 2. Let obj be ObjectCreate(%ObjectPrototype%).
        var obj = {};
        // 3. Perform CreateDataProperty(obj, "value", value).
        CreateDataProperty(obj, "value", value);
        // 4. Perform CreateDataProperty(obj, "done", done).
        CreateDataProperty(obj, "done", done);
        // 5. Return obj.
        return obj;
}

// _ESAbstract.CreateMethodProperty
// 7.3.5. CreateMethodProperty ( O, P, V )
function CreateMethodProperty(O, P, V) { // eslint-disable-line no-unused-vars
        // 1. Assert: Type(O) is Object.
        // 2. Assert: IsPropertyKey(P) is true.
        // 3. Let newDesc be the PropertyDescriptor{[[Value]]: V, [[Writable]]: true, [[Enumerable]]: false, [[Configurable]]: true}.
        var newDesc = {
                value: V,
                writable: true,
                enumerable: false,
                configurable: true
        };
        // 4. Return ? O.[[DefineOwnProperty]](P, newDesc).
        Object.defineProperty(O, P, newDesc);
}
if (!("isArray"in Array
)) {

// Array.isArray
/* global CreateMethodProperty, IsArray */
// 22.1.2.2. Array.isArray ( arg )
CreateMethodProperty(Array, 'isArray', function isArray(arg) {
        // 1. Return ? IsArray(arg).
        return IsArray(arg);
});

}

if (!("copyWithin"in Array.prototype&&function(){try{var t=function n(){}
t.prototype[0]="foo"
var o=new t
o[1]=1,o[2]=2,o.length=3
var r=Array.prototype.copyWithin.call(o,1,0)
return!(!r[0]||Object.prototype.hasOwnProperty.call(r,"0")||!Object.prototype.hasOwnProperty.call(r,"1")||"foo"!==r[0]||"foo"!==r[1]||1!==r[2]||3!==r.length)}catch(e){return!1}}()
)) {

// Array.prototype.copyWithin
/* global CreateMethodProperty, HasProperty, ToInteger */
// 22.1.3.3 Array.prototype.copyWithin ( target, start [ , end ] )
CreateMethodProperty(Array.prototype, 'copyWithin', function copyWithin(target, start /* [ , end ] */ ) {
        'use strict';
        var end = arguments[2];

        // 22.1.3.3.1 Let O be ? ToObject(this value).
        if (this === null || this === undefined) {
                throw new TypeError('Cannot call method on ' + this);
        }

        var o = Object(this);

        // 22.1.3.3.2 Let len be ? ToLength(? Get(O, "length")).
        var len = ToInteger(o.length);
        if (len <= 0) {
                len = 0;
        }
        if (len === Infinity) {
                len = Math.pow(2, 53) - 1;
        } else {
                len = Math.min(len, Math.pow(2, 53) - 1);
        }
        len = Math.max(len, 0);

        // 22.1.3.3.3 Let relativeTarget be ? ToInteger(target).
        var relativeTarget = ToInteger(target);

        // 22.1.3.3.4 If relativeTarget < 0, let to be max((len + relativeTarget), 0); else let to be min(relativeTarget, len).
        var to;
        if (relativeTarget < 0) {
                to = Math.max(len + relativeTarget, 0);
        } else {
                to = Math.min(relativeTarget, len);
        }

        // 22.1.3.3.5 Let relativeStart be ? ToInteger(start).
        var relativeStart = ToInteger(start);

        // 22.1.3.3.6 If relativeStart < 0, let from be max((len + relativeStart), 0); else let from be min(relativeStart, len).
        var from;
        if (relativeStart < 0) {
                from = Math.max(len + relativeStart, 0);
        } else {
                from = Math.min(relativeStart, len);
        }

        // 22.1.3.3.7 If end is undefined, let relativeEnd be len; else let relativeEnd be ? ToInteger(end).
        var relativeEnd;
        if (end === undefined) {
                relativeEnd = len;
        } else {
                relativeEnd = ToInteger(end);
        }

        // 22.1.3.3.8 If relativeEnd < 0, let final be max((len + relativeEnd), 0); else let final be min(relativeEnd, len).
        var final;
        if (relativeEnd < 0) {
                final = Math.max(len + relativeEnd, 0);
        } else {
                final = Math.min(relativeEnd, len);
        }

        // 22.1.3.3.9 Let count be min(final-from, len-to).
        var count = Math.min(final - from, len - to);

        // 22.1.3.3.10 If from<to and to<from+count, then
        var direction;
        if (from < to && to < from + count) {
                // 22.1.3.3.10.a Let direction be -1.
                direction = -1;

                // 22.1.3.3.10.b Let from be from + count - 1.
                from = from + count - 1;

                // 22.1.3.3.10.c Let to be to + count - 1.
                to = to + count - 1;
        } else {
                // 22.1.3.3.11 Else,
                // 22.1.3.3.11.a Let direction be 1.
                direction = 1;
        }

        // 22.1.3.3.12 Repeat, while count > 0
        while (count > 0) {
                // 22.1.3.3.12.a Let fromKey be ! ToString(from).
                var fromKey = String(from);
                // 22.1.3.3.12.b Let toKey be ! ToString(to).
                var toKey = String(to);
                // 22.1.3.3.12.c Let fromPresent be ? HasProperty(O, fromKey).
                var fromPresent = HasProperty(o, fromKey);
                // 22.1.3.3.12.d If fromPresent is true, then
                if (fromPresent) {
                        // 22.1.3.3.12.d.i Let fromVal be ? Get(O, fromKey).
                        var fromVal = o[fromKey];
                        // 22.1.3.3.12.d.ii Perform ? Set(O, toKey, fromVal, true).
                        o[toKey] = fromVal;
                } else {
                        // 22.1.3.3.12.e Else fromPresent is false,
                        // 22.1.3.3.12.e.i Perform ? DeletePropertyOrThrow(O, toKey).
                        delete o[toKey];
                }
                // 22.1.3.3.12.f Let from be from + direction.
                from = from + direction;
                // 22.1.3.3.12.g Let to be to + direction.
                to = to + direction;
                // 22.1.3.3.12.h Let count be count - 1.
                count = count - 1;
        }
        // 22.1.3.3.13 Return O.
        return o;
});

}

if (!("fill"in Array.prototype
)) {

// Array.prototype.fill
/* global CreateMethodProperty, Get, ToInteger, ToLength, ToObject, ToString */
// 22.1.3.6. Array.prototype.fill ( value [ , start [ , end ] ] )
CreateMethodProperty(Array.prototype, 'fill', function fill(value /* [ , start [ , end ] ] */) {
        var start = arguments[1];
        var end = arguments[2];
        // 1. Let O be ? ToObject(this value).
        var O = ToObject(this);
        // 2. Let len be ? ToLength(? Get(O, "length")).
        var len = ToLength(Get(O, "length"));
        // 3. Let relativeStart be ? ToInteger(start).
        var relativeStart = ToInteger(start);
        // 4. If relativeStart < 0, let k be max((len + relativeStart), 0); else let k be min(relativeStart, len)
        var k = relativeStart < 0 ? Math.max((len + relativeStart), 0) : Math.min(relativeStart, len);
        // 5. If end is undefined, let relativeEnd be len; else let relativeEnd be ? ToInteger(end).
        var relativeEnd = end === undefined ? len : ToInteger(end);
        // 6. If relativeEnd < 0, let final be max((len + relativeEnd), 0); else let final be min(relativeEnd, len).
        var final = relativeEnd < 0 ? Math.max((len + relativeEnd), 0) : Math.min(relativeEnd, len);
        // 7. Repeat, while k < final
        while (k < final) {
                // a. Let Pk be ! ToString(k).
                var Pk = ToString(k);
                // b. Perform ? Set(O, Pk, value, true).
                O[Pk] = value;
                // c. Increase k by 1.
                k = k + 1;
        }
        // 8. Return O.
        return O;
});

}

if (!("find"in Array.prototype
)) {

// Array.prototype.find
/* global Call, CreateMethodProperty, Get, IsCallable, ToBoolean, ToLength, ToObject, ToString */
// 22.1.3.8 Array.prototype.find ( predicate [ , thisArg ] )
CreateMethodProperty(Array.prototype, 'find', function find( predicate /* [ , thisArg ] */) {
        // 1. Let O be ? ToObject(this value).
        var O = ToObject(this);
        // 2. Let len be ? ToLength(? Get(O, "length")).
        var len = ToLength(Get(O, "length"));
        // 3. If IsCallable(predicate) is false, throw a TypeError exception.
        if (IsCallable(predicate) === false) {
                throw new TypeError(predicate + ' is not a function');
        }
        // 4. If thisArg is present, let T be thisArg; else let T be undefined.
        var T = arguments.length > 1 ? arguments[1] : undefined;
        // 5. Let k be 0.
        var k = 0;
        // 6. Repeat, while k < len
        while (k < len) {
                // a. Let Pk be ! ToString(k).
                var Pk = ToString(k);
                // b. Let kValue be ? Get(O, Pk).
                var kValue = Get(O, Pk);
                // c. Let testResult be ToBoolean(? Call(predicate, T, « kValue, k, O »)).
                var testResult = ToBoolean(Call(predicate, T, [kValue, k, O ]));
                // d. If testResult is true, return kValue.
                if (testResult) {
                        return kValue;
                }
                // e. Increase k by 1.
                var k = k + 1;
        }
        // 7. Return undefined.
        return undefined;
});

}

if (!("findIndex"in Array.prototype
)) {

// Array.prototype.findIndex
/* global Call, CreateMethodProperty, Get, IsCallable, ToBoolean, ToLength, ToObject, ToString */
// 22.1.3.9. Array.prototype.findIndex ( predicate [ , thisArg ] )
CreateMethodProperty(Array.prototype, 'findIndex', function findIndex(predicate /* [ , thisArg ] */) {
        // 1. Let O be ? ToObject(this value).
        var O = ToObject(this);
        // 2. Let len be ? ToLength(? Get(O, "length")).
        var len = ToLength(Get(O, "length"));
        // 3. If IsCallable(predicate) is false, throw a TypeError exception.
        if (IsCallable(predicate) === false) {
                throw new TypeError(predicate + ' is not a function');
        }
        // 4. If thisArg is present, let T be thisArg; else let T be undefined.
        var T = arguments.length > 1 ? arguments[1] : undefined;
        // 5. Let k be 0.
        var k = 0;
        // 6. Repeat, while k < len
        while (k < len) {
                // a. Let Pk be ! ToString(k).
                var Pk = ToString(k);
                // b. Let kValue be ? Get(O, Pk).
                var kValue = Get(O, Pk);
                // c. Let testResult be ToBoolean(? Call(predicate, T, « kValue, k, O »)).
                var testResult = ToBoolean(Call(predicate, T, [kValue, k, O]));
                // d. If testResult is true, return k.
                if (testResult) {
                        return k;
                }
                // e. Increase k by 1.
                k = k + 1;
        }
        // 7. Return -1.
        return -1;
});

}

if (!("forEach"in Array.prototype
)) {

// Array.prototype.forEach
/* global Call, CreateMethodProperty, Get, HasProperty, IsCallable, ToLength, ToObject, ToString */
// 22.1.3.10. Array.prototype.forEach ( callbackfn [ , thisArg ] )
CreateMethodProperty(Array.prototype, 'forEach', function forEach(callbackfn /* [ , thisArg ] */) {
        // 1. Let O be ? ToObject(this value).
        var O = ToObject(this);
        // Polyfill.io - If O is a String object, split it into an array in order to iterate correctly.
        // We will use arrayLike in place of O when we are iterating through the list.
        var arraylike = O instanceof String ? O.split('') : O;
        // 2. Let len be ? ToLength(? Get(O, "length")).
        var len = ToLength(Get(O, "length"));
        // 3. If IsCallable(callbackfn) is false, throw a TypeError exception.
        if (IsCallable(callbackfn) === false) {
                throw new TypeError(callbackfn + ' is not a function');
        }
        // 4. If thisArg is present, let T be thisArg; else let T be undefined.
        var T = arguments.length > 1 ? arguments[1] : undefined;
        // 5. Let k be 0.
        var k = 0;
        // 6. Repeat, while k < len
        while (k < len) {
                // a. Let Pk be ! ToString(k).
                var Pk = ToString(k);
                // b. Let kPresent be ? HasProperty(O, Pk).
                var kPresent = HasProperty(arraylike, Pk);
                // c. If kPresent is true, then
                if (kPresent) {
                        // i. Let kValue be ? Get(O, Pk).
                        var kValue = Get(arraylike, Pk);
                        // ii. Perform ? Call(callbackfn, T, « kValue, k, O »).
                        Call(callbackfn, T, [kValue, k, O]);
                }
                // d. Increase k by 1.
                k = k + 1;
        }
        // 7. Return undefined.
        return undefined;
});

}

if (!("bind"in Function.prototype
)) {

// Function.prototype.bind
/* global CreateMethodProperty, IsCallable */
// 19.2.3.2. Function.prototype.bind ( thisArg, ...args )
// https://github.com/es-shims/es5-shim/blob/d6d7ff1b131c7ba14c798cafc598bb6780d37d3b/es5-shim.js#L182
CreateMethodProperty(Function.prototype, 'bind', function bind(that) { // .length is 1
        // add necessary es5-shim utilities
        var $Array = Array;
        var $Object = Object;
        var ArrayPrototype = $Array.prototype;
        var Empty = function Empty() { };
        var array_slice = ArrayPrototype.slice;
        var array_concat = ArrayPrototype.concat;
        var array_push = ArrayPrototype.push;
        var max = Math.max;
        // /add necessary es5-shim utilities

        // 1. Let Target be the this value.
        var target = this;
        // 2. If IsCallable(Target) is false, throw a TypeError exception.
        if (!IsCallable(target)) {
                throw new TypeError('Function.prototype.bind called on incompatible ' + target);
        }
        // 3. Let A be a new (possibly empty) internal list of all of the
        //   argument values provided after thisArg (arg1, arg2 etc), in order.
        // XXX slicedArgs will stand in for "A" if used
        var args = array_slice.call(arguments, 1); // for normal call
        // 4. Let F be a new native ECMAScript object.
        // 11. Set the [[Prototype]] internal property of F to the standard
        //   built-in Function prototype object as specified in 15.3.3.1.
        // 12. Set the [[Call]] internal property of F as described in
        //   15.3.4.5.1.
        // 13. Set the [[Construct]] internal property of F as described in
        //   15.3.4.5.2.
        // 14. Set the [[HasInstance]] internal property of F as described in
        //   15.3.4.5.3.
        var bound;
        var binder = function () {

                if (this instanceof bound) {
                        // 15.3.4.5.2 [[Construct]]
                        // When the [[Construct]] internal method of a function object,
                        // F that was created using the bind function is called with a
                        // list of arguments ExtraArgs, the following steps are taken:
                        // 1. Let target be the value of F's [[TargetFunction]]
                        //   internal property.
                        // 2. If target has no [[Construct]] internal method, a
                        //   TypeError exception is thrown.
                        // 3. Let boundArgs be the value of F's [[BoundArgs]] internal
                        //   property.
                        // 4. Let args be a new list containing the same values as the
                        //   list boundArgs in the same order followed by the same
                        //   values as the list ExtraArgs in the same order.
                        // 5. Return the result of calling the [[Construct]] internal
                        //   method of target providing args as the arguments.

                        var result = target.apply(
                                this,
                                array_concat.call(args, array_slice.call(arguments))
                        );
                        if ($Object(result) === result) {
                                return result;
                        }
                        return this;

                } else {
                        // 15.3.4.5.1 [[Call]]
                        // When the [[Call]] internal method of a function object, F,
                        // which was created using the bind function is called with a
                        // this value and a list of arguments ExtraArgs, the following
                        // steps are taken:
                        // 1. Let boundArgs be the value of F's [[BoundArgs]] internal
                        //   property.
                        // 2. Let boundThis be the value of F's [[BoundThis]] internal
                        //   property.
                        // 3. Let target be the value of F's [[TargetFunction]] internal
                        //   property.
                        // 4. Let args be a new list containing the same values as the
                        //   list boundArgs in the same order followed by the same
                        //   values as the list ExtraArgs in the same order.
                        // 5. Return the result of calling the [[Call]] internal method
                        //   of target providing boundThis as the this value and
                        //   providing args as the arguments.

                        // equiv: target.call(this, ...boundArgs, ...args)
                        return target.apply(
                                that,
                                array_concat.call(args, array_slice.call(arguments))
                        );

                }

        };

        // 15. If the [[Class]] internal property of Target is "Function", then
        //     a. Let L be the length property of Target minus the length of A.
        //     b. Set the length own property of F to either 0 or L, whichever is
        //       larger.
        // 16. Else set the length own property of F to 0.

        var boundLength = max(0, target.length - args.length);

        // 17. Set the attributes of the length own property of F to the values
        //   specified in 15.3.5.1.
        var boundArgs = [];
        for (var i = 0; i < boundLength; i++) {
                array_push.call(boundArgs, '$' + i);
        }

        // XXX Build a dynamic function with desired amount of arguments is the only
        // way to set the length property of a function.
        // In environments where Content Security Policies enabled (Chrome extensions,
        // for ex.) all use of eval or Function costructor throws an exception.
        // However in all of these environments Function.prototype.bind exists
        // and so this code will never be executed.
        bound = Function('binder', 'return function (' + boundArgs.join(',') + '){ return binder.apply(this, arguments); }')(binder);

        if (target.prototype) {
                Empty.prototype = target.prototype;
                bound.prototype = new Empty();
                // Clean up dangling references.
                Empty.prototype = null;
        }

        // TODO
        // 18. Set the [[Extensible]] internal property of F to true.

        // TODO
        // 19. Let thrower be the [[ThrowTypeError]] function Object (13.2.3).
        // 20. Call the [[DefineOwnProperty]] internal method of F with
        //   arguments "caller", PropertyDescriptor {[[Get]]: thrower, [[Set]]:
        //   thrower, [[Enumerable]]: false, [[Configurable]]: false}, and
        //   false.
        // 21. Call the [[DefineOwnProperty]] internal method of F with
        //   arguments "arguments", PropertyDescriptor {[[Get]]: thrower,
        //   [[Set]]: thrower, [[Enumerable]]: false, [[Configurable]]: false},
        //   and false.

        // TODO
        // NOTE Function objects created using Function.prototype.bind do not
        // have a prototype property or the [[Code]], [[FormalParameters]], and
        // [[Scope]] internal properties.
        // XXX can't delete prototype in pure-js.

        // 22. Return F.
        return bound;
});

}

if (!("acosh"in Math
)) {

// Math.acosh
/* global CreateMethodProperty */
// 20.2.2.3. Math.acosh ( x )
CreateMethodProperty(Math, 'acosh', function acosh(x) {
        // If x is NaN, the result is NaN.
        if (isNaN(x)) {
                return NaN;
        }
        // If x is less than 1, the result is NaN.
        if (x < 1) {
                return NaN;
        }
        // If x is 1, the result is +0.
        if (x === 1) {
                return 0;
        }
        // If x is +∞, the result is +∞.
        if (x === Infinity) {
                return Infinity;
        }
        return Math.log(x + Math.sqrt(x * x - 1));
});

}

if (!("asinh"in Math
)) {

// Math.asinh
/* global CreateMethodProperty */
// 20.2.2.5. Math.asinh ( x )
CreateMethodProperty(Math, 'asinh', function asinh(x) {
        // If x is NaN, the result is NaN.
        if (isNaN(x)) {
                return NaN;
        }
        // If x is +0, the result is +0.
        if (x === 0 && 1/x === Infinity) {
                return 0;
        }
        // If x is -0, the result is -0.
        if (x === 0 && 1/x === -Infinity) {
                return -0;
        }
        // If x is +∞, the result is +∞.
        if (x === Infinity) {
                return Infinity;
        }
        // If x is -∞, the result is -∞.
        if (x === -Infinity) {
                return -Infinity;
        }
        return Math.log(x + Math.sqrt(x * x + 1));
});

}

if (!("atanh"in Math
)) {

// Math.atanh
/* global CreateMethodProperty */
// 20.2.2.7. Math.atanh ( x )
CreateMethodProperty(Math, 'atanh', function atanh(x) {
        // If x is NaN, the result is NaN.
        if (isNaN(x)) {
                return NaN;
        }
        // If x is less than -1, the result is NaN.
        if (x < -1) {
                return NaN;
        }
        // If x is greater than 1, the result is NaN.
        if (x > 1) {
                return NaN;
        }
        // If x is -1, the result is -∞.
        if (x === -1) {
                return -Infinity;
        }
        // If x is +1, the result is +∞.
        if (x === 1) {
                return Infinity;
        }
        // If x is +0, the result is +0.
        if (x === 0 && 1/x === Infinity) {
                return 0;
        }
        // If x is -0, the result is -0.
        if (x === 0 && 1/x === -Infinity) {
                return -0;
        }
        return Math.log((1 + x) / (1 - x)) / 2;
});

}

if (!("cbrt"in Math
)) {

// Math.cbrt
/* global CreateMethodProperty */
// 20.2.2.9. Math.cbrt ( x )
CreateMethodProperty(Math, 'cbrt', function cbrt(x) {
        // If x is NaN, the result is NaN.
        if (isNaN(x)) {
                return NaN;
        }
        // If x is +0, the result is +0.
        if (x === 0 && 1/x === Infinity) {
                return 0;
        }
        // If x is -0, the result is -0.
        if (x === 0 && 1/x === -Infinity) {
                return -0;
        }
        // If x is +∞, the result is +∞.
        if (x === Infinity) {
                return Infinity;
        }
        // If x is -∞, the result is -∞.
        if (x === -Infinity) {
                return -Infinity;
        }
        var y = Math.pow(Math.abs(x), 1 / 3);
        return x < 0 ? -y : y;
});

}

if (!("clz32"in Math
)) {

// Math.clz32
/* global CreateMethodProperty, ToUint32 */
// 20.2.2.11. Math.clz32 ( x )
CreateMethodProperty(Math, 'clz32', function clz32(x) {
        // 1. Let n be ToUint32(x).
        var n = ToUint32(x);
        // 2. Let p be the number of leading zero bits in the 32-bit binary representation of n.
        var p = n ? 32 - n.toString(2).length : 32;
        // 3. Return p.
        return p;
});

}

if (!("cosh"in Math
)) {

// Math.cosh
/* global CreateMethodProperty */
// 20.2.2.1. 3Math.cosh ( x )
CreateMethodProperty(Math, 'cosh', function cosh(x) {
        // If x is NaN, the result is NaN.
        if (isNaN(x)) {
                return NaN;
        }
        // If x is +0, the result is 1.
        if (x === 0 && 1/x === Infinity) {
                return 1;
        }
        // If x is -0, the result is 1.
        if (x === 0 && 1/x === -Infinity) {
                return 1;
        }
        // If x is +∞, the result is +∞.
        if (x === Infinity) {
                return Infinity;
        }
        // If x is -∞, the result is +∞.
        if (x === -Infinity) {
                return Infinity;
        }
        x = Math.abs(x);
        if (x > 709) {
                var y = Math.exp(0.5 * x);
                return y / 2 * y;
        }
        var y = Math.exp(x);
        return (y + 1 / y) / 2;
});

}

if (!("expm1"in Math
)) {

// Math.expm1
/* global CreateMethodProperty */
// 20.2.2.15. Math.expm1 ( x )
CreateMethodProperty(Math, 'expm1', function expm1(x) {
        // If x is NaN, the result is NaN.
        if (isNaN(x)) {
                return NaN;
        }
        // If x is +0, the result is +0.
        if (x === 0 && 1/x === Infinity) {
                return 0;
        }
        // If x is -0, the result is -0.
        if (x === 0 && 1/x === -Infinity) {
                return -0;
        }
        // If x is +∞, the result is +∞.
        if (x === Infinity) {
                return Infinity;
        }
        // If x is -∞, the result is -1.
        if (x === -Infinity) {
                return -1;
        }

        if (x > -1e-6 && x < 1e-6) {
                return x + x * x / 2;
        } else {
                return Math.exp(x) - 1;
        }
});

}

if (!("fround"in Math
)) {

// Math.fround
/* global Float32Array, CreateMethodProperty */
// 20.2.2.17 Math.fround ( x )
CreateMethodProperty(Math, 'fround', function (x) {
        // 1. If x is NaN, return NaN.
        if (isNaN(x)) {
                return NaN;
        }
        // 2. If x is one of +0, -0, +∞, -∞, return x.
        if (1 / x === +Infinity || 1 / x === -Infinity || x === +Infinity || x === -Infinity) {
                return x;
        }
        // 3. Let x32 be the result of converting x to a value in IEEE 754-2008 binary32 format using roundTiesToEven.
        // 4. Let x64 be the result of converting x32 to a value in IEEE 754-2008 binary64 format.
        // 5. Return the ECMAScript Number value corresponding to x64.
        return (new Float32Array([x]))[0];
});

}

if (!("hypot"in Math
)) {

// Math.hypot
/* global CreateMethodProperty */
// 20.2.2.18. Math.hypot ( value1, value2, ...values )
CreateMethodProperty(Math, 'hypot', function hypot(value1, value2) { // eslint-disable-line no-unused-vars
        // If no arguments are passed, the result is +0.
        if (arguments.length === 0) {
                return 0;
        }
        var y = 0;
        var max = 0;
        for (var i = 0; i < arguments.length; ++i) {
                // If any argument is +∞, the result is +∞.
                if (arguments[i] === Infinity) {
                        return Infinity;
                }

                // If any argument is -∞, the result is +∞.
                if (arguments[i] === -Infinity) {
                        return Infinity;
                }

                // If no argument is +∞ or -∞, and any argument is NaN, the result is NaN.
                // If all arguments are either +0 or -0, the result is +0.
                // Polyfill.io - The two conditions above are handled in the math.

                var arg = Math.abs(Number(arguments[i]));
                if (arg > max) {
                        y = y * Math.pow(max / arg, 2);
                        max = arg;
                }
                if (arg !== 0 || max !== 0) {
                        y = y + Math.pow(arg / max, 2);
                }
        }

  return max * Math.sqrt(y);
});

}

if (!("imul"in Math
)) {

// Math.imul
/* global CreateMethodProperty, ToUint32 */
// 20.2.2.19. Math.imul ( x, y )
CreateMethodProperty(Math, 'imul', function imul(x, y) {
        // 1. Let a be ToUint32(x).
        var a = ToUint32(x);
        // 2. Let b be ToUint32(y).
        var b = ToUint32(y);
        var UINT16 = 0xffff;
        var aHigh = a >>> 16 & UINT16;
        var aLow = UINT16 & a;
        var bHigh = b >>> 16 & UINT16;
        var bLow = UINT16 & b;
        // the shift by 0 fixes the sign on the high part
        // the final |0 converts the unsigned value into a signed value
        return aLow * bLow + (aHigh * bLow + aLow * bHigh << 16 >>> 0) | 0;
});
}

if (!("log10"in Math
)) {

// Math.log10
/* global CreateMethodProperty */
// 20.2.2.22. Math.log10 ( x )
CreateMethodProperty(Math, 'log10', function log10(x) {
        return Math.log(x) / Math.LN10;
});

}

if (!("log1p"in Math
)) {

// Math.log1p
/* global CreateMethodProperty */
// 20.2.2.21. Math.log1p ( x )
CreateMethodProperty(Math, 'log1p', function log1p(x) {
        x = Number(x);
        if (-1 < x && x < 1) {
                // Polyfill.io - For numbers in the range −1 < x < 1
                // Because we are using log, the precision of the result will be identical to log(1).
                // To fix this we avoid using log and use the Taylor Series expansion of log.
                // This series converges when |x| < 1. As we can not sum to infinity,
                // we instead sum the first 300 parts of the series to give a close approximation.
                // |x|<1, log(1+x) = x - x^2/2 + x^3/3 - ... + (-1)^(n-1)*x^n/n + ...
                var y = x;
                for (var i = 2; i <= 300; i++) {
                        y += Math.pow((-1), (i - 1)) * Math.pow(x, i) / i;
                }
                return y;
        }

        return Math.log(1 + x);
});
}

if (!("log2"in Math
)) {

// Math.log2
/* global CreateMethodProperty */
// 20.2.2.23. Math.log2 ( x )
CreateMethodProperty(Math, 'log2', function log2(x) {
        return Math.log(x) / Math.LN2;
});

}

if (!("sign"in Math
)) {

// Math.sign
/* global CreateMethodProperty */
// 20.2.2.29. Math.sign ( x )
CreateMethodProperty(Math, 'sign', function sign(x) {
        var x = Number(x);
        // If x is NaN, the result is NaN.
        if (isNaN(x)) {
                return NaN;
        }
        // If x is -0, the result is -0.
        if (1 / x === -Infinity) {
                return -0;
        }
        // If x is +0, the result is +0.
        if (1 / x === Infinity) {
                return 0;
        }
        // If x is negative and not -0, the result is -1.
        if (x < 0) {
                return -1;
        }
        // If x is positive and not +0, the result is +1.
        if (x > 0) {
                return 1;
        }
});

}

if (!("sinh"in Math
)) {

// Math.sinh
/* global CreateMethodProperty */
// 20.2.2.31. Math.sinh ( x )
CreateMethodProperty(Math, 'sinh', function sinh(x) {
        var s = (x < 0) ? -1 : 1;
        var absx = Math.abs(x);
        if (absx < 22) {
                if (absx < Math.pow(2, -28)) {
                        return x;
                }
                var t = Math.exp(absx) - 1;
                if (absx < 1) {
                        return (s * (2 * t - t * t / (t + 1)))/2;
                }
                return (s * (t + t / (t + 1)))/2;
        }
        if (absx < 709.7822265625) {
                return (s * Math.exp(absx))/2;
        }
        var w = Math.exp(0.5 * absx);
        var t = (s * w)/2;
        return t * w;
});

}

if (!("tanh"in Math
)) {

// Math.tanh
/* global CreateMethodProperty */
// 20.2.2.34. Math.tanh ( x )
CreateMethodProperty(Math, 'tanh', function tanh(x) {
        var y;

        return x === Infinity ? 1 : x === -Infinity ? -1 : (y = Math.exp(2 * x), (y - 1) / (y + 1));
});

}

if (!("trunc"in Math
)) {

// Math.trunc
/* global CreateMethodProperty */
CreateMethodProperty(Math, 'trunc', function trunc(x) {
        return x < 0 ? Math.ceil(x) : Math.floor(x);
});

}

if (!("isFinite"in Number
)) {

// Number.isFinite
/* global CreateMethodProperty, Type */
(function () {
        var that = this;
        // 20.1.2.2. Number.isFinite ( number )
        CreateMethodProperty(Number, 'isFinite', function isFinite(number) {
                // 1. If Type(number) is not Number, return false.
                if (Type(number) !== 'number') {
                        return false;
                }
                // 2. If number is NaN, +∞, or -∞, return false.
                // 3. Otherwise, return true.
                // Polyfill.io - We use isFinite as it implements steps 2 and 3.
                return that.isFinite(number);
        });
}());

}

if (!("isInteger"in Number
)) {

// Number.isInteger
/* global CreateMethodProperty, ToInteger, Type */
// 20.1.2.3. Number.isInteger ( number )
CreateMethodProperty(Number, 'isInteger', function isInteger(number) {
        // 1. If Type(number) is not Number, return false.
        if (Type(number) !== 'number') {
                return false;
        }
        // 2. If number is NaN, +∞, or -∞, return false.
        if (isNaN(number) || number === Infinity || number === -Infinity) {
                return false;
        }
        // 3. Let integer be ToInteger(number).
        var integer = ToInteger(number);
        // 4. If integer is not equal to number, return false.
        if (integer !== number) {
                return false;
        }
        // 5. Otherwise, return true.
        return true;
});

}

if (!("isNaN"in Number
)) {

// Number.isNaN
/* global CreateMethodProperty, Type */
(function () {
        var that = this;
        // 20.1.2.4. Number.isNaN ( number )
        CreateMethodProperty(Number, 'isNaN', function isNaN(number) {
                // 1. If Type(number) is not Number, return false.
                if (Type(number) !== 'number') {
                        return false;
                }
                // 2. If number is NaN, return true.
                if (that.isNaN(number)) {
                        return true;
                }
                // 3. Otherwise, return false.
                return false;
        });
}());

}

if (!("isSafeInteger"in Number
)) {

// Number.isSafeInteger
/* global CreateMethodProperty, Type, ToInteger */
// 20.1.2.5. Number.isSafeInteger ( number )
CreateMethodProperty(Number, 'isSafeInteger', function isSafeInteger(number) {
        // 1. If Type(number) is not Number, return false.
        if (Type(number) !== 'number') {
                return false;
        }
        // 2. If number is NaN, +∞, or -∞, return false.
        if (isNaN(number) || number === Infinity || number === -Infinity) {
                return false;
        }
        // 3. Let integer be ToInteger(number).
        var integer = ToInteger(number);
        // 4. If integer is not equal to number, return false.
        if (integer !== number) {
                return false;
        }
        // 5. If abs(integer) ≤ 2^53-1, return true.
        if (Math.abs(integer) <= (Math.pow(2, 53) - 1)) {
                return true;
        }
        // 6. Otherwise, return false.
        return false;
});

}

if (!("parseFloat"in Number
)) {

// Number.parseFloat
/* global CreateMethodProperty */
// 20.1.2.12. Number.parseFloat ( string )
// The value of the Number.parseFloat data property is the same built-in function object that is the value of the  parseFloat property of the global object defined in 18.2.4.
CreateMethodProperty(Number, 'parseFloat', parseFloat);

}

if (!("parseInt"in Number
)) {

// Number.parseInt
/* global CreateMethodProperty */
// 20.1.2.13. Number.parseInt ( string, radix )
// The value of the Number.parseInt data property is the same built-in function object that is the value of the  parseInt property of the global object defined in 18.2.5.
CreateMethodProperty(Number, 'parseInt', parseInt);

}

if (!("name"in Function.prototype&&"x"===function x(){}.name
)) {

// Function.prototype.name
(function () {

        var
        accessorName = 'name',
        fnNameMatchRegex = /^\s*function\s+([^\(\s]*)\s*/,
        $Function = Function,
        FunctionName = 'Function',
        FunctionProto = $Function.prototype,
        FunctionProtoCtor = FunctionProto.constructor,

        getFunctionName = function(fn) {
                var match, name;

                if (fn === $Function || fn === FunctionProtoCtor) {
                        name = FunctionName;
                }
                else if (fn !== FunctionProto) {
                        match = ('' + fn).match(fnNameMatchRegex);
                        name = match && match[1];
                }
                return name || '';
        };


        Object.defineProperty(FunctionProto, accessorName, {
                get: function Function$name() {
                        var
                        fn = this,
                        fnName = getFunctionName(fn);

                        // Since named function definitions have immutable names, also memoize the
                        // output by defining the `name` property directly on this Function
                        // instance so the accessor function will not need to be invoked again.
                        if (fn !== FunctionProto) {
                                Object.defineProperty(fn, accessorName, {
                                        value: fnName,
                                        configurable: true
                                });
                        }

                        return fnName;
                },
                configurable: true
        });

}());

}

if (!("EPSILON"in Number
)) {

// Number.Epsilon
// 20.1.2.1. Number.EPSILON
// The value of Number.EPSILON is the difference between 1 and the smallest value greater than 1 that is representable as a Number value, which is approximately 2.2204460492503130808472633361816 x 10-16.
// This property has the attributes { [[Writable]]: false, [[Enumerable]]: false, [[Configurable]]: false }.
Object.defineProperty(Number, 'EPSILON', {
        enumerable: false,
        configurable: false,
        writable: false,
        value: Math.pow(2, -52)
});

}

if (!("MAX_SAFE_INTEGER"in Number
)) {

// Number.MAX_SAFE_INTEGER
// 20.1.2.6. Number.MAX_SAFE_INTEGER
// The value of Number.MAX_SAFE_INTEGER is 9007199254740991 (2^53-1).
// This property has the attributes { [[Writable]]: false, [[Enumerable]]: false, [[Configurable]]: false }.
Object.defineProperty(Number, 'MAX_SAFE_INTEGER', {
        enumerable: false,
        configurable: false,
        writable: false,
        value: Math.pow(2, 53) - 1
});

}

if (!("MIN_SAFE_INTEGER"in Number
)) {

// Number.MIN_SAFE_INTEGER
// 20.1.2.8. Number.MIN_SAFE_INTEGER
// The value of Number.MIN_SAFE_INTEGER is -9007199254740991 (-(253-1)).
// This property has the attributes { [[Writable]]: false, [[Enumerable]]: false, [[Configurable]]: false }.
Object.defineProperty(Number, 'MIN_SAFE_INTEGER', {
        enumerable: false,
        configurable: false,
        writable: false,
        value: -(Math.pow(2, 53) - 1)
});

}

if (!("freeze"in Object
)) {

// Object.freeze
/* global CreateMethodProperty */
// 19.1.2.6. Object.freeze ( O )
CreateMethodProperty(Object, 'freeze', function freeze(O) {
        // This feature cannot be implemented fully as a polyfill.
        // We choose to silently fail which allows "securable" code
        // to "gracefully" degrade to working but insecure code.
        return O;
});

}

if (!("getOwnPropertyDescriptor"in Object&&"function"==typeof Object.getOwnPropertyDescriptor&&function(){try{var t={}
return t.test=0,0===Object.getOwnPropertyDescriptor(t,"test").value}catch(e){return!1}}()
)) {

// Object.getOwnPropertyDescriptor
/* global CreateMethodProperty */
(function () {
        var call = Function.prototype.call;
        var prototypeOfObject = Object.prototype;
        var owns = call.bind(prototypeOfObject.hasOwnProperty);

        var lookupGetter;
        var lookupSetter;
        var supportsAccessors;
        if ((supportsAccessors = owns(prototypeOfObject, "__defineGetter__"))) {
            lookupGetter = call.bind(prototypeOfObject.__lookupGetter__);
            lookupSetter = call.bind(prototypeOfObject.__lookupSetter__);
        }
        function doesGetOwnPropertyDescriptorWork(object) {
            try {
                object.sentinel = 0;
                return Object.getOwnPropertyDescriptor(
                    object,
                    "sentinel"
                ).value === 0;
            } catch (exception) {
                // returns falsy
            }
        }
        // check whether getOwnPropertyDescriptor works if it's given. Otherwise,
        // shim partially.
        if (Object.defineProperty) {
            var getOwnPropertyDescriptorWorksOnObject =
                doesGetOwnPropertyDescriptorWork({});
            var getOwnPropertyDescriptorWorksOnDom = typeof document == "undefined" ||
                doesGetOwnPropertyDescriptorWork(document.createElement("div"));
            if (!getOwnPropertyDescriptorWorksOnDom ||
                !getOwnPropertyDescriptorWorksOnObject
            ) {
                var getOwnPropertyDescriptorFallback = Object.getOwnPropertyDescriptor;
            }
        }

        if (!Object.getOwnPropertyDescriptor || getOwnPropertyDescriptorFallback) {
            var ERR_NON_OBJECT = "Object.getOwnPropertyDescriptor called on a non-object: ";

            CreateMethodProperty(Object, 'getOwnPropertyDescriptor', function getOwnPropertyDescriptor(object, property) {
                if ((typeof object != "object" && typeof object != "function") || object === null) {
                    throw new TypeError(ERR_NON_OBJECT + object);
                }

                // make a valiant attempt to use the real getOwnPropertyDescriptor
                // for I8's DOM elements.
                if (getOwnPropertyDescriptorFallback) {
                    try {
                        return getOwnPropertyDescriptorFallback.call(Object, object, property);
                    } catch (exception) {
                        // try the shim if the real one doesn't work
                    }
                }

                // If object does not owns property return undefined immediately.
                if (!owns(object, property)) {
                    return;
                }

                // If object has a property then it's for sure both `enumerable` and
                // `configurable`.
                var descriptor = { enumerable: true, configurable: true };

                // If JS engine supports accessor properties then property may be a
                // getter or setter.
                if (supportsAccessors) {
                    // Unfortunately `__lookupGetter__` will return a getter even
                    // if object has own non getter property along with a same named
                    // inherited getter. To avoid misbehavior we temporary remove
                    // `__proto__` so that `__lookupGetter__` will return getter only
                    // if it's owned by an object.
                    var prototype = object.__proto__;
                    object.__proto__ = prototypeOfObject;

                    var getter = lookupGetter(object, property);
                    var setter = lookupSetter(object, property);

                    // Once we have getter and setter we can put values back.
                    object.__proto__ = prototype;

                    if (getter || setter) {
                        if (getter) {
                            descriptor.get = getter;
                        }
                        if (setter) {
                            descriptor.set = setter;
                        }
                        // If it was accessor property we're done and return here
                        // in order to avoid adding `value` to the descriptor.
                        return descriptor;
                    }
                }

                // If we got this far we know that object has an own property that is
                // not an accessor so we set it as a value and return descriptor.
                descriptor.value = object[property];
                        descriptor.writable = true;
                return descriptor;
            });
        }
}());

}

if (!("getOwnPropertyNames"in Object
)) {

// Object.getOwnPropertyNames
/* global CreateMethodProperty */

var toString = ({}).toString;
var split = ''.split;

CreateMethodProperty(Object, 'getOwnPropertyNames', function getOwnPropertyNames(object) {
        var buffer = [];
        var key;

        // Non-enumerable properties cannot be discovered but can be checked for by name.
        // Define those used internally by JS to allow an incomplete solution
        var commonProps = ['length', "name", "arguments", "caller", "prototype", "observe", "unobserve"];

        if (typeof object === 'undefined' || object === null) {
                throw new TypeError('Cannot convert undefined or null to object');
        }

        // Polyfill.io fallback for non-array-like strings which exist in some ES3 user-agents (IE 8)
        object = toString.call(object) == '[object String]' ? split.call(object, '') : Object(object);

        // Enumerable properties only
        for (key in object) {
                if (Object.prototype.hasOwnProperty.call(object, key)) {
                        buffer.push(key);
                }
        }

        // Check for and add the common non-enumerable properties
        for (var i=0, s=commonProps.length; i<s; i++) {
                if (commonProps[i] in object) buffer.push(commonProps[i]);
        }

        return buffer;
});

}

if (!("getPrototypeOf"in Object
)) {

// Object.getPrototypeOf
/* global CreateMethodProperty */
// Based on: https://github.com/es-shims/es5-shim/blob/master/es5-sham.js

// https://github.com/es-shims/es5-shim/issues#issue/2
// http://ejohn.org/blog/objectgetprototypeof/
// recommended by fschaefer on github
//
// sure, and webreflection says ^_^
// ... this will nerever possibly return null
// ... Opera Mini breaks here with infinite loops
CreateMethodProperty(Object, 'getPrototypeOf', function getPrototypeOf(object) {
        if (object !== Object(object)) {
                throw new TypeError('Object.getPrototypeOf called on non-object');
        }
        var proto = object.__proto__;
        if (proto || proto === null) {
                return proto;
        } else if (typeof object.constructor == 'function' && object instanceof object.constructor) {
    return object.constructor.prototype;
  } else if (object instanceof Object) {
                return Object.prototype;
        } else {
                // Correctly return null for Objects created with `Object.create(null)`
                // (shammed or native) or `{ __proto__: null}`.  Also returns null for
                // cross-realm objects on browsers that lack `__proto__` support (like
                // IE <11), but that's the best we can do.
                return null;
        }
});

}

if (!("is"in Object
)) {

// Object.is
/* global CreateMethodProperty, SameValue */
// 19.1.2.12. Object.is ( value1, value2 )
CreateMethodProperty(Object, 'is', function is(value1, value2) {
        // 1. Return SameValue(value1, value2).
        return SameValue(value1, value2);
});

}

if (!("keys"in Object&&function(){return 2===Object.keys(arguments).length}(1,2)&&function(){try{return Object.keys(""),!0}catch(t){return!1}}()
)) {

// Object.keys
/* global CreateMethodProperty */
CreateMethodProperty(Object, "keys", (function() {
        'use strict';

        // modified from https://github.com/es-shims/object-keys

        var has = Object.prototype.hasOwnProperty;
        var toStr = Object.prototype.toString;
        var isEnumerable = Object.prototype.propertyIsEnumerable;
        var hasDontEnumBug = !isEnumerable.call({ toString: null }, 'toString');
        var hasProtoEnumBug = isEnumerable.call(function () {}, 'prototype');
        var dontEnums = [
                'toString',
                'toLocaleString',
                'valueOf',
                'hasOwnProperty',
                'isPrototypeOf',
                'propertyIsEnumerable',
                'constructor'
        ];
        var equalsConstructorPrototype = function (o) {
                var ctor = o.constructor;
                return ctor && ctor.prototype === o;
        };
        var excludedKeys = {
                $console: true,
                $external: true,
                $frame: true,
                $frameElement: true,
                $frames: true,
                $innerHeight: true,
                $innerWidth: true,
                $outerHeight: true,
                $outerWidth: true,
                $pageXOffset: true,
                $pageYOffset: true,
                $parent: true,
                $scrollLeft: true,
                $scrollTop: true,
                $scrollX: true,
                $scrollY: true,
                $self: true,
                $webkitIndexedDB: true,
                $webkitStorageInfo: true,
                $window: true
        };
        var hasAutomationEqualityBug = (function () {
                /* global window */
                if (typeof window === 'undefined') { return false; }
                for (var k in window) {
                        try {
                                if (!excludedKeys['$' + k] && has.call(window, k) && window[k] !== null && typeof window[k] === 'object') {
                                        try {
                                                equalsConstructorPrototype(window[k]);
                                        } catch (e) {
                                                return true;
                                        }
                                }
                        } catch (e) {
                                return true;
                        }
                }
                return false;
        }());
        var equalsConstructorPrototypeIfNotBuggy = function (o) {
                /* global window */
                if (typeof window === 'undefined' || !hasAutomationEqualityBug) {
                        return equalsConstructorPrototype(o);
                }
                try {
                        return equalsConstructorPrototype(o);
                } catch (e) {
                        return false;
                }
        };

        function isArgumentsObject(value) {
                var str = toStr.call(value);
                var isArgs = str === '[object Arguments]';
                if (!isArgs) {
                        isArgs = str !== '[object Array]' &&
                                value !== null &&
                                typeof value === 'object' &&
                                typeof value.length === 'number' &&
                                value.length >= 0 &&
                                toStr.call(value.callee) === '[object Function]';
                }
                return isArgs;
        }

        return function keys(object) {
                var isFunction = toStr.call(object) === '[object Function]';
                var isArguments = isArgumentsObject(object);
                var isString = toStr.call(object) === '[object String]';
                var theKeys = [];

                if (object === undefined || object === null) {
                        throw new TypeError('Cannot convert undefined or null to object');
                }

                var skipProto = hasProtoEnumBug && isFunction;
                if (isString && object.length > 0 && !has.call(object, 0)) {
                        for (var i = 0; i < object.length; ++i) {
                                theKeys.push(String(i));
                        }
                }

                if (isArguments && object.length > 0) {
                        for (var j = 0; j < object.length; ++j) {
                                theKeys.push(String(j));
                        }
                } else {
                        for (var name in object) {
                                if (!(skipProto && name === 'prototype') && has.call(object, name)) {
                                        theKeys.push(String(name));
                                }
                        }
                }

                if (hasDontEnumBug) {
                        var skipConstructor = equalsConstructorPrototypeIfNotBuggy(object);

                        for (var k = 0; k < dontEnums.length; ++k) {
                                if (!(skipConstructor && dontEnums[k] === 'constructor') && has.call(object, dontEnums[k])) {
                                        theKeys.push(dontEnums[k]);
                                }
                        }
                }
                return theKeys;
        };
}()));

}

if (!("assign"in Object
)) {

// Object.assign
/* global CreateMethodProperty, Get, ToObject */
// 19.1.2.1 Object.assign ( target, ...sources )
CreateMethodProperty(Object, 'assign', function assign(target, source) { // eslint-disable-line no-unused-vars
        // 1. Let to be ? ToObject(target).
        var to = ToObject(target);

        // 2. If only one argument was passed, return to.
        if (arguments.length === 1) {
                return to;
        }

        // 3. Let sources be the List of argument values starting with the second argument
        var sources = Array.prototype.slice.call(arguments, 1);

        // 4. For each element nextSource of sources, in ascending index order, do
        var index1;
        var index2;
        var keys;
        var from;
        for (index1 = 0; index1 < sources.length; index1++) {
                var nextSource = sources[index1];
                // a. If nextSource is undefined or null, let keys be a new empty List.
                if (nextSource === undefined || nextSource === null) {
                        keys = [];
                        // b. Else,
                } else {
                        // i. Let from be ! ToObject(nextSource).
                        from = ToObject(nextSource);
                        // ii. Let keys be ? from.[[OwnPropertyKeys]]().
                        /*
                                This step in our polyfill is not complying with the specification.
                                [[OwnPropertyKeys]] is meant to return ALL keys, including non-enumerable and symbols.
                                TODO: When we have Reflect.ownKeys, use that instead as it is the userland equivalent of [[OwnPropertyKeys]].
                        */
                        keys = Object.keys(from);
                }

                // c. For each element nextKey of keys in List order, do
                for (index2 = 0; index2 < keys.length; index2++) {
                        var nextKey = keys[index2];
                        var enumerable;
                        try {
                                // i. Let desc be ? from.[[GetOwnProperty]](nextKey).
                                var desc = Object.getOwnPropertyDescriptor(from, nextKey);
                                // ii. If desc is not undefined and desc.[[Enumerable]] is true, then
                                enumerable = desc !== undefined && desc.enumerable === true;
                        } catch (e) {
                                // Polyfill.io - We use Object.prototype.propertyIsEnumerable as a fallback
                                // because `Object.getOwnPropertyDescriptor(window.location, 'hash')` causes Internet Explorer 11 to crash.
                                enumerable = Object.prototype.propertyIsEnumerable.call(from, nextKey);
                        }
                        if (enumerable) {
                                // 1. Let propValue be ? Get(from, nextKey).
                                var propValue = Get(from, nextKey);
                                // 2. Perform ? Set(to, nextKey, propValue, true).
                                to[nextKey] = propValue;
                        }
                }
        }
        // 5. Return to.
        return to;
});

}

if (!("defineProperties"in Object
)) {

// Object.defineProperties
/* global CreateMethodProperty, Get, ToObject, Type */
// 19.1.2.3. Object.defineProperties ( O, Properties )
CreateMethodProperty(Object, 'defineProperties', function defineProperties(O, Properties) {
        // 1. If Type(O) is not Object, throw a TypeError exception.
        if (Type(O) !== 'object') {
                throw new TypeError('Object.defineProperties called on non-object');
        }
        // 2. Let props be ? ToObject(Properties).
        var props = ToObject(Properties);
        // 3. Let keys be ? props.[[OwnPropertyKeys]]().
        /*
                Polyfill.io - This step in our polyfill is not complying with the specification.
                [[OwnPropertyKeys]] is meant to return ALL keys, including non-enumerable and symbols.
                TODO: When we have Reflect.ownKeys, use that instead as it is the userland equivalent of [[OwnPropertyKeys]].
        */
        var keys = Object.keys(props);
        // 4. Let descriptors be a new empty List.
        var descriptors = [];
        // 5. For each element nextKey of keys in List order, do
        for (var i = 0; i < keys.length; i++) {
                var nextKey = keys[i];
                // a. Let propDesc be ? props.[[GetOwnProperty]](nextKey).
                var propDesc = Object.getOwnPropertyDescriptor(props, nextKey);
                // b. If propDesc is not undefined and propDesc.[[Enumerable]] is true, then
                if (propDesc !== undefined && propDesc.enumerable) {
                        // i. Let descObj be ? Get(props, nextKey).
                        var descObj = Get(props, nextKey);
                        // ii. Let desc be ? ToPropertyDescriptor(descObj).
                        // Polyfill.io - We skip this step because Object.defineProperty deals with it.
                        // TODO: Implement this step?
                        var desc = descObj;
                        // iii. Append the pair (a two element List) consisting of nextKey and desc to the end of descriptors.
                        descriptors.push([nextKey, desc]);
                }
        }
        // 6. For each pair from descriptors in list order, do
        for (var i = 0; i < descriptors.length; i++){
                // a. Let P be the first element of pair.
                var P = descriptors[i][0];
                // b. Let desc be the second element of pair.
                var desc = descriptors[i][1];
                // c. Perform ? DefinePropertyOrThrow(O, P, desc).
                Object.defineProperty(O, P, desc);
        }
        // 7. Return O.
        return O;
});

}

if (!("create"in Object
)) {

// Object.create
/* global CreateMethodProperty, Type */
CreateMethodProperty(Object, 'create', function create(O, properties) {
        // 1. If Type(O) is neither Object nor Null, throw a TypeError exception.
        if (Type(O) !== 'object' && Type(O) !== 'null') {
                throw new TypeError('Object prototype may only be an Object or null');
        }
        // 2. Let obj be ObjectCreate(O).
        var obj = new Function('e', 'function Object() {}Object.prototype=e;return new Object')(O);

        obj.constructor.prototype = O;

        // 3. If Properties is not undefined, then
        if (1 in arguments) {
                // a. Return ? ObjectDefineProperties(obj, Properties).
                return Object.defineProperties(obj, properties);
        }

        return obj;
});

}


// _ESAbstract.OrdinaryCreateFromConstructor
/* global GetPrototypeFromConstructor */
// 9.1.13. OrdinaryCreateFromConstructor ( constructor, intrinsicDefaultProto [ , internalSlotsList ] )
function OrdinaryCreateFromConstructor(constructor, intrinsicDefaultProto) { // eslint-disable-line no-unused-vars
        var internalSlotsList = arguments[2] || {};
        // 1. Assert: intrinsicDefaultProto is a String value that is this specification's name of an intrinsic object.
        // The corresponding object must be an intrinsic that is intended to be used as the[[Prototype]] value of an object.

        // 2. Let proto be ? GetPrototypeFromConstructor(constructor, intrinsicDefaultProto).
        var proto = GetPrototypeFromConstructor(constructor, intrinsicDefaultProto);

        // 3. Return ObjectCreate(proto, internalSlotsList).
        // Polyfill.io - We do not pass internalSlotsList to Object.create because Object.create does not use the default ordinary object definitions specified in 9.1.
        var obj = Object.create(proto);
        for (var name in internalSlotsList) {
                if (Object.prototype.hasOwnProperty.call(internalSlotsList, name)) {
                        Object.defineProperty(obj, name, {
                                configurable: true,
                                enumerable: false,
                                writable: true,
                                value: internalSlotsList[name]
                        });
                }
        }
        return obj;
}

// _ESAbstract.Construct
/* global IsConstructor, OrdinaryCreateFromConstructor, Call */
// 7.3.13. Construct ( F [ , argumentsList [ , newTarget ]] )
function Construct(F /* [ , argumentsList [ , newTarget ]] */) { // eslint-disable-line no-unused-vars
        // 1. If newTarget is not present, set newTarget to F.
        var newTarget = arguments.length > 2 ? arguments[2] : F;

        // 2. If argumentsList is not present, set argumentsList to a new empty List.
        var argumentsList = arguments.length > 1 ? arguments[1] : [];

        // 3. Assert: IsConstructor(F) is true.
        if (!IsConstructor(F)) {
                throw new TypeError('F must be a constructor.');
        }

        // 4. Assert: IsConstructor(newTarget) is true.
        if (!IsConstructor(newTarget)) {
                throw new TypeError('newTarget must be a constructor.');
        }

        // 5. Return ? F.[[Construct]](argumentsList, newTarget).
        // Polyfill.io - If newTarget is the same as F, it is equivalent to new F(...argumentsList).
        if (newTarget === F) {
                return new (Function.prototype.bind.apply(F, [null].concat(argumentsList)))();
        } else {
                // Polyfill.io - This is mimicking section 9.2.2 step 5.a.
                var obj = OrdinaryCreateFromConstructor(newTarget, Object.prototype);
                return Call(F, obj, argumentsList);
        }
}

// _ESAbstract.ArraySpeciesCreate
/* global IsArray, ArrayCreate, Get, Type, IsConstructor, Construct */
// 9.4.2.3. ArraySpeciesCreate ( originalArray, length )
function ArraySpeciesCreate(originalArray, length) { // eslint-disable-line no-unused-vars
        // 1. Assert: length is an integer Number ≥ 0.
        // 2. If length is -0, set length to +0.
        if (1/length === -Infinity) {
                length = 0;
        }

        // 3. Let isArray be ? IsArray(originalArray).
        var isArray = IsArray(originalArray);

        // 4. If isArray is false, return ? ArrayCreate(length).
        if (isArray === false) {
                return ArrayCreate(length);
        }

        // 5. Let C be ? Get(originalArray, "constructor").
        var C = Get(originalArray, 'constructor');

        // Polyfill.io - We skip this section as not sure how to make a cross-realm normal Array, a same-realm Array.
        // 6. If IsConstructor(C) is true, then
        // if (IsConstructor(C)) {
                // a. Let thisRealm be the current Realm Record.
                // b. Let realmC be ? GetFunctionRealm(C).
                // c. If thisRealm and realmC are not the same Realm Record, then
                        // i. If SameValue(C, realmC.[[Intrinsics]].[[%Array%]]) is true, set C to undefined.
        // }
        // 7. If Type(C) is Object, then
        if (Type(C) === 'object') {
                // a. Set C to ? Get(C, @@species).
                C = 'Symbol' in this && 'species' in this.Symbol ? Get(C, this.Symbol.species) : undefined;
                // b. If C is null, set C to undefined.
                if (C === null) {
                        C = undefined;
                }
        }
        // 8. If C is undefined, return ? ArrayCreate(length).
        if (C === undefined) {
                return ArrayCreate(length);
        }
        // 9. If IsConstructor(C) is false, throw a TypeError exception.
        if (!IsConstructor(C)) {
                throw new TypeError('C must be a constructor');
        }
        // 10. Return ? Construct(C, « length »).
        return Construct(C, [length]);
}
if (!("filter"in Array.prototype
)) {

// Array.prototype.filter
/* global CreateMethodProperty, ToObject, ToLength, Get, IsCallable, ArraySpeciesCreate, ToString, HasProperty, ToBoolean, Call, CreateDataPropertyOrThrow */
// 22.1.3.7. Array.prototype.filter ( callbackfn [ , thisArg ] )
CreateMethodProperty(Array.prototype, 'filter', function filter(callbackfn /* [ , thisArg ] */) {
        // 1. Let O be ? ToObject(this value).
        var O = ToObject(this);
        // 2. Let len be ? ToLength(? Get(O, "length")).
        var len = ToLength(Get(O, "length"));
        // 3. If IsCallable(callbackfn) is false, throw a TypeError exception.
        if (IsCallable(callbackfn) === false) {
                throw new TypeError(callbackfn + ' is not a function');
        }
        // 4. If thisArg is present, let T be thisArg; else let T be undefined.
        var T = arguments.length > 1 ? arguments[1] : undefined;
        // 5. Let A be ? ArraySpeciesCreate(O, 0).
        var A = ArraySpeciesCreate(O, 0);
        // 6. Let k be 0.
        var k = 0;
        // 7. Let to be 0.
        var to = 0;
        // 8. Repeat, while k < len
        while (k < len) {
                // a. Let Pk be ! ToString(k).
                var Pk = ToString(k);
                // b. Let kPresent be ? HasProperty(O, Pk).
                var kPresent = HasProperty(O, Pk);
                // c. If kPresent is true, then
                if (kPresent) {
                        // i. Let kValue be ? Get(O, Pk).
                        var kValue = Get(O, Pk);
                        // ii. Let selected be ToBoolean(? Call(callbackfn, T, « kValue, k, O »)).
                        var selected = ToBoolean(Call(callbackfn, T, [kValue, k, O]));
                        // iii. If selected is true, then
                        if (selected) {
                                // 1. Perform ? CreateDataPropertyOrThrow(A, ! ToString(to), kValue)
                                CreateDataPropertyOrThrow(A, ToString(to), kValue);
                                // 2. Increase to by 1.
                                to = to + 1;
                        }

                }
                // d. Increase k by 1.
                k = k + 1;
        }
        // 9. Return A.
        return A;
});

}

if (!("map"in Array.prototype
)) {

// Array.prototype.map
/* global ArraySpeciesCreate, Call, CreateDataPropertyOrThrow, CreateMethodProperty, Get, HasProperty, IsCallable, ToLength, ToObject, ToString */
/* global CreateMethodProperty, ToObject, ToLength, Get, ArraySpeciesCreate, ToString, HasProperty, Call, CreateDataPropertyOrThrow */
// 22.1.3.16. Array.prototype.map ( callbackfn [ , thisArg ] )
CreateMethodProperty(Array.prototype, 'map', function map(callbackfn /* [ , thisArg ] */) {
        // 1. Let O be ? ToObject(this value).
        var O = ToObject(this);
        // 2. Let len be ? ToLength(? Get(O, "length")).
        var len = ToLength(Get(O, "length"));
        // 3. If IsCallable(callbackfn) is false, throw a TypeError exception.
        if (IsCallable(callbackfn) === false) {
                throw new TypeError(callbackfn + ' is not a function');
        }
        // 4. If thisArg is present, let T be thisArg; else let T be undefined.
        var T = arguments.length > 1 ? arguments[1] : undefined;
        // 5. Let A be ? ArraySpeciesCreate(O, len).
        var A = ArraySpeciesCreate(O, len);
        // 6. Let k be 0.
        var k = 0;
        // 7. Repeat, while k < len
        while (k < len) {
                // a. Let Pk be ! ToString(k).
                var Pk = ToString(k);
                // b. Let kPresent be ? HasProperty(O, Pk).
                var kPresent = HasProperty(O, Pk);
                // c. If kPresent is true, then
                if (kPresent) {
                        // i. Let kValue be ? Get(O, Pk).
                        var kValue = Get(O, Pk);
                        // ii. Let mappedValue be ? Call(callbackfn, T, « kValue, k, O »).
                        var mappedValue = Call(callbackfn, T, [kValue, k, O]);
                        // iii. Perform ? CreateDataPropertyOrThrow(A, Pk, mappedValue).
                        CreateDataPropertyOrThrow(A, Pk, mappedValue);
                }
                // d. Increase k by 1.
                k = k + 1;
        }
        // 8. Return A.
        return A;
});

}

if (!("of"in Array
)) {

// Array.of
/* global ArrayCreate, Construct, CreateDataPropertyOrThrow, CreateMethodProperty, IsConstructor, ToString */
// 22.1.2.3. Array.of ( ...items )
CreateMethodProperty(Array, 'of', function of() {
        // 1. Let len be the actual number of arguments passed to this function.
        var len = arguments.length;
        // 2. Let items be the List of arguments passed to this function.
        var items = arguments;
        // 3. Let C be the this value.
        var C = this;
        // 4. If IsConstructor(C) is true, then
        if (IsConstructor(C)) {
                // a. Let A be ? Construct(C, « len »).
                var A = Construct(C, [len]);
                // 5. Else,
        } else {
                // a. Let A be ? ArrayCreate(len).
                var A = ArrayCreate(len);
        }
        // 6. Let k be 0.
        var k = 0;
        // 7. Repeat, while k < len
        while (k < len) {
                // a. Let kValue be items[k].
                var kValue = items[k];
                // b. Let Pk be ! ToString(k).
                var Pk = ToString(k);
                // c. Perform ? CreateDataPropertyOrThrow(A, Pk, kValue).
                CreateDataPropertyOrThrow(A, Pk, kValue);
                // d. Increase k by 1.
                var k = k + 1;

        }
        // 8. Perform ? Set(A, "length", len, true)
        A["length"] = len;
        // 9. Return A.
        return A;
});

}

if (!("seal"in Object&&function(){try{return Object.seal("1"),!0}catch(t){return!1}}
)) {

// Object.seal
/* global CreateMethodProperty, Type */
// 19.1.2.19 Object.seal ( O )
(function(originalObjectSeal) {
    CreateMethodProperty(Object, 'seal', function seal(O) {
        // 1. If Type(O) is not Object, return O.
        if (Type(O) === 'object') {
            return O;
        }
        // 2. Let status be ? SetIntegrityLevel(O, "sealed").
        // 3. If status is false, throw a TypeError exception.
        // 4. Return O.
        return originalObjectSeal ? originalObjectSeal(O) : O;
    });
}(Object.seal));


}


// Object.setPrototypeOf
/* global CreateMethodProperty */
// ES6-shim 0.16.0 (c) 2013-2014 Paul Miller (http://paulmillr.com)
// ES6-shim may be freely distributed under the MIT license.
// For more details and documentation:
// https://github.com/paulmillr/es6-shim/

 // NOTE:  This versions needs object ownership
  //        because every promoted object needs to be reassigned
  //        otherwise uncompatible browsers cannot work as expected
  //
  // NOTE:  This might need es5-shim or polyfills upfront
  //        because it's based on ES5 API.
  //        (probably just an IE <= 8 problem)
  //
  // NOTE:  nodejs is fine in version 0.8, 0.10, and future versions.
(function () {
        if (Object.setPrototypeOf) { return; }

        /*jshint proto: true */
        // @author    Andrea Giammarchi - @WebReflection

        var getOwnPropertyNames = Object.getOwnPropertyNames;
        var getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor;
        var create = Object.create;
        var defineProperty = Object.defineProperty;
        var getPrototypeOf = Object.getPrototypeOf;
        var objProto = Object.prototype;

        var copyDescriptors = function (target, source) {
                // define into target descriptors from source
                getOwnPropertyNames(source).forEach(function (key) {
                        defineProperty(
                                target,
                                key,
                                getOwnPropertyDescriptor(source, key)
                        );
                });
                return target;
        };
        // used as fallback when no promotion is possible
        var createAndCopy = function setPrototypeOf(origin, proto) {
                return copyDescriptors(create(proto), origin);
        };
        var set, sPOf;
        try {
                // this might fail for various reasons
                // ignore if Chrome cought it at runtime
                set = getOwnPropertyDescriptor(objProto, '__proto__').set;
                set.call({}, null);
                // setter not poisoned, it can promote
                // Firefox, Chrome
                sPOf = function setPrototypeOf(origin, proto) {
                        set.call(origin, proto);
                        return origin;
                };
        } catch (e) {
                // do one or more feature detections
                set = { __proto__: null };
                // if proto does not work, needs to fallback
                // some Opera, Rhino, ducktape
                if (set instanceof Object) {
                        sPOf = createAndCopy;
                } else {
                        // verify if null objects are buggy
                        /* eslint-disable no-proto */
                        set.__proto__ = objProto;
                        /* eslint-enable no-proto */
                        // if null objects are buggy
                        // nodejs 0.8 to 0.10
                        if (set instanceof Object) {
                                sPOf = function setPrototypeOf(origin, proto) {
                                        // use such bug to promote
                                        /* eslint-disable no-proto */
                                        origin.__proto__ = proto;
                                        /* eslint-enable no-proto */
                                        return origin;
                                };
                        } else {
                                // try to use proto or fallback
                                // Safari, old Firefox, many others
                                sPOf = function setPrototypeOf(origin, proto) {
                                        // if proto is not null
                                        if (getPrototypeOf(origin)) {
                                                // use __proto__ to promote
                                                /* eslint-disable no-proto */
                                                origin.__proto__ = proto;
                                                /* eslint-enable no-proto */
                                                return origin;
                                        } else {
                                                // otherwise unable to promote: fallback
                                                return createAndCopy(origin, proto);
                                        }
                                };
                        }
                }
        }
        CreateMethodProperty(Object, 'setPrototypeOf', sPOf);
}());
if (!("Promise"in this
)) {

// Promise
!function(n){function t(r){if(e[r])return e[r].exports;var o=e[r]={i:r,l:!1,exports:{}};return n[r].call(o.exports,o,o.exports,t),o.l=!0,o.exports}var e={};t.m=n,t.c=e,t.i=function(n){return n},t.d=function(n,e,r){t.o(n,e)||Object.defineProperty(n,e,{configurable:!1,enumerable:!0,get:r})},t.n=function(n){var e=n&&n.__esModule?function(){return n["default"]}:function(){return n};return t.d(e,"a",e),e},t.o=function(n,t){return Object.prototype.hasOwnProperty.call(n,t)},t.p="",t(t.s=100)}({100:/*!***********************!*\
  !*** ./src/global.js ***!
  \***********************/
function(n,t,e){(function(n){var t=e(/*! ./yaku */5);try{n.Promise=t,window.Promise=t}catch(r){}}).call(t,e(/*! ./../~/webpack/buildin/global.js */2))},2:/*!***********************************!*\
  !*** (webpack)/buildin/global.js ***!
  \***********************************/
function(n,t){var e;e=function(){return this}();try{e=e||Function("return this")()||(0,eval)("this")}catch(r){"object"==typeof window&&(e=window)}n.exports=e},5:/*!*********************!*\
  !*** ./src/yaku.js ***!
  \*********************/
function(n,t,e){(function(t){!function(){"use strict";function e(){return rn[q][B]||D}function r(n){return n&&"object"==typeof n}function o(n){return"function"==typeof n}function i(n,t){return n instanceof t}function u(n){return i(n,M)}function c(n,t,e){if(!t(n))throw h(e)}function f(){try{return R.apply(S,arguments)}catch(n){return nn.e=n,nn}}function s(n,t){return R=n,S=t,f}function a(n,t){function e(){for(var e=0;e<o;)t(r[e],r[e+1]),r[e++]=P,r[e++]=P;o=0,r.length>n&&(r.length=n)}var r=A(n),o=0;return function(n,t){r[o++]=n,r[o++]=t,2===o&&rn.nextTick(e)}}function l(n,t){var e,r,u,c,f=0;if(!n)throw h(Q);var a=n[rn[q][z]];if(o(a))r=a.call(n);else{if(!o(n.next)){if(i(n,A)){for(e=n.length;f<e;)t(n[f],f++);return f}throw h(Q)}r=n}for(;!(u=r.next()).done;)if((c=s(t)(u.value,f++))===nn)throw o(r[G])&&r[G](),c.e;return f}function h(n){return new TypeError(n)}function v(n){return(n?"":V)+(new M).stack}function _(n,t){var e="on"+n.toLowerCase(),r=O[e];H&&H.listeners(n).length?n===Z?H.emit(n,t._v,t):H.emit(n,t):r?r({reason:t._v,promise:t}):rn[n](t._v,t)}function p(n){return n&&n._s}function d(n){if(p(n))return new n(tn);var t,e,r;return t=new n(function(n,o){if(t)throw h();e=n,r=o}),c(e,o),c(r,o),t}function w(n,t){var e=!1;return function(r){e||(e=!0,L&&(n[N]=v(!0)),t===Y?k(n,r):x(n,t,r))}}function y(n,t,e,r){return o(e)&&(t._onFulfilled=e),o(r)&&(n[J]&&_(X,n),t._onRejected=r),L&&(t._p=n),n[n._c++]=t,n._s!==$&&on(n,t),t}function m(n){if(n._umark)return!0;n._umark=!0;for(var t,e=0,r=n._c;e<r;)if(t=n[e++],t._onRejected||m(t))return!0}function j(n,t){function e(n){return r.push(n.replace(/^\s+|\s+$/g,""))}var r=[];return L&&(t[N]&&e(t[N]),function o(n){n&&K in n&&(o(n._next),e(n[K]+""),o(n._p))}(t)),(n&&n.stack?n.stack:n)+("\n"+r.join("\n")).replace(en,"")}function g(n,t){return n(t)}function x(n,t,e){var r=0,o=n._c;if(n._s===$)for(n._s=t,n._v=e,t===U&&(L&&u(e)&&(e.longStack=j(e,n)),un(n));r<o;)on(n,n[r++]);return n}function k(n,t){if(t===n&&t)return x(n,U,h(W)),n;if(t!==C&&(o(t)||r(t))){var e=s(b)(t);if(e===nn)return x(n,U,e.e),n;o(e)?(L&&p(t)&&(n._next=t),p(t)?T(n,t,e):rn.nextTick(function(){T(n,t,e)})):x(n,Y,t)}else x(n,Y,t);return n}function b(n){return n.then}function T(n,t,e){var r=s(e,t)(function(e){t&&(t=C,k(n,e))},function(e){t&&(t=C,x(n,U,e))});r===nn&&t&&(x(n,U,r.e),t=C)}var P,R,S,C=null,F="object"==typeof self,O=F?self:t,E=O.Promise,H=O.process,I=O.console,L=!1,A=Array,M=Error,U=1,Y=2,$=3,q="Symbol",z="iterator",B="species",D=q+"("+B+")",G="return",J="_uh",K="_pt",N="_st",Q="Invalid argument",V="\nFrom previous ",W="Chaining cycle detected for promise",X="rejectionHandled",Z="unhandledRejection",nn={e:C},tn=function(){},en=/^.+\/node_modules\/yaku\/.+\n?/gm,rn=function(n){var t,e=this;if(!r(e)||e._s!==P)throw h("Invalid this");if(e._s=$,L&&(e[K]=v()),n!==tn){if(!o(n))throw h(Q);t=s(n)(w(e,Y),w(e,U)),t===nn&&x(e,U,t.e)}};rn["default"]=rn,function(n,t){for(var e in t)n[e]=t[e]}(rn.prototype,{then:function(n,t){if(this._s===undefined)throw h();return y(this,d(rn.speciesConstructor(this,rn)),n,t)},"catch":function(n){return this.then(P,n)},"finally":function(n){return this.then(function(t){return rn.resolve(n()).then(function(){return t})},function(t){return rn.resolve(n()).then(function(){throw t})})},_c:0,_p:C}),rn.resolve=function(n){return p(n)?n:k(d(this),n)},rn.reject=function(n){return x(d(this),U,n)},rn.race=function(n){var t=this,e=d(t),r=function(n){x(e,Y,n)},o=function(n){x(e,U,n)},i=s(l)(n,function(n){t.resolve(n).then(r,o)});return i===nn?t.reject(i.e):e},rn.all=function(n){function t(n){x(o,U,n)}var e,r=this,o=d(r),i=[];return(e=s(l)(n,function(n,u){r.resolve(n).then(function(n){i[u]=n,--e||x(o,Y,i)},t)}))===nn?r.reject(e.e):(e||x(o,Y,[]),o)},rn.Symbol=O[q]||{},s(function(){Object.defineProperty(rn,e(),{get:function(){return this}})})(),rn.speciesConstructor=function(n,t){var r=n.constructor;return r?r[e()]||t:t},rn.unhandledRejection=function(n,t){I&&I.error("Uncaught (in promise)",L?t.longStack:j(n,t))},rn.rejectionHandled=tn,rn.enableLongStackTrace=function(){L=!0},rn.nextTick=F?function(n){E?new E(function(n){n()}).then(n):setTimeout(n)}:H.nextTick,rn._s=1;var on=a(999,function(n,t){var e,r;return(r=n._s!==U?t._onFulfilled:t._onRejected)===P?void x(t,n._s,n._v):(e=s(g)(r,n._v))===nn?void x(t,U,e.e):void k(t,e)}),un=a(9,function(n){m(n)||(n[J]=1,_(Z,n))});try{n.exports=rn}catch(cn){O.Yaku=rn}}()}).call(t,e(/*! ./../~/webpack/buildin/global.js */2))}});
}

if (!("flags"in RegExp.prototype
)) {

// RegExp.prototype.flags
/* global Get, ToBoolean, Type */
Object.defineProperty(RegExp.prototype, 'flags', {
        configurable: true,
        enumerable: false,
        get: function () {
                // 21.2.5.3.1 Let R be the this value.
                var R = this;

                // 21.2.5.3.2 If Type(R) is not Object, throw a TypeError exception.
                if (Type(R) !== 'object') {
                        throw new TypeError('Method called on incompatible type: must be an object.');
                }
                // 21.2.5.3.3 Let result be the empty String.
                var result = '';

                // 21.2.5.3.4 Let global be ToBoolean(? Get(R, "global")).
                var global = ToBoolean(Get(R, 'global'));

                // 21.2.5.3.5 If global is true, append the code unit 0x0067 (LATIN SMALL LETTER G) as the last code unit of result.
                if (global) {
                        result += 'g';
                }

                // 21.2.5.3.6 Let ignoreCase be ToBoolean(? Get(R, "ignoreCase")).
                var ignoreCase = ToBoolean(Get(R, 'ignoreCase'));

                // 21.2.5.3.7 If ignoreCase is true, append the code unit 0x0069 (LATIN SMALL LETTER I) as the last code unit of result.
                if (ignoreCase) {
                        result += 'i';
                }

                // 21.2.5.3.8 Let multiline be ToBoolean(? Get(R, "multiline")).
                var multiline = ToBoolean(Get(R, 'multiline'));

                // 21.2.5.3.9 If multiline is true, append the code unit 0x006D (LATIN SMALL LETTER M) as the last code unit of result.
                if (multiline) {
                        result += 'm';
                }

                // 21.2.5.3.10 Let unicode be ToBoolean(? Get(R, "unicode")).
                var unicode = ToBoolean(Get(R, 'unicode'));

                // 21.2.5.3.11 If unicode is true, append the code unit 0x0075 (LATIN SMALL LETTER U) as the last code unit of result.
                if (unicode) {
                        result += 'u';
                }

                // 21.2.5.3.12 Let sticky be ToBoolean(? Get(R, "sticky")).
                var sticky = ToBoolean(Get(R, 'sticky'));

                // 21.2.5.3.13 If sticky is true, append the code unit 0x0079 (LATIN SMALL LETTER Y) as the last code unit of result.
                if (sticky) {
                        result += 'y';
                }

                // 21.2.5.3.14 Return result.
                return result;
        }
});

}

if (!("fromCodePoint"in String&&1===String.fromCodePoint.length
)) {

// String.fromCodePoint
/* global CreateMethodProperty, IsArray, SameValue, ToInteger, ToNumber, UTF16Encoding */

// 21.1.2.2. String.fromCodePoint ( ...codePoints )
CreateMethodProperty(String, 'fromCodePoint', function fromCodePoint(_) { // eslint-disable-line no-unused-vars
        // Polyfill.io - List to store the characters whilst iterating over the code points.
        var result = [];
        // 1. Let codePoints be a List containing the arguments passed to this function.
        var codePoints = arguments;
        // 2. Let length be the number of elements in codePoints.
        var length = arguments.length;
        // 3. Let elements be a new empty List.
        var elements = [];
        // 4. Let nextIndex be 0.
        var nextIndex = 0;
        // 5. Repeat, while nextIndex < length
        while (nextIndex < length) {
                // Polyfill.io - We reset the elements List as we store the partial results in the result List.
                var elements = [];
                // a. Let next be codePoints[nextIndex].
                var next = codePoints[nextIndex];
                // b. Let nextCP be ? ToNumber(next).
                var nextCP = ToNumber(next);
                // c. If SameValue(nextCP, ToInteger(nextCP)) is false, throw a RangeError exception.
                if (SameValue(nextCP, ToInteger(nextCP)) === false) {
                        throw new RangeError('Invalid code point ' + Object.prototype.toString.call(nextCP));
                }
                // d. If nextCP < 0 or nextCP > 0x10FFFF, throw a RangeError exception.
                if (nextCP < 0 || nextCP > 0x10FFFF) {
                        throw new RangeError('Invalid code point ' + Object.prototype.toString.call(nextCP));
                }
                // e. Append the elements of the UTF16Encoding of nextCP to the end of elements.
                // Polyfill.io - UTF16Encoding can return a single codepoint or a list of multiple codepoints.
                var cp = UTF16Encoding(nextCP);
                if (IsArray(cp)) {
                        elements = elements.concat(cp);
                } else {
                        elements.push(cp);
                }
                // f. Let nextIndex be nextIndex + 1.
                nextIndex = nextIndex + 1;

                // Polyfill.io - Retrieving the characters whilst iterating enables the function to work in a memory efficient and performant way.
                result.push(String.fromCharCode.apply(null, elements));
        }
        // 6. Return the String value whose elements are, in order, the elements in the List elements. If length is 0, the empty string is returned.
        return length === 0 ? '' : result.join('');
});

}

if (!("codePointAt"in String.prototype
)) {

// String.prototype.codePointAt
/* global CreateMethodProperty, RequireObjectCoercible, ToInteger, ToString, UTF16Decode */
// 21.1.3.3. String.prototype.codePointAt ( pos )
CreateMethodProperty(String.prototype, 'codePointAt', function codePointAt(pos) {
        // 1. Let O be ? RequireObjectCoercible(this value).
        var O = RequireObjectCoercible(this);
        // 2. Let S be ? ToString(O).
        var S = ToString(O);
        // 3. Let position be ? ToInteger(pos).
        var position = ToInteger(pos);
        // 4. Let size be the length of S.
        var size = S.length;
        // 5. If position < 0 or position ≥ size, return undefined.
        if (position < 0 || position >= size) {
                return undefined;
        }
        // 6. Let first be the numeric value of the code unit at index position within the String S.
        var first = String.prototype.charCodeAt.call(S, position);
        // 7. If first < 0xD800 or first > 0xDBFF or position+1 = size, return first.
        if (first < 0xD800 || first > 0xDBFF || position + 1 === size) {
                return first;
        }
        // 8. Let second be the numeric value of the code unit at index position+1 within the String S.
        var second = String.prototype.charCodeAt.call(S, position + 1);
        // 9. If second < 0xDC00 or second > 0xDFFF, return first.
        if (second < 0xDC00 || second > 0xDFFF) {
                return first;
        }
        // 10. Return UTF16Decode(first, second).
        // 21.1.3.3.10 Return UTF16Decode(first, second).
        return UTF16Decode(first, second);
});

}

if (!("endsWith"in String.prototype
)) {

// String.prototype.endsWith
/* global CreateMethodProperty, IsRegExp, RequireObjectCoercible, ToInteger, ToString */
// 21.1.3.6. String.prototype.endsWith ( searchString [ , endPosition ] )
CreateMethodProperty(String.prototype, 'endsWith', function endsWith(searchString /* [ , endPosition ] */) {
        'use strict';
        var endPosition = arguments.length > 1 ? arguments[1] : undefined;
        // 1. Let O be ? RequireObjectCoercible(this value).
        var O = RequireObjectCoercible(this);
        // 2. Let S be ? ToString(O).
        var S = ToString(O);
        // 3. Let isRegExp be ? IsRegExp(searchString).
        var isRegExp = IsRegExp(searchString);
        // 4. If isRegExp is true, throw a TypeError exception.
        if (isRegExp) {
                throw new TypeError('First argument to String.prototype.endsWith must not be a regular expression');
        }
        // 5. Let searchStr be ? ToString(searchString).
        var searchStr = ToString(searchString);
        // 6. Let len be the length of S.
        var len = S.length;
        // 7. If endPosition is undefined, let pos be len, else let pos be ? ToInteger(endPosition).
        var pos = endPosition === undefined ? len : ToInteger(endPosition);
        // 8. Let end be min(max(pos, 0), len).
        var end = Math.min(Math.max(pos, 0), len);
        // 9. Let searchLength be the length of searchStr.
        var searchLength = searchStr.length;
        // 10. Let start be end - searchLength.
        var start = end - searchLength;
        // 11. If start is less than 0, return false.
        if (start < 0) {
                return false;
        }
        // 12. If the sequence of elements of S starting at start of length searchLength is the same as the full element sequence of searchStr, return true.
        if (S.substr(start, searchLength) === searchStr) {
                return true;
         }
        // 13. Otherwise, return false.
        return false;
});

}

if (!("includes"in String.prototype
)) {

// String.prototype.includes
/* global CreateMethodProperty, IsRegExp, RequireObjectCoercible, ToInteger, ToString */
// 21.1.3.7. String.prototype.includes ( searchString [ , position ] )
CreateMethodProperty(String.prototype, 'includes', function includes(searchString /* [ , position ] */) {
        'use strict';
        var position = arguments.length > 1 ? arguments[1] : undefined;
        // 1. Let O be ? RequireObjectCoercible(this value).
        var O = RequireObjectCoercible(this);
        // 2. Let S be ? ToString(O).
        var S = ToString(O);
        // 3. Let isRegExp be ? IsRegExp(searchString).
        var isRegExp = IsRegExp(searchString);
        // 4. If isRegExp is true, throw a TypeError exception.
        if (isRegExp) {
                throw new TypeError('First argument to String.prototype.includes must not be a regular expression');
        }
        // 5. Let searchStr be ? ToString(searchString).
        var searchStr = ToString(searchString);
        // 6. Let pos be ? ToInteger(position). (If position is undefined, this step produces the value 0.)
        var pos = ToInteger(position);
        // 7. Let len be the length of S.
        var len = S.length;
        // 8. Let start be min(max(pos, 0), len).
        var start = Math.min(Math.max(pos, 0), len);
        // 9. Let searchLen be the length of searchStr.
        // var searchLength = searchStr.length;
        // 10. If there exists any integer k not smaller than start such that k + searchLen is not greater than len, and for all nonnegative integers j less than searchLen, the code unit at index k+j within S is the same as the code unit at index j within searchStr, return true; but if there is no such integer k, return false.
        return String.prototype.indexOf.call(S, searchStr, start) !== -1;
});

}

if (!("repeat"in String.prototype
)) {

// String.prototype.repeat
/* global CreateMethodProperty, RequireObjectCoercible, ToInteger, ToString */
// 21.1.3.15String.prototype.repeat ( count )
CreateMethodProperty(String.prototype, 'repeat', function repeat(count) {
        'use strict';
        // 1. Let O be ? RequireObjectCoercible(this value).
        var O = RequireObjectCoercible(this);
        // 2. Let S be ? ToString(O).
        var S = ToString(O);
        // 3. Let n be ? ToInteger(count).
        var n = ToInteger(count);
        // 4. If n < 0, throw a RangeError exception.
        if (n < 0) {
                throw new RangeError('Invalid count value');
        }
        // 5. If n is +∞, throw a RangeError exception.
        if (n === Infinity) {
                throw new RangeError('Invalid count value');
        }
        // 6. Let T be the String value that is made from n copies of S appended together. If n is 0, T is the empty String.
        var T = n === 0 ? '' : new Array(n + 1).join(S);
        // 7. Return T.
        return T;
});

}

if (!("startsWith"in String.prototype
)) {

// String.prototype.startsWith
/* global CreateMethodProperty, IsRegExp, RequireObjectCoercible, ToInteger, ToString */
// 21.1.3.20. String.prototype.startsWith ( searchString [ , position ] )
CreateMethodProperty(String.prototype, 'startsWith', function startsWith(searchString /* [ , position ] */) {
        'use strict';
        var position = arguments.length > 1 ? arguments[1] : undefined;
        // 1. Let O be ? RequireObjectCoercible(this value).
        var O = RequireObjectCoercible(this);
        // 2. Let S be ? ToString(O).
        var S = ToString(O);
        // 3. Let isRegExp be ? IsRegExp(searchString).
        var isRegExp = IsRegExp(searchString);
        // 4. If isRegExp is true, throw a TypeError exception.
        if (isRegExp) {
                throw new TypeError('First argument to String.prototype.startsWith must not be a regular expression');
        }
        // 5. Let searchStr be ? ToString(searchString).
        var searchStr = ToString(searchString);
        // 6. Let pos be ? ToInteger(position). (If position is undefined, this step produces the value 0.)
        var pos = ToInteger(position);
        // 7. Let len be the length of S.
        var len = S.length;
        // 8. Let start be min(max(pos, 0), len).
        var start = Math.min(Math.max(pos, 0), len);
        // 9. Let searchLength be the length of searchStr.
        var searchLength = searchStr.length;
        // 10. If searchLength+start is greater than len, return false.
        if (searchLength + start > len) {
                return false;
        }
        // 11. If the sequence of elements of S starting at start of length searchLength is the same as the full element sequence of searchStr, return true.
        if (S.substr(start).indexOf(searchString) === 0) {
                return true;
        }
        // 12. Otherwise, return false.
        return false;
});

}

if (!("Symbol"in this&&0===this.Symbol.length
)) {

// Symbol
// A modification of https://github.com/WebReflection/get-own-property-symbols
// (C) Andrea Giammarchi - MIT Licensed

(function (Object, GOPS, global) {
        'use strict'; //so that ({}).toString.call(null) returns the correct [object Null] rather than [object Window]

        var     setDescriptor;
        var id = 0;
        var random = '' + Math.random();
        var prefix = '__\x01symbol:';
        var prefixLength = prefix.length;
        var internalSymbol = '__\x01symbol@@' + random;
        var DP = 'defineProperty';
        var DPies = 'defineProperties';
        var GOPN = 'getOwnPropertyNames';
        var GOPD = 'getOwnPropertyDescriptor';
        var PIE = 'propertyIsEnumerable';
        var ObjectProto = Object.prototype;
        var hOP = ObjectProto.hasOwnProperty;
        var pIE = ObjectProto[PIE];
        var toString = ObjectProto.toString;
        var concat = Array.prototype.concat;
        var cachedWindowNames = Object.getOwnPropertyNames ? Object.getOwnPropertyNames(window) : [];
        var nGOPN = Object[GOPN];
        var gOPN = function getOwnPropertyNames (obj) {
                if (toString.call(obj) === '[object Window]') {
                        try {
                                return nGOPN(obj);
                        } catch (e) {
                                // IE bug where layout engine calls userland gOPN for cross-domain `window` objects
                                return concat.call([], cachedWindowNames);
                        }
                }
                return nGOPN(obj);
        };
        var gOPD = Object[GOPD];
        var create = Object.create;
        var keys = Object.keys;
        var freeze = Object.freeze || Object;
        var defineProperty = Object[DP];
        var $defineProperties = Object[DPies];
        var descriptor = gOPD(Object, GOPN);
        var addInternalIfNeeded = function (o, uid, enumerable) {
                if (!hOP.call(o, internalSymbol)) {
                        try {
                                defineProperty(o, internalSymbol, {
                                        enumerable: false,
                                        configurable: false,
                                        writable: false,
                                        value: {}
                                });
                        } catch (e) {
                                o[internalSymbol] = {};
                        }
                }
                o[internalSymbol]['@@' + uid] = enumerable;
        };
        var createWithSymbols = function (proto, descriptors) {
                var self = create(proto);
                gOPN(descriptors).forEach(function (key) {
                        if (propertyIsEnumerable.call(descriptors, key)) {
                                $defineProperty(self, key, descriptors[key]);
                        }
                });
                return self;
        };
        var copyAsNonEnumerable = function (descriptor) {
                var newDescriptor = create(descriptor);
                newDescriptor.enumerable = false;
                return newDescriptor;
        };
        var get = function get(){};
        var onlyNonSymbols = function (name) {
                return name != internalSymbol &&
                        !hOP.call(source, name);
        };
        var onlySymbols = function (name) {
                return name != internalSymbol &&
                        hOP.call(source, name);
        };
        var propertyIsEnumerable = function propertyIsEnumerable(key) {
                var uid = '' + key;
                return onlySymbols(uid) ? (
                        hOP.call(this, uid) &&
                        this[internalSymbol]['@@' + uid]
                ) : pIE.call(this, key);
        };
        var setAndGetSymbol = function (uid) {
                var descriptor = {
                        enumerable: false,
                        configurable: true,
                        get: get,
                        set: function (value) {
                        setDescriptor(this, uid, {
                                enumerable: false,
                                configurable: true,
                                writable: true,
                                value: value
                        });
                        addInternalIfNeeded(this, uid, true);
                        }
                };
                try {
                        defineProperty(ObjectProto, uid, descriptor);
                } catch (e) {
                        ObjectProto[uid] = descriptor.value;
                }
                return freeze(source[uid] = defineProperty(
                        Object(uid),
                        'constructor',
                        sourceConstructor
                ));
        };
        var Symbol = function Symbol() {
                var description = arguments[0];
                if (this instanceof Symbol) {
                        throw new TypeError('Symbol is not a constructor');
                }
                return setAndGetSymbol(
                        prefix.concat(description || '', random, ++id)
                );
                };
        var source = create(null);
        var sourceConstructor = {value: Symbol};
        var sourceMap = function (uid) {
                return source[uid];
                };
        var $defineProperty = function defineProp(o, key, descriptor) {
                var uid = '' + key;
                if (onlySymbols(uid)) {
                        setDescriptor(o, uid, descriptor.enumerable ?
                                copyAsNonEnumerable(descriptor) : descriptor);
                        addInternalIfNeeded(o, uid, !!descriptor.enumerable);
                } else {
                        defineProperty(o, key, descriptor);
                }
                return o;
        };

        var onlyInternalSymbols = function (obj) {
                return function (name) {
                        return hOP.call(obj, internalSymbol) && hOP.call(obj[internalSymbol], '@@' + name);
                };
        };
        var $getOwnPropertySymbols = function getOwnPropertySymbols(o) {
                return gOPN(o).filter(o === ObjectProto ? onlyInternalSymbols(o) : onlySymbols).map(sourceMap);
                }
        ;

        descriptor.value = $defineProperty;
        defineProperty(Object, DP, descriptor);

        descriptor.value = $getOwnPropertySymbols;
        defineProperty(Object, GOPS, descriptor);

        descriptor.value = function getOwnPropertyNames(o) {
                return gOPN(o).filter(onlyNonSymbols);
        };
        defineProperty(Object, GOPN, descriptor);

        descriptor.value = function defineProperties(o, descriptors) {
                var symbols = $getOwnPropertySymbols(descriptors);
                if (symbols.length) {
                keys(descriptors).concat(symbols).forEach(function (uid) {
                        if (propertyIsEnumerable.call(descriptors, uid)) {
                        $defineProperty(o, uid, descriptors[uid]);
                        }
                });
                } else {
                $defineProperties(o, descriptors);
                }
                return o;
        };
        defineProperty(Object, DPies, descriptor);

        descriptor.value = propertyIsEnumerable;
        defineProperty(ObjectProto, PIE, descriptor);

        descriptor.value = Symbol;
        defineProperty(global, 'Symbol', descriptor);

        // defining `Symbol.for(key)`
        descriptor.value = function (key) {
                var uid = prefix.concat(prefix, key, random);
                return uid in ObjectProto ? source[uid] : setAndGetSymbol(uid);
        };
        defineProperty(Symbol, 'for', descriptor);

        // defining `Symbol.keyFor(symbol)`
        descriptor.value = function (symbol) {
                if (onlyNonSymbols(symbol))
                throw new TypeError(symbol + ' is not a symbol');
                return hOP.call(source, symbol) ?
                symbol.slice(prefixLength * 2, -random.length) :
                void 0
                ;
        };
        defineProperty(Symbol, 'keyFor', descriptor);

        descriptor.value = function getOwnPropertyDescriptor(o, key) {
                var descriptor = gOPD(o, key);
                if (descriptor && onlySymbols(key)) {
                descriptor.enumerable = propertyIsEnumerable.call(o, key);
                }
                return descriptor;
        };
        defineProperty(Object, GOPD, descriptor);

        descriptor.value = function (proto, descriptors) {
                return arguments.length === 1 || typeof descriptors === "undefined" ?
                create(proto) :
                createWithSymbols(proto, descriptors);
        };
        defineProperty(Object, 'create', descriptor);

        var strictModeSupported = (function(){ 'use strict'; return this; }).call(null) === null;
        if (strictModeSupported) {
                descriptor.value = function () {
                        var str = toString.call(this);
                        return (str === '[object String]' && onlySymbols(this)) ? '[object Symbol]' : str;
                };
        } else {
                descriptor.value = function () {
                        // https://github.com/Financial-Times/polyfill-library/issues/164#issuecomment-486965300
                        // Polyfill.io this code is here for the situation where a browser does not
                        // support strict mode and is executing `Object.prototype.toString.call(null)`.
                        // This code ensures that we return the correct result in that situation however,
                        // this code also introduces a bug where it will return the incorrect result for
                        // `Object.prototype.toString.call(window)`. We can't have the correct result for
                        // both `window` and `null`, so we have opted for `null` as we believe this is the more 
                        // common situation. 
                        if (this === window) {
                                return '[object Null]';
                        }

                        var str = toString.call(this);
                        return (str === '[object String]' && onlySymbols(this)) ? '[object Symbol]' : str;
                };
        }
        defineProperty(ObjectProto, 'toString', descriptor);

        setDescriptor = function (o, key, descriptor) {
                var protoDescriptor = gOPD(ObjectProto, key);
                delete ObjectProto[key];
                defineProperty(o, key, descriptor);
                if (o !== ObjectProto) {
                        defineProperty(ObjectProto, key, protoDescriptor);
                }
        };

}(Object, 'getOwnPropertySymbols', this));

}

if (!("Symbol"in this&&"hasInstance"in this.Symbol
)) {

// Symbol.hasInstance
/* global Symbol */
Object.defineProperty(Symbol, 'hasInstance', { value: Symbol('hasInstance') });

}

if (!("Symbol"in this&&"isConcatSpreadable"in this.Symbol
)) {

// Symbol.isConcatSpreadable
/* global Symbol */
Object.defineProperty(Symbol, 'isConcatSpreadable', { value: Symbol('isConcatSpreadable') });

}

if (!("Symbol"in this&&"iterator"in this.Symbol
)) {

// Symbol.iterator
/* global Symbol */
Object.defineProperty(Symbol, 'iterator', { value: Symbol('iterator') });

}


// _ESAbstract.GetIterator
/* global GetMethod, Symbol, Call, Type, GetV */
// 7.4.1. GetIterator ( obj [ , method ] )
// The abstract operation GetIterator with argument obj and optional argument method performs the following steps:
function GetIterator(obj /*, method */) { // eslint-disable-line no-unused-vars
        // 1. If method is not present, then
                // a. Set method to ? GetMethod(obj, @@iterator).
        var method = arguments.length > 1 ? arguments[1] : GetMethod(obj, Symbol.iterator);
        // 2. Let iterator be ? Call(method, obj).
        var iterator = Call(method, obj);
        // 3. If Type(iterator) is not Object, throw a TypeError exception.
        if (Type(iterator) !== 'object') {
                throw new TypeError('bad iterator');
        }
        // 4. Let nextMethod be ? GetV(iterator, "next").
        var nextMethod = GetV(iterator, "next");
        // 5. Let iteratorRecord be Record {[[Iterator]]: iterator, [[NextMethod]]: nextMethod, [[Done]]: false}.
        var iteratorRecord = Object.create(null);
        iteratorRecord['[[Iterator]]'] = iterator;
        iteratorRecord['[[NextMethod]]'] = nextMethod;
        iteratorRecord['[[Done]]'] = false;
        // 6. Return iteratorRecord.
        return iteratorRecord;
}
if (!("Symbol"in this&&"match"in this.Symbol
)) {

// Symbol.match
/* global Symbol */
Object.defineProperty(Symbol, 'match', { value: Symbol('match') });

}

if (!("Symbol"in this&&"replace"in this.Symbol
)) {

// Symbol.replace
/* global Symbol */
Object.defineProperty(Symbol, 'replace', { value: Symbol('replace') });

}

if (!("Symbol"in this&&"search"in this.Symbol
)) {

// Symbol.search
/* global Symbol */
Object.defineProperty(Symbol, 'search', { value: Symbol('search') });

}

if (!("Symbol"in this&&"species"in this.Symbol
)) {

// Symbol.species
/* global Symbol */
Object.defineProperty(Symbol, 'species', { value: Symbol('species') });

}

if (!("Map"in this&&function(t){try{var n=new Map([[1,1],[2,2]])
return 0===Map.length&&2===n.size&&"Symbol"in t&&"iterator"in Symbol&&"function"==typeof n[Symbol.iterator]}catch(i){return!1}}(this)
)) {

// Map
/* global CreateIterResultObject, CreateMethodProperty, GetIterator, IsCallable, IteratorClose, IteratorStep, IteratorValue, OrdinaryCreateFromConstructor, SameValueZero, Type, Symbol */
(function (global) {
        var supportsGetters = (function () {
                try {
                        var a = {};
                        Object.defineProperty(a, 't', {
                                configurable: true,
                                enumerable: false,
                                get: function () {
                                        return true;
                                },
                                set: undefined
                        });
                        return !!a.t;
                } catch (e) {
                        return false;
                }
        }());

        // Deleted map items mess with iterator pointers, so rather than removing them mark them as deleted. Can't use undefined or null since those both valid keys so use a private symbol.
        var undefMarker = Symbol('undef');
        // 23.1.1.1 Map ( [ iterable ] )
        var Map = function Map(/* iterable */) {
                // 1. If NewTarget is undefined, throw a TypeError exception.
                if (!(this instanceof Map)) {
                        throw new TypeError('Constructor Map requires "new"');
                }
                // 2. Let map be ? OrdinaryCreateFromConstructor(NewTarget, "%MapPrototype%", « [[MapData]] »).
                var map = OrdinaryCreateFromConstructor(this, Map.prototype, {
                        _keys: [],
                        _values: [],
                        _size: 0,
                        _es6Map: true
                });

                // 3. Set map.[[MapData]] to a new empty List.
                // Polyfill.io - This step was done as part of step two.

                // Some old engines do not support ES5 getters/setters.  Since Map only requires these for the size property, we can fall back to setting the size property statically each time the size of the map changes.
                if (!supportsGetters) {
                        Object.defineProperty(map, 'size', {
                                configurable: true,
                                enumerable: false,
                                writable: true,
                                value: 0
                        });
                }

                // 4. If iterable is not present, let iterable be undefined.
                var iterable = arguments.length > 0 ? arguments[0] : undefined;

                // 5. If iterable is either undefined or null, return map.
                if (iterable === null || iterable === undefined) {
                        return map;
                }

                // 6. Let adder be ? Get(map, "set").
                var adder = map.set;

                // 7. If IsCallable(adder) is false, throw a TypeError exception.
                if (!IsCallable(adder)) {
                        throw new TypeError("Map.prototype.set is not a function");
                }

                // 8. Let iteratorRecord be ? GetIterator(iterable).
                try {
                        var iteratorRecord = GetIterator(iterable);
                        // 9. Repeat,
                        while (true) {
                                // a. Let next be ? IteratorStep(iteratorRecord).
                                var next = IteratorStep(iteratorRecord);
                                // b. If next is false, return map.
                                if (next === false) {
                                        return map;
                                }
                                // c. Let nextItem be ? IteratorValue(next).
                                var nextItem = IteratorValue(next);
                                // d. If Type(nextItem) is not Object, then
                                if (Type(nextItem) !== 'object') {
                                        // i. Let error be Completion{[[Type]]: throw, [[Value]]: a newly created TypeError object, [[Target]]: empty}.
                                        try {
                                                throw new TypeError('Iterator value ' + nextItem + ' is not an entry object');
                                        } catch (error) {
                                                // ii. Return ? IteratorClose(iteratorRecord, error).
                                                return IteratorClose(iteratorRecord, error);
                                        }
                                }
                                try {
                                        // Polyfill.io - The try catch accounts for steps: f, h, and j.

                                        // e. Let k be Get(nextItem, "0").
                                        var k = nextItem[0];
                                        // f. If k is an abrupt completion, return ? IteratorClose(iteratorRecord, k).
                                        // g. Let v be Get(nextItem, "1").
                                        var v = nextItem[1];
                                        // h. If v is an abrupt completion, return ? IteratorClose(iteratorRecord, v).
                                        // i. Let status be Call(adder, map, « k.[[Value]], v.[[Value]] »).
                                        adder.call(map, k, v);
                                } catch (e) {
                                        // j. If status is an abrupt completion, return ? IteratorClose(iteratorRecord, status).
                                        return IteratorClose(iteratorRecord, e);
                                }
                        }
                } catch (e) {
                        // Polyfill.io - For user agents which do not have iteration methods on argument objects or arrays, we can special case those.
                        if (Array.isArray(iterable) ||
                                Object.prototype.toString.call(iterable) === '[object Arguments]' ||
                                // IE 7 & IE 8 return '[object Object]' for the arguments object, we can detect by checking for the existence of the callee property
                                (!!iterable.callee)) {
                                var index;
                                var length = iterable.length;
                                for (index = 0; index < length; index++) {
                                        adder.call(map, iterable[index][0], iterable[index][1]);
                                }
                        }
                }
                return map;
        };

        // 23.1.2.1. Map.prototype
        // The initial value of Map.prototype is the intrinsic object %MapPrototype%.
        // This property has the attributes { [[Writable]]: false, [[Enumerable]]: false, [[Configurable]]: false }.
        Object.defineProperty(Map, 'prototype', {
                configurable: false,
                enumerable: false,
                writable: false,
                value: {}
        });

        // 23.1.2.2 get Map [ @@species ]
        if (supportsGetters) {
                Object.defineProperty(Map, Symbol.species, {
                        configurable: true,
                        enumerable: false,
                        get: function () {
                                // 1. Return the this value.
                                return this;
                        },
                        set: undefined
                });
        } else {
                CreateMethodProperty(Map, Symbol.species, Map);
        }

        // 23.1.3.1 Map.prototype.clear ( )
        CreateMethodProperty(Map.prototype, 'clear', function clear() {
                        // 1. Let M be the this value.
                        var M = this;
                        // 2. If Type(M) is not Object, throw a TypeError exception.
                        if (Type(M) !== 'object') {
                                throw new TypeError('Method Map.prototype.clear called on incompatible receiver ' + Object.prototype.toString.call(M));
                        }
                        // 3. If M does not have a [[MapData]] internal slot, throw a TypeError exception.
                        if (M._es6Map !== true) {
                                throw new TypeError('Method Map.prototype.clear called on incompatible receiver ' + Object.prototype.toString.call(M));
                        }
                        // 4. Let entries be the List that is M.[[MapData]].
                        var entries = M._keys;
                        // 5. For each Record {[[Key]], [[Value]]} p that is an element of entries, do
                        for (var i = 0; i < entries.length; i++) {
                                // 5.a. Set p.[[Key]] to empty.
                                M._keys[i] = undefMarker;
                                // 5.b. Set p.[[Value]] to empty.
                                M._values[i] = undefMarker;
                        }
                        this._size = 0;
                        if (!supportsGetters) {
                                this.size = this._size;
                        }
                        // 6. Return undefined.
                        return undefined;
                }
        );

        // 23.1.3.2. Map.prototype.constructor
        CreateMethodProperty(Map.prototype, 'constructor', Map);

        // 23.1.3.3. Map.prototype.delete ( key )
        CreateMethodProperty(Map.prototype, 'delete', function (key) {
                        // 1. Let M be the this value.
                        var M = this;
                        // 2. If Type(M) is not Object, throw a TypeError exception.
                        if (Type(M) !== 'object') {
                                throw new TypeError('Method Map.prototype.clear called on incompatible receiver ' + Object.prototype.toString.call(M));
                        }
                        // 3. If M does not have a [[MapData]] internal slot, throw a TypeError exception.
                        if (M._es6Map !== true) {
                                throw new TypeError('Method Map.prototype.clear called on incompatible receiver ' + Object.prototype.toString.call(M));
                        }
                        // 4. Let entries be the List that is M.[[MapData]].
                        var entries = M._keys;
                        // 5. For each Record {[[Key]], [[Value]]} p that is an element of entries, do
                        for (var i = 0; i < entries.length; i++) {
                                // a. If p.[[Key]] is not empty and SameValueZero(p.[[Key]], key) is true, then
                                if (M._keys[i] !== undefMarker && SameValueZero(M._keys[i], key)) {
                                        // i. Set p.[[Key]] to empty.
                                        this._keys[i] = undefMarker;
                                        // ii. Set p.[[Value]] to empty.
                                        this._values[i] = undefMarker;
                                        this._size = --this._size;
                                        if (!supportsGetters) {
                                                this.size = this._size;
                                        }
                                        // iii. Return true.
                                        return true;
                                }
                        }
                        // 6. Return false.
                        return false;
                }
        );

        // 23.1.3.4. Map.prototype.entries ( )
        CreateMethodProperty(Map.prototype, 'entries', function entries () {
                        // 1. Let M be the this value.
                        var M = this;
                        // 2. Return ? CreateMapIterator(M, "key+value").
                        return CreateMapIterator(M, 'key+value');
                }
        );

        // 23.1.3.5. Map.prototype.forEach ( callbackfn [ , thisArg ] )
        CreateMethodProperty(Map.prototype, 'forEach', function (callbackFn) {
                        // 1. Let M be the this value.
                        var M = this;
                        // 2. If Type(M) is not Object, throw a TypeError exception.
                        if (Type(M) !== 'object') {
                                throw new TypeError('Method Map.prototype.forEach called on incompatible receiver ' + Object.prototype.toString.call(M));
                        }
                        // 3. If M does not have a [[MapData]] internal slot, throw a TypeError exception.
                        if (M._es6Map !== true) {
                                throw new TypeError('Method Map.prototype.forEach called on incompatible receiver ' + Object.prototype.toString.call(M));
                        }
                        // 4. If IsCallable(callbackfn) is false, throw a TypeError exception.
                        if (!IsCallable(callbackFn)) {
                                throw new TypeError(Object.prototype.toString.call(callbackFn) + ' is not a function.');
                        }
                        // 5. If thisArg is present, let T be thisArg; else let T be undefined.
                        if (arguments[1]) {
                                var T = arguments[1];
                        }
                        // 6. Let entries be the List that is M.[[MapData]].
                        var entries = M._keys;
                        // 7. For each Record {[[Key]], [[Value]]} e that is an element of entries, in original key insertion order, do
                        for (var i = 0; i < entries.length; i++) {
                                // a. If e.[[Key]] is not empty, then
                                if (M._keys[i] !== undefMarker && M._values[i] !== undefMarker ) {
                                        // i. Perform ? Call(callbackfn, T, « e.[[Value]], e.[[Key]], M »).
                                        callbackFn.call(T, M._values[i], M._keys[i], M);
                                }
                        }
                        // 8. Return undefined.
                        return undefined;
                }
        );

        // 23.1.3.6. Map.prototype.get ( key )
        CreateMethodProperty(Map.prototype, 'get', function get(key) {
                        // 1. Let M be the this value.
                        var M = this;
                        // 2. If Type(M) is not Object, throw a TypeError exception.
                        if (Type(M) !== 'object') {
                                throw new TypeError('Method Map.prototype.get called on incompatible receiver ' + Object.prototype.toString.call(M));
                        }
                        // 3. If M does not have a [[MapData]] internal slot, throw a TypeError exception.
                        if (M._es6Map !== true) {
                                throw new TypeError('Method Map.prototype.get called on incompatible receiver ' + Object.prototype.toString.call(M));
                        }
                        // 4. Let entries be the List that is M.[[MapData]].
                        var entries = M._keys;
                        // 5. For each Record {[[Key]], [[Value]]} p that is an element of entries, do
                        for (var i = 0; i < entries.length; i++) {
                                // a. If p.[[Key]] is not empty and SameValueZero(p.[[Key]], key) is true, return p.[[Value]].
                                if (M._keys[i] !== undefMarker && SameValueZero(M._keys[i], key)) {
                                        return M._values[i];
                                }
                        }
                        // 6. Return undefined.
                        return undefined;
                });

        // 23.1.3.7. Map.prototype.has ( key )
        CreateMethodProperty(Map.prototype, 'has', function has (key) {
                        // 1. Let M be the this value.
                        var M = this;
                        // 2. If Type(M) is not Object, throw a TypeError exception.
                        if (typeof M !== 'object') {
                                throw new TypeError('Method Map.prototype.has called on incompatible receiver ' + Object.prototype.toString.call(M));
                        }
                        // 3. If M does not have a [[MapData]] internal slot, throw a TypeError exception.
                        if (M._es6Map !== true) {
                                throw new TypeError('Method Map.prototype.has called on incompatible receiver ' + Object.prototype.toString.call(M));
                        }
                        // 4. Let entries be the List that is M.[[MapData]].
                        var entries = M._keys;
                        // 5. For each Record {[[Key]], [[Value]]} p that is an element of entries, do
                        for (var i = 0; i < entries.length; i++) {
                                // a. If p.[[Key]] is not empty and SameValueZero(p.[[Key]], key) is true, return true.
                                if (M._keys[i] !== undefMarker && SameValueZero(M._keys[i], key)) {
                                        return true;
                                }
                        }
                        // 6. Return false.
                        return false;
                });

        // 23.1.3.8. Map.prototype.keys ( )
        CreateMethodProperty(Map.prototype, 'keys', function keys () {
                        // 1. Let M be the this value.
                        var M = this;
                        // 2. Return ? CreateMapIterator(M, "key").
                        return CreateMapIterator(M, "key");
                });

        // 23.1.3.9. Map.prototype.set ( key, value )
        CreateMethodProperty(Map.prototype, 'set', function set(key, value) {
                        // 1. Let M be the this value.
                        var M = this;
                        // 2. If Type(M) is not Object, throw a TypeError exception.
                        if (Type(M) !== 'object') {
                                throw new TypeError('Method Map.prototype.set called on incompatible receiver ' + Object.prototype.toString.call(M));
                        }
                        // 3. If M does not have a [[MapData]] internal slot, throw a TypeError exception.
                        if (M._es6Map !== true) {
                                throw new TypeError('Method Map.prototype.set called on incompatible receiver ' + Object.prototype.toString.call(M));
                        }
                        // 4. Let entries be the List that is M.[[MapData]].
                        var entries = M._keys;
                        // 5. For each Record {[[Key]], [[Value]]} p that is an element of entries, do
                        for (var i = 0; i < entries.length; i++) {
                                // a. If p.[[Key]] is not empty and SameValueZero(p.[[Key]], key) is true, then
                                if (M._keys[i] !== undefMarker && SameValueZero(M._keys[i], key)) {
                                        // i. Set p.[[Value]] to value.
                                        M._values[i] = value;
                                        // Return M.
                                        return M;
                                }
                        }
                        // 6. If key is -0, let key be +0.
                        if (key === -0) {
                                key = 0;
                        }
                        // 7. Let p be the Record {[[Key]]: key, [[Value]]: value}.
                        var p = {};
                        p['[[Key]]'] = key;
                        p['[[Value]]'] = value;
                        // 8. Append p as the last element of entries.
                        M._keys.push(p['[[Key]]']);
                        M._values.push(p['[[Value]]']);
                        ++M._size;
                        if (!supportsGetters) {
                                M.size = M._size;
                        }
                        // 9. Return M.
                        return M;
                });

        // 23.1.3.10. get Map.prototype.size
        if (supportsGetters) {
                Object.defineProperty(Map.prototype, 'size', {
                        configurable: true,
                        enumerable: false,
                        get: function () {
                                // 1. Let M be the this value.
                                var M = this;
                                // 2. If Type(M) is not Object, throw a TypeError exception.
                                if (Type(M) !== 'object') {
                                        throw new TypeError('Method Map.prototype.size called on incompatible receiver ' + Object.prototype.toString.call(M));
                                }
                                // 3. If M does not have a [[MapData]] internal slot, throw a TypeError exception.
                                if (M._es6Map !== true) {
                                        throw new TypeError('Method Map.prototype.size called on incompatible receiver ' + Object.prototype.toString.call(M));
                                }
                                // 4. Let entries be the List that is M.[[MapData]].
                                var entries = M._keys;
                                // 5. Let count be 0.
                                var count = 0;
                                // 6. For each Record {[[Key]], [[Value]]} p that is an element of entries, do
                                for (var i = 0; i < entries.length; i++) {
                                        // a. If p.[[Key]] is not empty, set count to count+1.
                                        if (M._keys[i] !== undefMarker) {
                                                count = count + 1;
                                        }
                                }
                                // 7. Return count.
                                return count;
                        },
                        set: undefined
                });
        }

        // 23.1.3.11. Map.prototype.values ( )
        CreateMethodProperty(Map.prototype, 'values', function values () {
                        // 1. Let M be the this value.
                        var M = this;
                        // 2. Return ? CreateMapIterator(M, "value").
                        return CreateMapIterator(M, 'value');
                }
        );

        // 23.1.3.12. Map.prototype [ @@iterator ] ( )
        // The initial value of the @@iterator property is the same function object as the initial value of the entries property.
        CreateMethodProperty(Map.prototype, Symbol.iterator, Map.prototype.entries);

        // 23.1.3.13. Map.prototype [ @@toStringTag ]
        // The initial value of the @@toStringTag property is the String value "Map".
        // This property has the attributes { [[Writable]]: false, [[Enumerable]]: false, [[Configurable]]: true }.

        // Polyfill.io - Safari 8 implements Map.name but as a non-configurable property, which means it would throw an error if we try and configure it here.
        if (!('name' in Map)) {
                // 19.2.4.2 name
                Object.defineProperty(Map, 'name', {
                        configurable: true,
                        enumerable: false,
                        writable: false,
                        value: 'Map'
                });
        }

        // 23.1.5.1. CreateMapIterator ( map, kind )
        function CreateMapIterator(map, kind) {
                // 1. If Type(map) is not Object, throw a TypeError exception.
                if (Type(map) !== 'object') {
                        throw new TypeError('createMapIterator called on incompatible receiver ' + Object.prototype.toString.call(map));
                }
                // 2. If map does not have a [[MapData]] internal slot, throw a TypeError exception.
                if (map._es6Map !== true) {
                        throw new TypeError('createMapIterator called on incompatible receiver ' + Object.prototype.toString.call(map));
                }
                // 3. Let iterator be ObjectCreate(%MapIteratorPrototype%, « [[Map]], [[MapNextIndex]], [[MapIterationKind]] »).
                var iterator = Object.create(MapIteratorPrototype);
                // 4. Set iterator.[[Map]] to map.
                Object.defineProperty(iterator, '[[Map]]', {
                        configurable: true,
                        enumerable: false,
                        writable: true,
                        value: map
                });
                // 5. Set iterator.[[MapNextIndex]] to 0.
                Object.defineProperty(iterator, '[[MapNextIndex]]', {
                        configurable: true,
                        enumerable: false,
                        writable: true,
                        value: 0
                });
                // 6. Set iterator.[[MapIterationKind]] to kind.
                Object.defineProperty(iterator, '[[MapIterationKind]]', {
                        configurable: true,
                        enumerable: false,
                        writable: true,
                        value: kind
                });
                // 7. Return iterator.
                return iterator;
        }

        // 23.1.5.2. The %MapIteratorPrototype% Object
        var MapIteratorPrototype = {};
        // Polyfill.io - We use this as a quick way to check if an object is a Map Iterator instance.
        Object.defineProperty(MapIteratorPrototype, 'isMapIterator', {
                configurable: false,
                enumerable: false,
                writable: false,
                value: true
        });

        // 23.1.5.2.1. %MapIteratorPrototype%.next ( )
        CreateMethodProperty(MapIteratorPrototype, 'next', function next() {
                        // 1. Let O be the this value.
                        var O = this;
                        // 2. If Type(O) is not Object, throw a TypeError exception.
                        if (Type(O) !== 'object') {
                                throw new TypeError('Method %MapIteratorPrototype%.next called on incompatible receiver ' + Object.prototype.toString.call(O));
                        }
                        // 3. If O does not have all of the internal slots of a Map Iterator Instance (23.1.5.3), throw a TypeError exception.
                        if (!O.isMapIterator) {
                                throw new TypeError('Method %MapIteratorPrototype%.next called on incompatible receiver ' + Object.prototype.toString.call(O));
                        }
                        // 4. Let m be O.[[Map]].
                        var m = O['[[Map]]'];
                        // 5. Let index be O.[[MapNextIndex]].
                        var index = O['[[MapNextIndex]]'];
                        // 6. Let itemKind be O.[[MapIterationKind]].
                        var itemKind = O['[[MapIterationKind]]'];
                        // 7. If m is undefined, return CreateIterResultObject(undefined, true).
                        if (m === undefined) {
                                return CreateIterResultObject(undefined, true);
                        }
                        // 8. Assert: m has a [[MapData]] internal slot.
                        if (!m._es6Map) {
                                throw new Error(Object.prototype.toString.call(m) + ' has a [[MapData]] internal slot.');
                        }
                        // 9. Let entries be the List that is m.[[MapData]].
                        var entries = m._keys;
                        // 10. Let numEntries be the number of elements of entries.
                        var numEntries = entries.length;
                        // 11. NOTE: numEntries must be redetermined each time this method is evaluated.
                        // 12. Repeat, while index is less than numEntries,
                        while (index < numEntries) {
                                // a. Let e be the Record {[[Key]], [[Value]]} that is the value of entries[index].
                                var e = Object.create(null);
                                e['[[Key]]'] = m._keys[index];
                                e['[[Value]]'] = m._values[index];
                                // b. Set index to index+1.
                                index = index + 1;
                                // c. Set O.[[MapNextIndex]] to index.
                                O['[[MapNextIndex]]'] = index;
                                // d. If e.[[Key]] is not empty, then
                                if (e['[[Key]]'] !== undefMarker) {
                                        // i. If itemKind is "key", let result be e.[[Key]].
                                        if (itemKind === 'key') {
                                                var result = e['[[Key]]'];
                                                // ii. Else if itemKind is "value", let result be e.[[Value]].
                                        } else if (itemKind === 'value') {
                                                result = e['[[Value]]'];
                                                // iii. Else,
                                        } else {
                                                // 1. Assert: itemKind is "key+value".
                                                if (itemKind !== 'key+value') {
                                                        throw new Error();
                                                }
                                                // 2. Let result be CreateArrayFromList(« e.[[Key]], e.[[Value]] »).
                                                result = [
                                                        e['[[Key]]'],
                                                        e['[[Value]]']
                                                ];
                                        }
                                        // iv. Return CreateIterResultObject(result, false).
                                        return CreateIterResultObject(result, false);
                                }
                        }
                        // 13. Set O.[[Map]] to undefined.
                        O['[[Map]]'] = undefined;
                        // 14. Return CreateIterResultObject(undefined, true).
                        return CreateIterResultObject(undefined, true);
                }
        );

        // 23.1.5.2.2 %MapIteratorPrototype% [ @@toStringTag ]
        // The initial value of the @@toStringTag property is the String value "Map Iterator".
        // This property has the attributes { [[Writable]]: false, [[Enumerable]]: false, [[Configurable]]: true }.

        CreateMethodProperty(MapIteratorPrototype, Symbol.iterator, function iterator() {
                        return this;
                }
        );

        // Export the object
        try {
                CreateMethodProperty(global, 'Map', Map);
        } catch (e) {
                // IE8 throws an error here if we set enumerable to false.
                // More info on table 2: https://msdn.microsoft.com/en-us/library/dd229916(v=vs.85).aspx
                global['Map'] = Map;
        }
}(this));

}

if (!("Set"in this&&function(){try{var t=new Set([1,2])
return 0===Set.length&&2===t.size&&"Symbol"in this&&"iterator"in Symbol&&"function"==typeof t[Symbol.iterator]}catch(e){return!1}}()
)) {

// Set
/* global CreateIterResultObject, CreateMethodProperty, GetIterator, IsCallable, IteratorClose, IteratorStep, IteratorValue, OrdinaryCreateFromConstructor, SameValueZero, Symbol */
(function (global) {
        var supportsGetters = (function () {
                try {
                        var a = {};
                        Object.defineProperty(a, 't', {
                                configurable: true,
                                enumerable: false,
                                get: function () {
                                        return true;
                                },
                                set: undefined
                        });
                        return !!a.t;
                } catch (e) {
                        return false;
                }
        }());

        // Deleted set items mess with iterator pointers, so rather than removing them mark them as deleted. Can't use undefined or null since those both valid keys so use a private symbol.
        var undefMarker = Symbol('undef');
        // 23.2.1.1. Set ( [ iterable ] )
        var Set = function Set(/* iterable */) {
                // 1. If NewTarget is undefined, throw a TypeError exception.
                if (!(this instanceof Set)) {
                        throw new TypeError('Constructor Set requires "new"');
                }
                // 2. Let set be ? OrdinaryCreateFromConstructor(NewTarget, "%SetPrototype%", « [[SetData]] »).
                var set = OrdinaryCreateFromConstructor(this, Set.prototype, {
                        _values: [],
                        _size: 0,
                        _es6Set: true
                });

                // 3. Set set.[[SetData]] to a new empty List.
                // Polyfill.io - This step was done as part of step two.

                // Some old engines do not support ES5 getters/setters.  Since Set only requires these for the size property, we can fall back to setting the size property statically each time the size of the set changes.
                if (!supportsGetters) {
                        Object.defineProperty(set, 'size', {
                                configurable: true,
                                enumerable: false,
                                writable: true,
                                value: 0
                        });
                }

                // 4. If iterable is not present, let iterable be undefined.
                var iterable = arguments.length > 0 ? arguments[0] : undefined;

                // 5. If iterable is either undefined or null, return set.
                if (iterable === null || iterable === undefined) {
                        return set;
                }

                // 6. Let adder be ? Get(set, "add").
                var adder = set.add;
                // 7. If IsCallable(adder) is false, throw a TypeError exception.
                if (!IsCallable(adder)) {
                        throw new TypeError("Set.prototype.add is not a function");
                }

                try {
                        // 8. Let iteratorRecord be ? GetIterator(iterable).
                        var iteratorRecord = GetIterator(iterable);
                        // 9. Repeat,
                        while (true) {
                                // a. Let next be ? IteratorStep(iteratorRecord).
                                var next = IteratorStep(iteratorRecord);
                                // b. If next is false, return set.
                                if (next === false) {
                                        return set;
                                }
                                // c. Let nextValue be ? IteratorValue(next).
                                var nextValue = IteratorValue(next);
                                // d. Let status be Call(adder, set, « nextValue.[[Value]] »).
                                try {
                                        adder.call(set, nextValue);
                                } catch (e) {
                                        // e. If status is an abrupt completion, return ? IteratorClose(iteratorRecord, status).
                                        return IteratorClose(iteratorRecord, e);
                                }
                        }
                } catch (e) {
                        // Polyfill.io - For user agents which do not have iteration methods on argument objects or arrays, we can special case those.
                        if (Array.isArray(iterable) ||
                                Object.prototype.toString.call(iterable) === '[object Arguments]' ||
                                // IE 7 & IE 8 return '[object Object]' for the arguments object, we can detect by checking for the existence of the callee property
                                (!!iterable.callee)) {
                                var index;
                                var length = iterable.length;
                                for (index = 0; index < length; index++) {
                                        adder.call(set, iterable[index]);
                                }
                        } else {
                                throw (e);
                        }
                }
                return set;
        };

        // 23.2.2.1. Set.prototype
        // The initial value of Set.prototype is the intrinsic %SetPrototype% object.
        // This property has the attributes { [[Writable]]: false, [[Enumerable]]: false, [[Configurable]]: false }.
        Object.defineProperty(Set, 'prototype', {
                configurable: false,
                enumerable: false,
                writable: false,
                value: {}
        });

        // 23.2.2.2 get Set [ @@species ]
        if (supportsGetters) {
                Object.defineProperty(Set, Symbol.species, {
                        configurable: true,
                        enumerable: false,
                        get: function () {
                                // 1. Return the this value.
                                return this;
                        },
                        set: undefined
                });
        } else {
                CreateMethodProperty(Set, Symbol.species, Set);
        }

        // 23.2.3.1. Set.prototype.add ( value )
        CreateMethodProperty(Set.prototype, 'add', function add(value) {
                        // 1. Let S be the this value.
                        var S = this;
                        // 2. If Type(S) is not Object, throw a TypeError exception.
                        if (typeof S !== 'object') {
                                throw new TypeError('Method Set.prototype.add called on incompatible receiver ' + Object.prototype.toString.call(S));
                        }
                        // 3. If S does not have a [[SetData]] internal slot, throw a TypeError exception.
                        if (S._es6Set !== true) {
                                throw new TypeError('Method Set.prototype.add called on incompatible receiver ' + Object.prototype.toString.call(S));
                        }
                        // 4. Let entries be the List that is S.[[SetData]].
                        var entries = S._values;
                        // 5. For each e that is an element of entries, do
                        for (var i = 0; i < entries.length; i++) {
                                var e = entries[i];
                                // a. If e is not empty and SameValueZero(e, value) is true, then
                                if (e !== undefMarker && SameValueZero(e, value)) {
                                        // i. Return S.
                                        return S;
                                }
                        }
                        // 6. If value is -0, let value be +0.
                        if (1/value === -Infinity) {
                                value = 0;
                        }
                        // 7. Append value as the last element of entries.
                        S._values.push(value);

                        this._size = ++this._size;
                        if (!supportsGetters) {
                                this.size = this._size;
                        }
                        // 8. Return S.
                        return S;
                });

        // 23.2.3.2. Set.prototype.clear ( )
        CreateMethodProperty(Set.prototype, 'clear', function clear() {
                        // 1. Let S be the this value.
                        var S = this;
                        // 2. If Type(S) is not Object, throw a TypeError exception.
                        if (typeof S !== 'object') {
                                throw new TypeError('Method Set.prototype.clear called on incompatible receiver ' + Object.prototype.toString.call(S));
                        }
                        // 3. If S does not have a [[SetData]] internal slot, throw a TypeError exception.
                        if (S._es6Set !== true) {
                                throw new TypeError('Method Set.prototype.clear called on incompatible receiver ' + Object.prototype.toString.call(S));
                        }
                        // 4. Let entries be the List that is S.[[SetData]].
                        var entries = S._values;
                        // 5. For each e that is an element of entries, do
                        for (var i = 0; i < entries.length; i++) {
                                // a. Replace the element of entries whose value is e with an element whose value is empty.
                                entries[i] = undefMarker;
                        }
                        this._size = 0;
                        if (!supportsGetters) {
                                this.size = this._size;
                        }
                        // 6. Return undefined.
                        return undefined;
                });

        // 23.2.3.3. Set.prototype.constructor
        CreateMethodProperty(Set.prototype, 'constructor', Set);

        // 23.2.3.4. Set.prototype.delete ( value )
        CreateMethodProperty(Set.prototype, 'delete', function (value) {
                        // 1. Let S be the this value.
                        var S = this;
                        // 2. If Type(S) is not Object, throw a TypeError exception.
                        if (typeof S !== 'object') {
                                throw new TypeError('Method Set.prototype.delete called on incompatible receiver ' + Object.prototype.toString.call(S));
                        }
                        // 3. If S does not have a [[SetData]] internal slot, throw a TypeError exception.
                        if (S._es6Set !== true) {
                                throw new TypeError('Method Set.prototype.delete called on incompatible receiver ' + Object.prototype.toString.call(S));
                        }
                        // 4. Let entries be the List that is S.[[SetData]].
                        var entries = S._values;
                        // 5. For each e that is an element of entries, do
                        for (var i = 0; i < entries.length; i++) {
                                var e = entries[i];
                                // a. If e is not empty and SameValueZero(e, value) is true, then
                                if (e !== undefMarker && SameValueZero(e, value)) {
                                        // i. Replace the element of entries whose value is e with an element whose value is empty.
                                        entries[i] = undefMarker;

                                        this._size = --this._size;
                                        if (!supportsGetters) {
                                                this.size = this._size;
                                        }
                                        // ii. Return true.
                                        return true;
                                }
                        }
                        // 6. Return false.
                        return false;
                }
        );

        // 23.2.3.5. Set.prototype.entries ( )
        CreateMethodProperty(Set.prototype, 'entries', function entries() {
                        // 1. Let S be the this value.
                        var S = this;
                        // 2. Return ? CreateSetIterator(S, "key+value").
                        return CreateSetIterator(S, 'key+value');
                }
        );

        // 23.2.3.6. Set.prototype.forEach ( callbackfn [ , thisArg ] )
        CreateMethodProperty(Set.prototype, 'forEach', function forEach(callbackFn /*[ , thisArg ]*/) {
                        // 1. Let S be the this value.
                        var S = this;
                        // 2. If Type(S) is not Object, throw a TypeError exception.
                        if (typeof S !== 'object') {
                                throw new TypeError('Method Set.prototype.forEach called on incompatible receiver ' + Object.prototype.toString.call(S));
                        }
                        // 3. If S does not have a [[SetData]] internal slot, throw a TypeError exception.
                        if (S._es6Set !== true) {
                                throw new TypeError('Method Set.prototype.forEach called on incompatible receiver ' + Object.prototype.toString.call(S));
                        }
                        // 4. If IsCallable(callbackfn) is false, throw a TypeError exception.
                        if (!IsCallable(callbackFn)) {
                                throw new TypeError(Object.prototype.toString.call(callbackFn) + ' is not a function.');
                        }
                        // 5. If thisArg is present, let T be thisArg; else let T be undefined.
                        if (arguments[1]) {
                                var T = arguments[1];
                        }
                        // 6. Let entries be the List that is S.[[SetData]].
                        var entries = S._values;
                        // 7. For each e that is an element of entries, in original insertion order, do
                        for (var i = 0; i < entries.length; i++) {
                                var e = entries[i];
                                // a. If e is not empty, then
                                if (e !== undefMarker) {
                                        // i. Perform ? Call(callbackfn, T, « e, e, S »).
                                        callbackFn.call(T, e, e, S);
                                }
                        }
                        // 8. Return undefined.
                        return undefined;
                }
        );

        // 23.2.3.7. Set.prototype.has ( value )
        CreateMethodProperty(Set.prototype, 'has', function has(value) {
                        // 1. Let S be the this value.
                        var S = this;
                        // 2. If Type(S) is not Object, throw a TypeError exception.
                        if (typeof S !== 'object') {
                                throw new TypeError('Method Set.prototype.forEach called on incompatible receiver ' + Object.prototype.toString.call(S));
                        }
                        // 3. If S does not have a [[SetData]] internal slot, throw a TypeError exception.
                        if (S._es6Set !== true) {
                                throw new TypeError('Method Set.prototype.forEach called on incompatible receiver ' + Object.prototype.toString.call(S));
                        }
                        // 4. Let entries be the List that is S.[[SetData]].
                        var entries = S._values;
                        // 5. For each e that is an element of entries, do
                        for (var i = 0; i < entries.length; i++) {
                                var e = entries[i];
                                // a. If e is not empty and SameValueZero(e, value) is true, return true.
                                if (e !== undefMarker && SameValueZero(e, value)) {
                                        return true;
                                }
                        }
                        // 6. Return false.
                        return false;
                }
        );

        // Polyfill.io - We need to define Set.prototype.values before Set.prototype.keys because keys is a reference to values.
        // 23.2.3.10. Set.prototype.values()
        var values = function values() {
                // 1. Let S be the this value.
                var S = this;
                // 2. Return ? CreateSetIterator(S, "value").
                return CreateSetIterator(S, "value");
        };
        CreateMethodProperty(Set.prototype, 'values', values);

        // 23.2.3.8 Set.prototype.keys ( )
        // The initial value of the keys property is the same function object as the initial value of the values property.
        CreateMethodProperty(Set.prototype, 'keys', values);

        // 23.2.3.9. get Set.prototype.size
        if (supportsGetters) {
                Object.defineProperty(Set.prototype, 'size', {
                        configurable: true,
                        enumerable: false,
                        get: function () {
                                // 1. Let S be the this value.
                                var S = this;
                                // 2. If Type(S) is not Object, throw a TypeError exception.
                                if (typeof S !== 'object') {
                                        throw new TypeError('Method Set.prototype.size called on incompatible receiver ' + Object.prototype.toString.call(S));
                                }
                                // 3. If S does not have a [[SetData]] internal slot, throw a TypeError exception.
                                if (S._es6Set !== true) {
                                        throw new TypeError('Method Set.prototype.size called on incompatible receiver ' + Object.prototype.toString.call(S));
                                }
                                // 4. Let entries be the List that is S.[[SetData]].
                                var entries = S._values;
                                // 5. Let count be 0.
                                var count = 0;
                                // 6. For each e that is an element of entries, do
                                for (var i = 0; i < entries.length; i++) {
                                        var e = entries[i];
                                        // a. If e is not empty, set count to count+1.
                                        if (e !== undefMarker) {
                                                count = count + 1;
                                        }
                                }
                                // 7. Return count.
                                return count;
                        },
                        set: undefined
                });
        }

        // 23.2.3.11. Set.prototype [ @@iterator ] ( )
        // The initial value of the @@iterator property is the same function object as the initial value of the values property.
        CreateMethodProperty(Set.prototype, Symbol.iterator, values);

        // 23.2.3.12. Set.prototype [ @@toStringTag ]
        // The initial value of the @@toStringTag property is the String value "Set".
        // This property has the attributes { [[Writable]]: false, [[Enumerable]]: false, [[Configurable]]: true }.

        // Polyfill.io - Safari 8 implements Set.name but as a non-configurable property, which means it would throw an error if we try and configure it here.
        if (!('name' in Set)) {
                // 19.2.4.2 name
                Object.defineProperty(Set, 'name', {
                        configurable: true,
                        enumerable: false,
                        writable: false,
                        value: 'Set'
                });
        }

        // 23.2.5.1. CreateSetIterator ( set, kind )
        function CreateSetIterator(set, kind) {
                // 1. If Type(set) is not Object, throw a TypeError exception.
                if (typeof set !== 'object') {
                        throw new TypeError('createSetIterator called on incompatible receiver ' + Object.prototype.toString.call(set));
                }
                // 2. If set does not have a [[SetData]] internal slot, throw a TypeError exception.
                if (set._es6Set !== true) {
                        throw new TypeError('createSetIterator called on incompatible receiver ' + Object.prototype.toString.call(set));
                }
                // 3. Let iterator be ObjectCreate(%SetIteratorPrototype%, « [[IteratedSet]], [[SetNextIndex]], [[SetIterationKind]] »).
                var iterator = Object.create(SetIteratorPrototype);
                // 4. Set iterator.[[IteratedSet]] to set.
                Object.defineProperty(iterator, '[[IteratedSet]]', {
                        configurable: true,
                        enumerable: false,
                        writable: true,
                        value: set
                });
                // 5. Set iterator.[[SetNextIndex]] to 0.
                Object.defineProperty(iterator, '[[SetNextIndex]]', {
                        configurable: true,
                        enumerable: false,
                        writable: true,
                        value: 0
                });
                // 6. Set iterator.[[SetIterationKind]] to kind.
                Object.defineProperty(iterator, '[[SetIterationKind]]', {
                        configurable: true,
                        enumerable: false,
                        writable: true,
                        value: kind
                });
                // 7. Return iterator.
                return iterator;
        }

        // 23.2.5.2. The %SetIteratorPrototype% Object
        var SetIteratorPrototype = {};
        //Polyfill.io - We add this property to help us identify what is a set iterator.
        Object.defineProperty(SetIteratorPrototype, 'isSetIterator', {
                configurable: false,
                enumerable: false,
                writable: false,
                value: true
        });

        // 23.2.5.2.1. %SetIteratorPrototype%.next ( )
        CreateMethodProperty(SetIteratorPrototype, 'next', function next() {
                // 1. Let O be the this value.
                var O = this;
                // 2. If Type(O) is not Object, throw a TypeError exception.
                if (typeof O !== 'object') {
                        throw new TypeError('Method %SetIteratorPrototype%.next called on incompatible receiver ' + Object.prototype.toString.call(O));
                }
                // 3. If O does not have all of the internal slots of a Set Iterator Instance (23.2.5.3), throw a TypeError exception.
                if (!O.isSetIterator) {
                        throw new TypeError('Method %SetIteratorPrototype%.next called on incompatible receiver ' + Object.prototype.toString.call(O));
                }
                // 4. Let s be O.[[IteratedSet]].
                var s = O['[[IteratedSet]]'];
                // 5. Let index be O.[[SetNextIndex]].
                var index = O['[[SetNextIndex]]'];
                // 6. Let itemKind be O.[[SetIterationKind]].
                var itemKind = O['[[SetIterationKind]]'];
                // 7. If s is undefined, return CreateIterResultObject(undefined, true).
                if (s === undefined) {
                        return CreateIterResultObject(undefined, true);
                }
                // 8. Assert: s has a [[SetData]] internal slot.
                if (!s._es6Set) {
                        throw new Error(Object.prototype.toString.call(s) + ' does not have [[SetData]] internal slot.');
                }
                // 9. Let entries be the List that is s.[[SetData]].
                var entries = s._values;
                // 10. Let numEntries be the number of elements of entries.
                var numEntries = entries.length;
                // 11. NOTE: numEntries must be redetermined each time this method is evaluated.
                // 12. Repeat, while index is less than numEntries,
                while (index < numEntries) {
                        // a. Let e be entries[index].
                        var e = entries[index];
                        // b. Set index to index+1.
                        index = index + 1;
                        // c. Set O.[[SetNextIndex]] to index.
                        O['[[SetNextIndex]]'] = index;
                        // d. If e is not empty, then
                        if (e !== undefMarker) {
                                // i. If itemKind is "key+value", then
                                if (itemKind === 'key+value') {
                                        // 1. Return CreateIterResultObject(CreateArrayFromList(« e, e »), false).
                                        return CreateIterResultObject([e, e], false);
                                }
                                // ii. Return CreateIterResultObject(e, false).
                                return CreateIterResultObject(e, false);
                        }
                }
                // 13. Set O.[[IteratedSet]] to undefined.
                O['[[IteratedSet]]'] = undefined;
                // 14. Return CreateIterResultObject(undefined, true).
                return CreateIterResultObject(undefined, true);
        });

        // 23.2.5.2.2. %SetIteratorPrototype% [ @@toStringTag ]
        // The initial value of the @@toStringTag property is the String value "Set Iterator".
        // This property has the attributes { [[Writable]]: false, [[Enumerable]]: false, [[Configurable]]: true }.

        CreateMethodProperty(SetIteratorPrototype, Symbol.iterator, function iterator() {
                        return this;
                }
        );

        // Export the object
        try {
                CreateMethodProperty(global, 'Set', Set);
        } catch (e) {
                // IE8 throws an error here if we set enumerable to false.
                // More info on table 2: https://msdn.microsoft.com/en-us/library/dd229916(v=vs.85).aspx
                global['Set'] = Set;
        }

}(this));

}

if (!("from"in Array&&function(){try{return Array.from({length:-Infinity}),!0}catch(r){return!1}}()
)) {

// Array.from
/* globals
        IsCallable, GetMethod, Symbol, IsConstructor, Construct, ArrayCreate, GetIterator, IteratorClose,
        ToString, IteratorStep, IteratorValue, Call, CreateDataPropertyOrThrow, ToObject, ToLength, Get, CreateMethodProperty
*/
(function () {
        var toString = Object.prototype.toString;
        var stringMatch = String.prototype.match;
        // A cross-realm friendly way to detect if a value is a String object or literal.
        function isString(value) {
                if (typeof value === 'string') { return true; }
                if (typeof value !== 'object') { return false; }
                return toString.call(value) === '[object String]';
        }

        // 22.1.2.1. Array.from ( items [ , mapfn [ , thisArg ] ] )
        CreateMethodProperty(Array, 'from', function from(items /* [ , mapfn [ , thisArg ] ] */) { // eslint-disable-line no-undef
                // 1. Let C be the this value.
                var C = this;
                // 2. If mapfn is undefined, let mapping be false.
                var mapfn = arguments.length > 1 ? arguments[1] : undefined;
                if (mapfn === undefined) {
                        var mapping = false;
                        // 3. Else,
                } else {
                        // a. If IsCallable(mapfn) is false, throw a TypeError exception.
                        if (IsCallable(mapfn) === false) {
                                throw new TypeError(Object.prototype.toString.call(mapfn) + ' is not a function.');
                        }
                        // b. If thisArg is present, let T be thisArg; else let T be undefined.
                        var thisArg = arguments.length > 2 ? arguments[2] : undefined;
                        if (thisArg !== undefined) {
                                var T = thisArg;
                        } else {
                                T = undefined;
                        }
                        // c. Let mapping be true.
                        mapping = true;

                }
                // 4. Let usingIterator be ? GetMethod(items, @@iterator).
                var usingIterator = GetMethod(items, Symbol.iterator);
                // 5. If usingIterator is not undefined, then
                if (usingIterator !== undefined) {
                        // a. If IsConstructor(C) is true, then
                        if (IsConstructor(C)) {
                                // i. Let A be ? Construct(C).
                                var A = Construct(C);
                                // b. Else,
                        } else {
                                // i. Let A be ! ArrayCreate(0).
                                A = ArrayCreate(0);
                        }
                        // c. Let iteratorRecord be ? GetIterator(items, usingIterator).
                        var iteratorRecord = GetIterator(items, usingIterator);
                        // d. Let k be 0.
                        var k = 0;
                        // e. Repeat,
                        while (true) {
                                // i. If k ≥ 2^53-1, then
                                if (k >= (Math.pow(2, 53) - 1)) {
                                        // 1. Let error be Completion{[[Type]]: throw, [[Value]]: a newly created TypeError object, [[Target]]: empty}.
                                        var error = new TypeError('Iteration count can not be greater than or equal 9007199254740991.');
                                        // 2. Return ? IteratorClose(iteratorRecord, error).
                                        return IteratorClose(iteratorRecord, error);
                                }
                                // ii. Let Pk be ! ToString(k).
                                var Pk = ToString(k);
                                // iii. Let next be ? IteratorStep(iteratorRecord).
                                var next = IteratorStep(iteratorRecord);
                                // iv. If next is false, then
                                if (next === false) {
                                        // 1. Perform ? Set(A, "length", k, true).
                                        A["length"] = k;
                                        // 2. Return A.
                                        return A;
                                }
                                // v. Let nextValue be ? IteratorValue(next).
                                var nextValue = IteratorValue(next);
                                // vi. If mapping is true, then
                                if (mapping) {
                                        try {
                                                // Polyfill.io - The try catch accounts for step 2.
                                                // 1. Let mappedValue be Call(mapfn, T, « nextValue, k »).
                                                var mappedValue = Call(mapfn, T, [nextValue, k]);
                                                // 2. If mappedValue is an abrupt completion, return ? IteratorClose(iteratorRecord, mappedValue).
                                                // 3. Let mappedValue be mappedValue.[[Value]].
                                        } catch (e) {
                                                return IteratorClose(iteratorRecord, e);
                                        }

                                        // vii. Else, let mappedValue be nextValue.
                                } else {
                                        mappedValue = nextValue;
                                }
                                try {
                                        // Polyfill.io - The try catch accounts for step ix.
                                        // viii. Let defineStatus be CreateDataPropertyOrThrow(A, Pk, mappedValue).
                                        CreateDataPropertyOrThrow(A, Pk, mappedValue);
                                        // ix. If defineStatus is an abrupt completion, return ? IteratorClose(iteratorRecord, defineStatus).
                                } catch (e) {
                                        return IteratorClose(iteratorRecord, e);
                                }
                                // x. Increase k by 1.
                                k = k + 1;
                        }
                }
                // 6. NOTE: items is not an Iterable so assume it is an array-like object.
                // 7. Let arrayLike be ! ToObject(items).
                // Polyfill.io - For Strings we need to split astral symbols into surrogate pairs.
                if (isString(items)) {
                        var arrayLike = stringMatch.call(items, /[\uD800-\uDBFF][\uDC00-\uDFFF]?|[^\uD800-\uDFFF]|./g) || [];
                } else {
                        arrayLike = ToObject(items);
                }
                // 8. Let len be ? ToLength(? Get(arrayLike, "length")).
                var len = ToLength(Get(arrayLike, "length"));
                // 9. If IsConstructor(C) is true, then
                if (IsConstructor(C)) {
                        // a. Let A be ? Construct(C, « len »).
                        A = Construct(C, [len]);
                        // 10. Else,
                } else {
                        // a. Let A be ? ArrayCreate(len).
                        A = ArrayCreate(len);
                }
                // 11. Let k be 0.
                k = 0;
                // 12. Repeat, while k < len
                while (k < len) {
                        // a. Let Pk be ! ToString(k).
                        Pk = ToString(k);
                        // b. Let kValue be ? Get(arrayLike, Pk).
                        var kValue = Get(arrayLike, Pk);
                        // c. If mapping is true, then
                        if (mapping === true) {
                                // i. Let mappedValue be ? Call(mapfn, T, « kValue, k »).
                                mappedValue = Call(mapfn, T, [kValue, k]);
                                // d. Else, let mappedValue be kValue.
                        } else {
                                mappedValue = kValue;
                        }
                        // e. Perform ? CreateDataPropertyOrThrow(A, Pk, mappedValue).
                        CreateDataPropertyOrThrow(A, Pk, mappedValue);
                        // f. Increase k by 1.
                        k = k + 1;
                }
                // 13. Perform ? Set(A, "length", len, true).
                A["length"] = len;
                // 14. Return A.
                return A;
        });
}());

}

if (!("Symbol"in this&&"split"in this.Symbol
)) {

// Symbol.split
/* global Symbol */
Object.defineProperty(Symbol, 'split', { value: Symbol('split') });

}

if (!("Symbol"in this&&"toPrimitive"in this.Symbol
)) {

// Symbol.toPrimitive
/* global Symbol */
Object.defineProperty(Symbol, 'toPrimitive', { value: Symbol('toPrimitive') });

}

if (!("Symbol"in this&&"toStringTag"in this.Symbol
)) {

// Symbol.toStringTag
/* global Symbol */
Object.defineProperty(Symbol, 'toStringTag', {
        value: Symbol('toStringTag')
});

}


// _Iterator
/* global Symbol */
// A modification of https://github.com/medikoo/es6-iterator
// Copyright (C) 2013-2015 Mariusz Nowak (www.medikoo.com)

var Iterator = (function () { // eslint-disable-line no-unused-vars
        var clear = function () {
                this.length = 0;
                return this;
        };
        var callable = function (fn) {
                if (typeof fn !== 'function') throw new TypeError(fn + " is not a function");
                return fn;
        };

        var Iterator = function (list, context) {
                if (!(this instanceof Iterator)) {
                        return new Iterator(list, context);
                }
                Object.defineProperties(this, {
                        __list__: {
                                writable: true,
                                value: list
                        },
                        __context__: {
                                writable: true,
                                value: context
                        },
                        __nextIndex__: {
                                writable: true,
                                value: 0
                        }
                });
                if (!context) return;
                callable(context.on);
                context.on('_add', this._onAdd.bind(this));
                context.on('_delete', this._onDelete.bind(this));
                context.on('_clear', this._onClear.bind(this));
        };

        Object.defineProperties(Iterator.prototype, Object.assign({
                constructor: {
                        value: Iterator,
                        configurable: true,
                        enumerable: false,
                        writable: true
                },
                _next: {
                        value: function () {
                                var i;
                                if (!this.__list__) return;
                                if (this.__redo__) {
                                        i = this.__redo__.shift();
                                        if (i !== undefined) return i;
                                }
                                if (this.__nextIndex__ < this.__list__.length) return this.__nextIndex__++;
                                this._unBind();
                        },
                        configurable: true,
                        enumerable: false,
                        writable: true
                },
                next: {
                        value: function () {
                                return this._createResult(this._next());
                        },
                        configurable: true,
                        enumerable: false,
                        writable: true
                },
                _createResult: {
                        value: function (i) {
                                if (i === undefined) return {
                                        done: true,
                                        value: undefined
                                };
                                return {
                                        done: false,
                                        value: this._resolve(i)
                                };
                        },
                        configurable: true,
                        enumerable: false,
                        writable: true
                },
                _resolve: {
                        value: function (i) {
                                return this.__list__[i];
                        },
                        configurable: true,
                        enumerable: false,
                        writable: true
                },
                _unBind: {
                        value: function () {
                                this.__list__ = null;
                                delete this.__redo__;
                                if (!this.__context__) return;
                                this.__context__.off('_add', this._onAdd.bind(this));
                                this.__context__.off('_delete', this._onDelete.bind(this));
                                this.__context__.off('_clear', this._onClear.bind(this));
                                this.__context__ = null;
                        },
                        configurable: true,
                        enumerable: false,
                        writable: true
                },
                toString: {
                        value: function () {
                                return '[object Iterator]';
                        },
                        configurable: true,
                        enumerable: false,
                        writable: true
                }
        }, {
                _onAdd: {
                        value: function (index) {
                                if (index >= this.__nextIndex__) return;
                                ++this.__nextIndex__;
                                if (!this.__redo__) {
                                        Object.defineProperty(this, '__redo__', {
                                                value: [index],
                                                configurable: true,
                                                enumerable: false,
                                                writable: false
                                        });
                                        return;
                                }
                                this.__redo__.forEach(function (redo, i) {
                                        if (redo >= index) this.__redo__[i] = ++redo;
                                }, this);
                                this.__redo__.push(index);
                        },
                        configurable: true,
                        enumerable: false,
                        writable: true
                },
                _onDelete: {
                        value: function (index) {
                                var i;
                                if (index >= this.__nextIndex__) return;
                                --this.__nextIndex__;
                                if (!this.__redo__) return;
                                i = this.__redo__.indexOf(index);
                                if (i !== -1) this.__redo__.splice(i, 1);
                                this.__redo__.forEach(function (redo, i) {
                                        if (redo > index) this.__redo__[i] = --redo;
                                }, this);
                        },
                        configurable: true,
                        enumerable: false,
                        writable: true
                },
                _onClear: {
                        value: function () {
                                if (this.__redo__) clear.call(this.__redo__);
                                this.__nextIndex__ = 0;
                        },
                        configurable: true,
                        enumerable: false,
                        writable: true
                }
        }));

        Object.defineProperty(Iterator.prototype, Symbol.iterator, {
                value: function () {
                        return this;
                },
                configurable: true,
                enumerable: false,
                writable: true
        });
        Object.defineProperty(Iterator.prototype, Symbol.toStringTag, {
                value: 'Iterator',
                configurable: false,
                enumerable: false,
                writable: true
        });

        return Iterator;
}());

// _ArrayIterator
/* global Iterator */
// A modification of https://github.com/medikoo/es6-iterator
// Copyright (C) 2013-2015 Mariusz Nowak (www.medikoo.com)

var ArrayIterator = (function() { // eslint-disable-line no-unused-vars

        var ArrayIterator = function(arr, kind) {
                if (!(this instanceof ArrayIterator)) return new ArrayIterator(arr, kind);
                Iterator.call(this, arr);
                if (!kind) kind = 'value';
                else if (String.prototype.includes.call(kind, 'key+value')) kind = 'key+value';
                else if (String.prototype.includes.call(kind, 'key')) kind = 'key';
                else kind = 'value';
                Object.defineProperty(this, '__kind__', {
                        value: kind,
                        configurable: false,
                        enumerable: false,
                        writable: false
                });
        };
        if (Object.setPrototypeOf) Object.setPrototypeOf(ArrayIterator, Iterator.prototype);

        ArrayIterator.prototype = Object.create(Iterator.prototype, {
                constructor: {
                        value: ArrayIterator,
                        configurable: true,
                        enumerable: false,
                        writable: true
                },
                _resolve: {
                        value: function(i) {
                                if (this.__kind__ === 'value') return this.__list__[i];
                                if (this.__kind__ === 'key+value') return [i, this.__list__[i]];
                                return i;
                        },
                        configurable: true,
                        enumerable: false,
                        writable: true
                },
                toString: {
                        value: function() {
                                return '[object Array Iterator]';
                        },
                        configurable: true,
                        enumerable: false,
                        writable: true
                }
        });

        return ArrayIterator;
}());
if (!("Symbol"in this&&"iterator"in this.Symbol&&!!Array.prototype.entries
)) {

// Array.prototype.entries
/* global CreateMethodProperty, ToObject */
// 22.1.3.4. Array.prototype.entries ( )
CreateMethodProperty(Array.prototype, 'entries', function entries() {
        // 1. Let O be ? ToObject(this value).
        var O = ToObject(this);
        // 2. Return CreateArrayIterator(O, "key+value").
        // TODO: Add CreateArrayIterator
        return new ArrayIterator(O, 'key+value');
});

}

if (!("Symbol"in this&&"iterator"in this.Symbol&&!!Array.prototype.keys
)) {

// Array.prototype.keys
/* global CreateMethodProperty, ToObject */
// 22.1.3.14. Array.prototype.keys ( )
CreateMethodProperty(Array.prototype, 'keys', function keys() {
        // 1. Let O be ? ToObject(this value).
        var O = ToObject(this);
        // 2. Return CreateArrayIterator(O, "key").
        // TODO: Add CreateArrayIterator.
        return new ArrayIterator(O, 'key');
});

}

if (!("values"in Array.prototype
)) {

// Array.prototype.values
/* global CreateMethodProperty, Symbol, ToObject */
// 22.1.3.30/ Array.prototype.values ( )
// Polyfill.io - Firefox, Chrome and Opera have Array.prototype[Symbol.iterator], which is the exact same function as Array.prototype.values.
if ('Symbol' in this && 'iterator' in Symbol && typeof Array.prototype[Symbol.iterator] === 'function') {
        CreateMethodProperty(Array.prototype, 'values', Array.prototype[Symbol.iterator]);
} else {
        CreateMethodProperty(Array.prototype, 'values', function values () {
                // 1. Let O be ? ToObject(this value).
                var O = ToObject(this);
                // 2. Return CreateArrayIterator(O, "value").
                // TODO: Add CreateArrayIterator
                return new ArrayIterator(O, 'value');
        });
}

}

if (!("Symbol"in this&&"iterator"in this.Symbol&&!!Array.prototype[Symbol.iterator]
)) {

// Array.prototype.@@iterator
/* global Symbol, CreateMethodProperty */
// 22.1.3.31. Array.prototype [ @@iterator ] ( )
// The initial value of the @@iterator property is the same function object as the initial value of the  Array.prototype.values property.
CreateMethodProperty(Array.prototype, Symbol.iterator, Array.prototype.values);

}


// _StringIterator
// A modification of https://github.com/medikoo/es6-iterator
// Copyright (C) 2013-2015 Mariusz Nowak (www.medikoo.com)

/* global Iterator */

var StringIterator = (function() { // eslint-disable-line no-unused-vars

        var StringIterator = function (str) {
                if (!(this instanceof StringIterator)) return new StringIterator(str);
                str = String(str);
                Iterator.call(this, str);
                Object.defineProperty(this, '__length__', {
                        value: str.length,
                        configurable: false,
                        enumerable: false,
                        writable: false
                });
        };
        if (Object.setPrototypeOf) Object.setPrototypeOf(StringIterator, Iterator);

        StringIterator.prototype = Object.create(Iterator.prototype, {
                constructor: {
                        value: StringIterator,
                        configurable: true,
                        enumerable: false,
                        writable: true
                },
                _next: {
                        value: function() {
                                if (!this.__list__) return;
                                if (this.__nextIndex__ < this.__length__) return this.__nextIndex__++;
                                this._unBind();
                        },
                        configurable: true,
                        enumerable: false,
                        writable: true
                },
                _resolve: {
                        value: function (i) {
                                var char = this.__list__[i], code;
                                if (this.__nextIndex__ === this.__length__) return char;
                                code = char.charCodeAt(0);
                                if ((code >= 0xD800) && (code <= 0xDBFF)) return char + this.__list__[this.__nextIndex__++];
                                return char;
                        },
                        configurable: true,
                        enumerable: false,
                        writable: true
                },
                toString: {
                        value: function() {
                                return '[object String Iterator]';
                        },
                        configurable: true,
                        enumerable: false,
                        writable: true
                }
        });

        return StringIterator;
}());
if (!("Symbol"in this&&"iterator"in this.Symbol&&!!String.prototype[Symbol.iterator]
)) {

// String.prototype.@@iterator
/* global CreateMethodProperty, RequireObjectCoercible, ToString, StringIterator, Symbol */
// 21.1.3.29. String.prototype [ @@iterator ] ( )
CreateMethodProperty(String.prototype, Symbol.iterator, function () {
        // 1. Let O be ? RequireObjectCoercible(this value).
        var O = RequireObjectCoercible(this);
        // 2. Let S be ? ToString(O).
        var S = ToString(O);
        // 3. Return CreateStringIterator(S).
        // TODO: Add CreateStringIterator.
        return new StringIterator(S);
});

}

if (!("Symbol"in this&&"unscopables"in this.Symbol
)) {

// Symbol.unscopables
/* global Symbol */
Object.defineProperty(Symbol, 'unscopables', { value: Symbol('unscopables') });

}

if (!((function(e){try{if("WeakMap"in e&&0===WeakMap.length){var t={},a=new WeakMap([[t,"test"]])
return"test"===a.get(t)&&!1===a["delete"](0)}return!1}catch(n){return!1}})(this)
)) {

// WeakMap
/* globals Symbol, OrdinaryCreateFromConstructor, IsCallable, GetIterator, IteratorStep, IteratorValue, IteratorClose, Get, Call, CreateMethodProperty, Type, SameValue */
(function (global) {
        // Deleted map items mess with iterator pointers, so rather than removing them mark them as deleted. Can't use undefined or null since those both valid keys so use a private symbol.
        var undefMarker = Symbol('undef');
        // 23.3.1.1 WeakMap ( [ iterable ] )
        var WeakMap = function WeakMap(/* iterable */) {
                // 1. If NewTarget is undefined, throw a TypeError exception.
                if (!(this instanceof WeakMap)) {
                        throw new TypeError('Constructor WeakMap requires "new"');
                }
                // 2. Let map be ? OrdinaryCreateFromConstructor(NewTarget, "%WeakMapPrototype%", « [[WeakMapData]] »).
                var map = OrdinaryCreateFromConstructor(this, WeakMap.prototype, {
                        _keys: [],
                        _values: [],
                        _es6WeakMap: true
                });

                // 3. Set map.[[WeakMapData]] to a new empty List.
                // Polyfill.io - This step was done as part of step two.

                // 4. If iterable is not present, let iterable be undefined.
                var iterable = arguments.length > 0 ? arguments[0] : undefined;

                // 5. If iterable is either undefined or null, return map.
                if (iterable === null || iterable === undefined) {
                        return map;
                }

                // 6. Let adder be ? Get(map, "set").
                var adder = Get(map, "set");

                // 7. If IsCallable(adder) is false, throw a TypeError exception.
                if (!IsCallable(adder)) {
                        throw new TypeError("WeakMap.prototype.set is not a function");
                }

                // 8. Let iteratorRecord be ? GetIterator(iterable).
                try {
                        var iteratorRecord = GetIterator(iterable);
                        // 9. Repeat,
                        while (true) {
                                // a. Let next be ? IteratorStep(iteratorRecord).
                                var next = IteratorStep(iteratorRecord);
                                // b. If next is false, return map.
                                if (next === false) {
                                        return map;
                                }
                                // c. Let nextItem be ? IteratorValue(next).
                                var nextItem = IteratorValue(next);
                                // d. If Type(nextItem) is not Object, then
                                if (Type(nextItem) !== 'object') {
                                        // i. Let error be Completion{[[Type]]: throw, [[Value]]: a newly created TypeError object, [[Target]]: empty}.
                                        try {
                                                throw new TypeError('Iterator value ' + nextItem + ' is not an entry object');
                                        } catch (error) {
                                                // ii. Return ? IteratorClose(iteratorRecord, error).
                                                return IteratorClose(iteratorRecord, error);
                                        }
                                }
                                try {
                                        // Polyfill.io - The try catch accounts for steps: f, h, and j.

                                        // e. Let k be Get(nextItem, "0").
                                        var k = Get(nextItem, "0");
                                        // f. If k is an abrupt completion, return ? IteratorClose(iteratorRecord, k).
                                        // g. Let v be Get(nextItem, "1").
                                        var v = Get(nextItem, "1");
                                        // h. If v is an abrupt completion, return ? IteratorClose(iteratorRecord, v).
                                        // i. Let status be Call(adder, map, « k.[[Value]], v.[[Value]] »).
                                        Call(adder, map, [k, v]);
                                } catch (e) {
                                        // j. If status is an abrupt completion, return ? IteratorClose(iteratorRecord, status).
                                        return IteratorClose(iteratorRecord, e);
                                }
                        }
                } catch (e) {
                        // Polyfill.io - For user agents which do not have iteration methods on argument objects or arrays, we can special case those.
                        if (Array.isArray(iterable) ||
                                Object.prototype.toString.call(iterable) === '[object Arguments]' ||
                                // IE 7 & IE 8 return '[object Object]' for the arguments object, we can detect by checking for the existence of the callee property
                                (!!iterable.callee)) {
                                var index;
                                var length = iterable.length;
                                for (index = 0; index < length; index++) {
                                        var k = iterable[index][0];
                                        var v = iterable[index][1];
                                        Call(adder, map, [k, v]);
                                }
                        }
                }
                return map;
        };

        // 23.3.2.1 WeakMap.prototype
        // The initial value of WeakMap.prototype is the intrinsic object %WeakMapPrototype%.
        // This property has the attributes { [[Writable]]: false, [[Enumerable]]: false, [[Configurable]]: false }.
        Object.defineProperty(WeakMap, 'prototype', {
                configurable: false,
                enumerable: false,
                writable: false,
                value: {}
        });

        // 23.3.3.1 WeakMap.prototype.constructor
        CreateMethodProperty(WeakMap.prototype, 'constructor', WeakMap);

        // 23.3.3.2 WeakMap.prototype.delete ( key )
        CreateMethodProperty(WeakMap.prototype, 'delete', function (key) {
                // 1. Let M be the this value.
                var M = this;
                // 2. If Type(M) is not Object, throw a TypeError exception.
                if (Type(M) !== 'object') {
                        throw new TypeError('Method WeakMap.prototype.clear called on incompatible receiver ' + Object.prototype.toString.call(M));
                }
                // 3. If M does not have a [[WeakMapData]] internal slot, throw a TypeError exception.
                if (M._es6WeakMap !== true) {
                        throw new TypeError('Method WeakMap.prototype.clear called on incompatible receiver ' + Object.prototype.toString.call(M));
                }
                // 4. Let entries be the List that is M.[[WeakMapData]].
                var entries = M._keys;
                // 5. If Type(key) is not Object, return false.
                if (Type(key) !== 'object') {
                        return false;
                }
                // 6. For each Record {[[Key]], [[Value]]} p that is an element of entries, do
                for (var i = 0; i < entries.length; i++) {
                        // a. If p.[[Key]] is not empty and SameValue(p.[[Key]], key) is true, then
                        if (M._keys[i] !== undefMarker && SameValue(M._keys[i], key)) {
                                // i. Set p.[[Key]] to empty.
                                this._keys[i] = undefMarker;
                                // ii. Set p.[[Value]] to empty.
                                this._values[i] = undefMarker;
                                this._size = --this._size;
                                // iii. Return true.
                                return true;
                        }
                }
                // 7. Return false.
                return false;
        });

        // 23.3.3.3 WeakMap.prototype.get ( key )
        CreateMethodProperty(WeakMap.prototype, 'get', function get(key) {
                // 1. Let M be the this value.
                var M = this;
                // 2. If Type(M) is not Object, throw a TypeError exception.
                if (Type(M) !== 'object') {
                        throw new TypeError('Method WeakMap.prototype.get called on incompatible receiver ' + Object.prototype.toString.call(M));
                }
                // 3. If M does not have a [[WeakMapData]] internal slot, throw a TypeError exception.
                if (M._es6WeakMap !== true) {
                        throw new TypeError('Method WeakMap.prototype.get called on incompatible receiver ' + Object.prototype.toString.call(M));
                }
                // 4. Let entries be the List that is M.[[WeakMapData]].
                var entries = M._keys;
                // 5. If Type(key) is not Object, return undefined.
                if (Type(key) !== 'object') {
                        return undefined;
                }
                // 6. For each Record {[[Key]], [[Value]]} p that is an element of entries, do
                for (var i = 0; i < entries.length; i++) {
                        // a. If p.[[Key]] is not empty and SameValue(p.[[Key]], key) is true, return p.[[Value]].
                        if (M._keys[i] !== undefMarker && SameValue(M._keys[i], key)) {
                                return M._values[i];
                        }
                }
                // 7. Return undefined.
                return undefined;
        });

        // 23.3.3.4 WeakMap.prototype.has ( key )
        CreateMethodProperty(WeakMap.prototype, 'has', function has(key) {
                // 1. Let M be the this value.
                var M = this;
                // 2. If Type(M) is not Object, throw a TypeError exception.
                if (typeof M !== 'object') {
                        throw new TypeError('Method WeakMap.prototype.has called on incompatible receiver ' + Object.prototype.toString.call(M));
                }
                // 3. If M does not have a [[WeakMapData]] internal slot, throw a TypeError exception.
                if (M._es6WeakMap !== true) {
                        throw new TypeError('Method WeakMap.prototype.has called on incompatible receiver ' + Object.prototype.toString.call(M));
                }
                // 4. Let entries be the List that is M.[[WeakMapData]].
                var entries = M._keys;
                // 5. If Type(key) is not Object, return false.
                if (Type(key) !== 'object') {
                        return false;
                }
                // 6. For each Record {[[Key]], [[Value]]} p that is an element of entries, do
                for (var i = 0; i < entries.length; i++) {
                        // a. If p.[[Key]] is not empty and SameValue(p.[[Key]], key) is true, return true.
                        if (M._keys[i] !== undefMarker && SameValue(M._keys[i], key)) {
                                return true;
                        }
                }
                // 7. Return false.
                return false;
        });

        // 23.3.3.5 WeakMap.prototype.set ( key, value )
        CreateMethodProperty(WeakMap.prototype, 'set', function set(key, value) {
                // 1. Let M be the this value.
                var M = this;
                // 2. If Type(M) is not Object, throw a TypeError exception.
                if (Type(M) !== 'object') {
                        throw new TypeError('Method WeakMap.prototype.set called on incompatible receiver ' + Object.prototype.toString.call(M));
                }
                // 3. If M does not have a [[WeakMapData]] internal slot, throw a TypeError exception.
                if (M._es6WeakMap !== true) {
                        throw new TypeError('Method WeakMap.prototype.set called on incompatible receiver ' + Object.prototype.toString.call(M));
                }
                // 4. Let entries be the List that is M.[[WeakMapData]].
                var entries = M._keys;
                // 5. If Type(key) is not Object, throw a TypeError exception.
                if (Type(key) !== 'object') {
                        throw new TypeError("Invalid value used as weak map key");
                }
                // 6. For each Record {[[Key]], [[Value]]} p that is an element of entries, do
                for (var i = 0; i < entries.length; i++) {
                        // a. If p.[[Key]] is not empty and SameValue(p.[[Key]], key) is true, then
                        if (M._keys[i] !== undefMarker && SameValue(M._keys[i], key)) {
                                // i. Set p.[[Value]] to value.
                                M._values[i] = value;
                                // ii. Return M.
                                return M;
                        }
                }
                // 7. Let p be the Record {[[Key]]: key, [[Value]]: value}.
                var p = {
                        '[[Key]]': key,
                        '[[Value]]': value
                };
                // 8. Append p as the last element of entries.
                M._keys.push(p['[[Key]]']);
                M._values.push(p['[[Value]]']);
                // 9. Return M.
                return M;
        });

        // 23.3.3.6 WeakMap.prototype [ @@toStringTag ]
        // The initial value of the @@toStringTag property is the String value "WeakMap".
        // This property has the attributes { [[Writable]]: false, [[Enumerable]]: false, [[Configurable]]: true }.

        // Polyfill.io - Safari 8 implements WeakMap.name but as a non-writable property, which means it would throw an error if we try and write to it here.
        if (!('name' in WeakMap)) {
                // 19.2.4.2 name
                Object.defineProperty(WeakMap, 'name', {
                        configurable: true,
                        enumerable: false,
                        writable: false,
                        value: 'WeakMap'
                });
        }

        // Export the object
        try {
                CreateMethodProperty(global, 'WeakMap', WeakMap);
        } catch (e) {
                // IE8 throws an error here if we set enumerable to false.
                // More info on table 2: https://msdn.microsoft.com/en-us/library/dd229916(v=vs.85).aspx
                global['WeakMap'] = WeakMap;
        }
}(this));

}

if (!((function(e){try{if("WeakSet"in e&&0===WeakSet.length){var t={},n=new WeakSet([t])
return n.has(t)&&!1===n["delete"](0)}return!1}catch(r){return!1}})(this)
)) {

// WeakSet
/* global Call, CreateMethodProperty, Get, GetIterator, IsArray, IsCallable, IteratorClose, IteratorStep, IteratorValue, OrdinaryCreateFromConstructor, SameValueZero, Type, Symbol */
(function (global) {
        // Deleted set items mess with iterator pointers, so rather than removing them mark them as deleted. Can't use undefined or null since those both valid keys so use a private symbol.
        var undefMarker = Symbol('undef');
        // 23.4.1.1. WeakSet ( [ iterable ] )
        var WeakSet = function WeakSet() {
                // 1. If NewTarget is undefined, throw a TypeError exception.
                if (!(this instanceof WeakSet)) {
                        throw new TypeError('Constructor WeakSet requires "new"');
                }
                // 2. Let set be ? OrdinaryCreateFromConstructor(NewTarget, "%WeakSetPrototype%", « [[WeakSetData]] »).
                var set = OrdinaryCreateFromConstructor(this, WeakSet.prototype, {
                        _values: [],
                        _size: 0,
                        _es6WeakSet: true
                });

                // 3. Set set.[[WeakSetData]] to a new empty List.
                // Polyfill.io - This step was done as part of step two.

                // 4. If iterable is not present, let iterable be undefined.
                var iterable = arguments.length > 0 ? arguments[0] : undefined;
                // 5. If iterable is either undefined or null, return set.
                if (iterable === null || iterable === undefined) {
                        return set;
                }
                // 6. Let adder be ? Get(set, "add").
                var adder = Get(set, 'add');
                // 7. If IsCallable(adder) is false, throw a TypeError exception.
                if (!IsCallable(adder)) {
                        throw new TypeError("WeakSet.prototype.add is not a function");
                }
                try {
                        // 8. Let iteratorRecord be ? GetIterator(iterable).
                        var iteratorRecord = GetIterator(iterable);
                        // 9. Repeat,
                        while (true) {
                                // a. Let next be ? IteratorStep(iteratorRecord).
                                var next = IteratorStep(iteratorRecord);
                                // b. If next is false, return set.
                                if (next === false) {
                                        return set;
                                }
                                // c. Let nextValue be ? IteratorValue(next).
                                var nextValue = IteratorValue(next);
                                // d. Let status be Call(adder, set, « nextValue »).
                                try {
                                        Call(adder, set, [nextValue]);
                                } catch (e) {
                                        // e. If status is an abrupt completion, return ? IteratorClose(iteratorRecord, status).
                                        return IteratorClose(iteratorRecord, e);
                                }
                        }
                } catch (e) {
                        // Polyfill.io - For user agents which do not have iteration methods on argument objects or arrays, we can special case those.
                        if (IsArray(iterable) ||
                                Object.prototype.toString.call(iterable) === '[object Arguments]' ||
                                // IE 7 & IE 8 return '[object Object]' for the arguments object, we can detect by checking for the existence of the callee property
                                (!!iterable.callee)) {
                                var index;
                                var length = iterable.length;
                                for (index = 0; index < length; index++) {
                                        Call(adder, set, [iterable[index]]);
                                }
                        }
                }
                return set;
        };

        // 23.4.2.1. WeakSet.prototype
        // The initial value of WeakSet.prototype is the intrinsic %WeakSetPrototype% object.
        // This property has the attributes { [[Writable]]: false, [[Enumerable]]: false, [[Configurable]]: false }.
        Object.defineProperty(WeakSet, 'prototype', {
                configurable: false,
                enumerable: false,
                writable: false,
                value: {}
        });

        // 23.4.3.1. WeakSet.prototype.add ( value )
        CreateMethodProperty(WeakSet.prototype, 'add', function add(value) {
                // 1. Let S be the this value.
                var S = this;
                // 2. If Type(S) is not Object, throw a TypeError exception.
                if (Type(S) !== 'object') {
                        throw new TypeError('Method WeakSet.prototype.add called on incompatible receiver ' + Object.prototype.toString.call(S));
                }
                // 3. If S does not have a [[WeakSetData]] internal slot, throw a TypeError exception.
                if (S._es6WeakSet !== true) {
                        throw new TypeError('Method WeakSet.prototype.add called on incompatible receiver ' + Object.prototype.toString.call(S));
                }
                // 4. If Type(value) is not Object, throw a TypeError exception.
                if (Type(value) !== 'object') {
                        throw new TypeError('Invalid value used in weak set');
                }
                // 5. Let entries be the List that is S.[[WeakSetData]].
                var entries = S._values;
                // 6. For each e that is an element of entries, do
                for (var i = 0; i < entries.length; i++) {
                        var e = entries[i];
                        // a. If e is not empty and SameValue(e, value) is true, then
                        if (e !== undefMarker && SameValueZero(e, value)) {
                                // i. Return S.
                                return S;
                        }
                }
                // 7. Append value as the last element of entries.
                S._values.push(value);
                // 8. Return S.
                return S;
        });

        // 23.4.3.2. WeakSet.prototype.constructor
        CreateMethodProperty(WeakSet.prototype, 'constructor', WeakSet);

        // 23.4.3.3. WeakSet.prototype.delete ( value )
        CreateMethodProperty(WeakSet.prototype, 'delete', function (value) {
                // 1. Let S be the this value.
                var S = this;
                // 2. If Type(S) is not Object, throw a TypeError exception.
                if (Type(S) !== 'object') {
                        throw new TypeError('Method WeakSet.prototype.delete called on incompatible receiver ' + Object.prototype.toString.call(S));
                }
                // 3. If S does not have a [[WeakSetData]] internal slot, throw a TypeError exception.
                if (S._es6WeakSet !== true) {
                        throw new TypeError('Method WeakSet.prototype.delete called on incompatible receiver ' + Object.prototype.toString.call(S));
                }
                // 4. If Type(value) is not Object, return false.
                if (Type(value) !== 'object') {
                        return false;
                }
                // 5. Let entries be the List that is S.[[WeakSetData]].
                var entries = S._values;
                // 6. For each e that is an element of entries, do
                for (var i = 0; i < entries.length; i++) {
                        var e = entries[i];
                        // a. If e is not empty and SameValue(e, value) is true, then
                        if (e !== undefMarker && SameValueZero(e, value)) {
                                // i. Replace the element of entries whose value is e with an element whose value is empty.
                                entries[i] = undefMarker;
                                // ii. Return true.
                                return true;
                        }
                }
                // 7. Return false.
                return false;
        });

        // 23.4.3.4. WeakSet.prototype.has ( value )
        CreateMethodProperty(WeakSet.prototype, 'has', function has(value) {
                // 1. Let S be the this value.
                var S = this;
                // 2. If Type(S) is not Object, throw a TypeError exception.
                if (Type(S) !== 'object') {
                        throw new TypeError('Method WeakSet.prototype.has called on incompatible receiver ' + Object.prototype.toString.call(S));
                }
                // 3. If S does not have a [[WeakSetData]] internal slot, throw a TypeError exception.
                if (S._es6WeakSet !== true) {
                        throw new TypeError('Method WeakSet.prototype.has called on incompatible receiver ' + Object.prototype.toString.call(S));
                }
                // 4. Let entries be the List that is S.[[WeakSetData]].
                var entries = S._values;
                // 5. If Type(value) is not Object, return false.
                if (Type(value) !== 'object') {
                        return false;
                }
                // 6. For each e that is an element of entries, do
                for (var i = 0; i < entries.length; i++) {
                        var e = entries[i];
                        // a. If e is not empty and SameValue(e, value) is true, return true.
                        if (e !== undefMarker && SameValueZero(e, value)) {
                                return true;
                        }
                }
                // 7. Return false.
                return false;
        });

        // 23.4.3.5. WeakSet.prototype [ @@toStringTag ]
        // The initial value of the @@toStringTag property is the String value "WeakSet".
        // This property has the attributes { [[Writable]]: false, [[Enumerable]]: false, [[Configurable]]: true }.

        // Polyfill.io - Safari 8 implements Set.name but as a non-configurable property, which means it would throw an error if we try and configure it here.
        if (!('name' in WeakSet)) {
                // 19.2.4.2 name
                Object.defineProperty(WeakSet, 'name', {
                        configurable: true,
                        enumerable: false,
                        writable: false,
                        value: 'WeakSet'
                });
        }

        // Export the object
        try {
                CreateMethodProperty(global, 'WeakSet', WeakSet);
        } catch (e) {
                // IE8 throws an error here if we set enumerable to false.
                // More info on table 2: https://msdn.microsoft.com/en-us/library/dd229916(v=vs.85).aspx
                global['WeakSet'] = WeakSet;
        }

}(this));

}

})
.call('object' === typeof window && window || 'object' === typeof self && self || 'object' === typeof global && global || {});