diff --git a/.vscode/launch.json b/.vscode/launch.json index ac83a43..653bdc3 100644 --- a/.vscode/launch.json +++ b/.vscode/launch.json @@ -4,6 +4,7 @@ // For more information, visit: https://go.microsoft.com/fwlink/?linkid=830387 "version": "0.2.0", "configurations": [ + // { // "name": "Launch index.html", // "type": "firefox", @@ -31,6 +32,12 @@ "reAttach": true, "addonType": "webExtension", "addonPath": "${workspaceFolder}/src" + }, + { + "name": "Launch Node.JS", + "type": "node", + "request": "launch", + "program": "${file}" } ] } \ No newline at end of file diff --git a/node_modules/core-js/CHANGELOG.md b/node_modules/core-js/CHANGELOG.md new file mode 100644 index 0000000..d6b2876 --- /dev/null +++ b/node_modules/core-js/CHANGELOG.md @@ -0,0 +1,548 @@ +## Changelog +##### 2.3.0 - 2016.04.24 +- Added `asap` for enqueuing microtasks, [stage 0 proposal](https://github.com/rwaldron/tc39-notes/blob/master/es6/2014-09/sept-25.md#510-globalasap-for-enqueuing-a-microtask) +- Added well-known symbol `Symbol.asyncIterator` for [stage 2 async iteration proposal](https://github.com/tc39/proposal-async-iteration) +- Added well-known symbol `Symbol.observable` for [stage 1 observables proposal](https://github.com/zenparsing/es-observable) +- `String#{padStart, padEnd}` returns original string if filler is empty string, [T39 meeting notes](https://github.com/rwaldron/tc39-notes/blob/master/es7/2016-03/march-29.md#stringprototypepadstartpadend) +- `Object.values` and `Object.entries` moved to stage 4 from 3, [T39 meeting notes](https://github.com/rwaldron/tc39-notes/blob/master/es7/2016-03/march-29.md#objectvalues--objectentries) +- `System.global` moved to stage 2 from 1, [T39 meeting notes](https://github.com/rwaldron/tc39-notes/blob/master/es7/2016-03/march-29.md#systemglobal) +- `Map#toJSON` and `Set#toJSON` rejected and will be removed from the next major release, [T39 meeting notes](https://github.com/rwaldron/tc39-notes/blob/master/es7/2016-03/march-31.md#mapprototypetojsonsetprototypetojson) +- `Error.isError` withdrawn and will be removed from the next major release, [T39 meeting notes](https://github.com/rwaldron/tc39-notes/blob/master/es7/2016-03/march-29.md#erroriserror) +- Added fallback for `Function#name` on non-extensible functions and functions with broken `toString` conversion, [#193](https://github.com/zloirock/core-js/issues/193) + +##### 2.2.2 - 2016.04.06 +- Added conversion `-0` to `+0` to `Array#{indexOf, lastIndexOf}`, [ES2016 fix](https://github.com/tc39/ecma262/pull/316) +- Added fixes for some `Math` methods in Tor Browser +- `Array.{from, of}` no longer calls prototype setters +- Added workaround over Chrome DevTools strange behavior, [#186](https://github.com/zloirock/core-js/issues/186) + +##### 2.2.1 - 2016.03.19 +- Fixed `Object.getOwnPropertyNames(window)` `2.1+` versions bug, [#181](https://github.com/zloirock/core-js/issues/181) + +##### 2.2.0 - 2016.03.15 +- Added `String#matchAll`, [proposal](https://github.com/tc39/String.prototype.matchAll) +- Added `Object#__(define|lookup)[GS]etter__`, [annex B ES2017](https://github.com/tc39/ecma262/pull/381) +- Added `@@toPrimitive` methods to `Date` and `Symbol` +- Fixed `%TypedArray%#slice` in Edge ~ 13 (throws with `@@species` and wrapped / inherited constructor) +- Some other minor fixes + +##### 2.1.5 - 2016.03.12 +- Improved support NodeJS domains in `Promise#then`, [#180](https://github.com/zloirock/core-js/issues/180) +- Added fallback for `Date#toJSON` bug in Qt Script, [#173](https://github.com/zloirock/core-js/issues/173#issuecomment-193972502) + +##### 2.1.4 - 2016.03.08 +- Added fallback for `Symbol` polyfill in Qt Script, [#173](https://github.com/zloirock/core-js/issues/173) +- Added one more fallback for IE11 `Script Access Denied` error with iframes, [#165](https://github.com/zloirock/core-js/issues/165) + +##### 2.1.3 - 2016.02.29 +- Added fallback for [`es6-promise` package bug](https://github.com/stefanpenner/es6-promise/issues/169), [#176](https://github.com/zloirock/core-js/issues/176) + +##### 2.1.2 - 2016.02.29 +- Some minor `Promise` fixes: + - Browsers `rejectionhandled` event better HTML spec complaint + - Errors in unhandled rejection handlers should not cause any problems + - Fixed typo in feature detection + +##### 2.1.1 - 2016.02.22 +- Some `Promise` improvements: + - Feature detection: + - **Added detection unhandled rejection tracking support - now it's available everywhere**, [#140](https://github.com/zloirock/core-js/issues/140) + - Added detection `@@species` pattern support for completely correct subclassing + - Removed usage `Object.setPrototypeOf` from feature detection and noisy console message about it in FF + - `Promise.all` fixed for some very specific cases + +##### 2.1.0 - 2016.02.09 +- **API**: + - ES5 polyfills are split and logic, used in other polyfills, moved to internal modules + - **All entry point works in ES3 environment like IE8- without `core-js/(library/)es5`** + - **Added all missed single entry points for ES5 polyfills** + - Separated ES5 polyfills moved to the ES6 namespace. Why? + - Mainly, for prevent duplication features in different namespaces - logic of most required ES5 polyfills changed in ES6+: + - Already added changes for: `Object` statics - should accept primitives, new whitespaces lists in `String#trim`, `parse(Int|float)`, `RegExp#toString` logic, `String#split`, etc + - Should be changed in the future: `@@species` and `ToLength` logic in `Array` methods, `Date` parsing, `Function#bind`, etc + - Should not be changed only several features like `Array.isArray` and `Date.now` + - Some ES5 polyfills required for modern engines + - All old entry points should work fine, but in the next major release API can be changed + - `Object.getOwnPropertyDescriptors` moved to the stage 3, [January TC39 meeting](https://github.com/rwaldron/tc39-notes/blob/master/es7/2016-01/2016-01-28.md#objectgetownpropertydescriptors-to-stage-3-jordan-harband-low-priority-but-super-quick) + - Added `umd` option for [custom build process](https://github.com/zloirock/core-js#custom-build-from-external-scripts), [#169](https://github.com/zloirock/core-js/issues/169) + - Returned entry points for `Array` statics, removed in `2.0`, for compatibility with `babel` `6` and for future fixes +- **Deprecated**: + - `Reflect.enumerate` deprecated and will be removed from the next major release, [January TC39 meeting](https://github.com/rwaldron/tc39-notes/blob/master/es7/2016-01/2016-01-28.md#5xix-revisit-proxy-enumerate---revisit-decision-to-exhaust-iterator) +- **New Features**: + - Added [`Reflect` metadata API](https://github.com/jonathandturner/decorators/blob/master/specs/metadata.md) as a pre-strawman feature, [#152](https://github.com/zloirock/core-js/issues/152): + - `Reflect.defineMetadata` + - `Reflect.deleteMetadata` + - `Reflect.getMetadata` + - `Reflect.getMetadataKeys` + - `Reflect.getOwnMetadata` + - `Reflect.getOwnMetadataKeys` + - `Reflect.hasMetadata` + - `Reflect.hasOwnMetadata` + - `Reflect.metadata` + - Implementation / fixes `Date#toJSON` + - Fixes for `parseInt` and `Number.parseInt` + - Fixes for `parseFloat` and `Number.parseFloat` + - Fixes for `RegExp#toString` + - Fixes for `Array#sort` + - Fixes for `Number#toFixed` + - Fixes for `Number#toPrecision` + - Additional fixes for `String#split` (`RegExp#@@split`) +- **Improvements**: + - Correct subclassing wrapped collections, `Number` and `RegExp` constructors with native class syntax + - Correct support `SharedArrayBuffer` and buffers from other realms in typed arrays wrappers + - Additional validations for `Object.{defineProperty, getOwnPropertyDescriptor}` and `Reflect.defineProperty` +- **Bug Fixes**: + - Fixed some cases `Array#lastIndexOf` with negative second argument + +##### 2.0.3 - 2016.01.11 +- Added fallback for V8 ~ Chrome 49 `Promise` subclassing bug causes unhandled rejection on feature detection, [#159](https://github.com/zloirock/core-js/issues/159) +- Added fix for very specific environments with global `window === null` + +##### 2.0.2 - 2016.01.04 +- Temporarily removed `length` validation from `Uint8Array` constructor wrapper. Reason - [bug in `ws` module](https://github.com/websockets/ws/pull/645) (-> `socket.io`) which passes to `Buffer` constructor -> `Uint8Array` float and uses [the `V8` bug](https://code.google.com/p/v8/issues/detail?id=4552) for conversion to int (by the spec should be thrown an error). [It creates problems for many people.](https://github.com/karma-runner/karma/issues/1768) I hope, it will be returned after fixing this bug in `V8`. + +##### 2.0.1 - 2015.12.31 +- forced usage `Promise.resolve` polyfill in the `library` version for correct work with wrapper +- `Object.assign` should be defined in the strict mode -> throw an error on extension non-extensible objects, [#154](https://github.com/zloirock/core-js/issues/154) + +##### 2.0.0 - 2015.12.24 +- added implementations and fixes [Typed Arrays](https://github.com/zloirock/core-js#ecmascript-6-typed-arrays)-related features + - `ArrayBuffer`, `ArrayBuffer.isView`, `ArrayBuffer#slice` + - `DataView` with all getter / setter methods + - `Int8Array`, `Uint8Array`, `Uint8ClampedArray`, `Int16Array`, `Uint16Array`, `Int32Array`, `Uint32Array`, `Float32Array` and `Float64Array` constructors + - `%TypedArray%.{for, of}`, `%TypedArray%#{copyWithin, every, fill, filter, find, findIndex, forEach, indexOf, includes, join, lastIndexOf, map, reduce, reduceRight, reverse, set, slice, some, sort, subarray, values, keys, entries, @@iterator, ...}` +- added [`System.global`](https://github.com/zloirock/core-js#ecmascript-7-proposals), [proposal](https://github.com/tc39/proposal-global), [November TC39 meeting](https://github.com/rwaldron/tc39-notes/tree/master/es7/2015-11/nov-19.md#systemglobal-jhd) +- added [`Error.isError`](https://github.com/zloirock/core-js#ecmascript-7-proposals), [proposal](https://github.com/ljharb/proposal-is-error), [November TC39 meeting](https://github.com/rwaldron/tc39-notes/tree/master/es7/2015-11/nov-19.md#jhd-erroriserror) +- added [`Math.{iaddh, isubh, imulh, umulh}`](https://github.com/zloirock/core-js#ecmascript-7-proposals), [proposal](https://gist.github.com/BrendanEich/4294d5c212a6d2254703) +- `RegExp.escape` moved from the `es7` to the non-standard `core` namespace, [July TC39 meeting](https://github.com/rwaldron/tc39-notes/blob/master/es7/2015-07/july-28.md#62-regexpescape) - too slow, but it's condition of stability, [#116](https://github.com/zloirock/core-js/issues/116) +- [`Promise`](https://github.com/zloirock/core-js#ecmascript-6-promise) + - some performance optimisations + - added basic support [`rejectionHandled` event / `onrejectionhandled` handler](https://github.com/zloirock/core-js#unhandled-rejection-tracking) to the polyfill + - removed usage `@@species` from `Promise.{all, race}`, [November TC39 meeting](https://github.com/rwaldron/tc39-notes/tree/master/es7/2015-11/nov-18.md#conclusionresolution-2) +- some improvements [collections polyfills](https://github.com/zloirock/core-js#ecmascript-6-collections) + - `O(1)` and preventing possible leaks with frozen keys, [#134](https://github.com/zloirock/core-js/issues/134) + - correct observable state object keys +- renamed `String#{padLeft, padRight}` -> [`String#{padStart, padEnd}`](https://github.com/zloirock/core-js#ecmascript-7-proposals), [proposal](https://github.com/tc39/proposal-string-pad-start-end), [November TC39 meeting](https://github.com/rwaldron/tc39-notes/tree/master/es7/2015-11/nov-17.md#conclusionresolution-2) (they want to rename it on each meeting?O_o), [#132](https://github.com/zloirock/core-js/issues/132) +- added [`String#{trimStart, trimEnd}` as aliases for `String#{trimLeft, trimRight}`](https://github.com/zloirock/core-js#ecmascript-7-proposals), [proposal](https://github.com/sebmarkbage/ecmascript-string-left-right-trim), [November TC39 meeting](https://github.com/rwaldron/tc39-notes/tree/master/es7/2015-11/nov-17.md#conclusionresolution-2) +- added [annex B HTML methods](https://github.com/zloirock/core-js#ecmascript-6-string) - ugly, but also [the part of the spec](http://www.ecma-international.org/ecma-262/6.0/#sec-string.prototype.anchor) +- added little fix for [`Date#toString`](https://github.com/zloirock/core-js#ecmascript-6-date) - `new Date(NaN).toString()` [should be `'Invalid Date'`](http://www.ecma-international.org/ecma-262/6.0/#sec-todatestring) +- added [`{keys, values, entries, @@iterator}` methods to DOM collections](https://github.com/zloirock/core-js#iterable-dom-collections) which should have [iterable interface](https://heycam.github.io/webidl/#idl-iterable) or should be [inherited from `Array`](https://heycam.github.io/webidl/#LegacyArrayClass) - `NodeList`, `DOMTokenList`, `MediaList`, `StyleSheetList`, `CSSRuleList`. +- removed Mozilla `Array` generics - [deprecated and will be removed from FF](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array#Array_generic_methods), [looks like strawman is dead](http://wiki.ecmascript.org/doku.php?id=strawman:array_statics), available [alternative shim](https://github.com/plusdude/array-generics) +- removed `core.log` module +- CommonJS API + - added entry points for [virtual methods](https://github.com/zloirock/core-js#commonjs-and-prototype-methods-without-global-namespace-pollution) + - added entry points for [stages proposals](https://github.com/zloirock/core-js#ecmascript-7-proposals) + - some other minor changes +- [custom build from external scripts](https://github.com/zloirock/core-js#custom-build-from-external-scripts) moved to the separate package for preventing problems with dependencies +- changed `$` prefix for internal modules file names because Team Foundation Server does not support it, [#129](https://github.com/zloirock/core-js/issues/129) +- additional fix for `SameValueZero` in V8 ~ Chromium 39-42 collections +- additional fix for FF27 `Array` iterator +- removed usage shortcuts for `arguments` object - old WebKit bug, [#150](https://github.com/zloirock/core-js/issues/150) +- `{Map, Set}#forEach` non-generic, [#144](https://github.com/zloirock/core-js/issues/144) +- many other improvements + +##### 1.2.6 - 2015.11.09 +* reject with `TypeError` on attempt resolve promise itself +* correct behavior with broken `Promise` subclass constructors / methods +* added `Promise`-based fallback for microtask +* fixed V8 and FF `Array#{values, @@iterator}.name` +* fixed IE7- `[1, 2].join(undefined) -> '1,2'` +* some other fixes / improvements / optimizations + +##### 1.2.5 - 2015.11.02 +* some more `Number` constructor fixes: + * fixed V8 ~ Node 0.8 bug: `Number('+0x1')` should be `NaN` + * fixed `Number(' 0b1\n')` case, should be `1` + * fixed `Number()` case, should be `0` + +##### 1.2.4 - 2015.11.01 +* fixed `Number('0b12') -> NaN` case in the shim +* fixed V8 ~ Chromium 40- bug - `Weak(Map|Set)#{delete, get, has}` should not throw errors [#124](https://github.com/zloirock/core-js/issues/124) +* some other fixes and optimizations + +##### 1.2.3 - 2015.10.23 +* fixed some problems related old V8 bug `Object('a').propertyIsEnumerable(0) // => false`, for example, `Object.assign({}, 'qwe')` from the last release +* fixed `.name` property and `Function#toString` conversion some polyfilled methods +* fixed `Math.imul` arity in Safari 8- + +##### 1.2.2 - 2015.10.18 +* improved optimisations for V8 +* fixed build process from external packages, [#120](https://github.com/zloirock/core-js/pull/120) +* one more `Object.{assign, values, entries}` fix for [**very** specific case](https://github.com/ljharb/proposal-object-values-entries/issues/5) + +##### 1.2.1 - 2015.10.02 +* replaced fix `JSON.stringify` + `Symbol` behavior from `.toJSON` method to wrapping `JSON.stringify` - little more correct, [compat-table/642](https://github.com/kangax/compat-table/pull/642) +* fixed typo which broke tasks scheduler in WebWorkers in old FF, [#114](https://github.com/zloirock/core-js/pull/114) + +##### 1.2.0 - 2015.09.27 +* added browser [`Promise` rejection hook](#unhandled-rejection-tracking), [#106](https://github.com/zloirock/core-js/issues/106) +* added correct [`IsRegExp`](http://www.ecma-international.org/ecma-262/6.0/#sec-isregexp) logic to [`String#{includes, startsWith, endsWith}`](https://github.com/zloirock/core-js/#ecmascript-6-string) and [`RegExp` constructor](https://github.com/zloirock/core-js/#ecmascript-6-regexp), `@@match` case, [example](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Symbol/match#Disabling_the_isRegExp_check) +* updated [`String#leftPad`](https://github.com/zloirock/core-js/#ecmascript-7-proposals) [with proposal](https://github.com/ljharb/proposal-string-pad-left-right/issues/6): string filler truncated from the right side +* replaced V8 [`Object.assign`](https://github.com/zloirock/core-js/#ecmascript-6-object) - its properties order not only [incorrect](https://github.com/sindresorhus/object-assign/issues/22), it is non-deterministic and it causes some problems +* fixed behavior with deleted in getters properties for `Object.{`[`assign`](https://github.com/zloirock/core-js/#ecmascript-6-object)`, `[`entries, values`](https://github.com/zloirock/core-js/#ecmascript-7-proposals)`}`, [example](http://goo.gl/iQE01c) +* fixed [`Math.sinh`](https://github.com/zloirock/core-js/#ecmascript-6-math) with very small numbers in V8 near Chromium 38 +* some other fixes and optimizations + +##### 1.1.4 - 2015.09.05 +* fixed support symbols in FF34-35 [`Object.assign`](https://github.com/zloirock/core-js/#ecmascript-6-object) +* fixed [collections iterators](https://github.com/zloirock/core-js/#ecmascript-6-iterators) in FF25-26 +* fixed non-generic WebKit [`Array.of`](https://github.com/zloirock/core-js/#ecmascript-6-array) +* some other fixes and optimizations + +##### 1.1.3 - 2015.08.29 +* fixed support Node.js domains in [`Promise`](https://github.com/zloirock/core-js/#ecmascript-6-promise), [#103](https://github.com/zloirock/core-js/issues/103) + +##### 1.1.2 - 2015.08.28 +* added `toJSON` method to [`Symbol`](https://github.com/zloirock/core-js/#ecmascript-6-symbol) polyfill and to MS Edge implementation for expected `JSON.stringify` result w/o patching this method +* replaced [`Reflect.construct`](https://github.com/zloirock/core-js/#ecmascript-6-reflect) implementations w/o correct support third argument +* fixed `global` detection with changed `document.domain` in ~IE8, [#100](https://github.com/zloirock/core-js/issues/100) + +##### 1.1.1 - 2015.08.20 +* added more correct microtask implementation for [`Promise`](#ecmascript-6-promise) + +##### 1.1.0 - 2015.08.17 +* updated [string padding](https://github.com/zloirock/core-js/#ecmascript-7-proposals) to [actual proposal](https://github.com/ljharb/proposal-string-pad-left-right) - renamed, minor internal changes: + * `String#lpad` -> `String#padLeft` + * `String#rpad` -> `String#padRight` +* added [string trim functions](#ecmascript-7-proposals) - [proposal](https://github.com/sebmarkbage/ecmascript-string-left-right-trim), defacto standard - required only for IE11- and fixed for some old engines: + * `String#trimLeft` + * `String#trimRight` +* [`String#trim`](https://github.com/zloirock/core-js/#ecmascript-6-string) fixed for some engines by es6 spec and moved from `es5` to single `es6` module +* splitted [`es6.object.statics-accept-primitives`](https://github.com/zloirock/core-js/#ecmascript-6-object) +* caps for `freeze`-family `Object` methods moved from `es5` to `es6` namespace and joined with [es6 wrappers](https://github.com/zloirock/core-js/#ecmascript-6-object) +* `es5` [namespace](https://github.com/zloirock/core-js/#commonjs) also includes modules, moved to `es6` namespace - you can use it as before +* increased `MessageChannel` priority in `$.task`, [#95](https://github.com/zloirock/core-js/issues/95) +* does not get `global.Symbol` on each getting iterator, if you wanna use alternative `Symbol` shim - add it before `core-js` +* [`Reflect.construct`](https://github.com/zloirock/core-js/#ecmascript-6-reflect) optimized and fixed for some cases +* simplified [`Reflect.enumerate`](https://github.com/zloirock/core-js/#ecmascript-6-reflect), see [this question](https://esdiscuss.org/topic/question-about-enumerate-and-property-decision-timing) +* some corrections in [`Math.acosh`](https://github.com/zloirock/core-js/#ecmascript-6-math) +* fixed [`Math.imul`](https://github.com/zloirock/core-js/#ecmascript-6-math) for old WebKit +* some fixes in string / RegExp [well-known symbols](https://github.com/zloirock/core-js/#ecmascript-6-regexp) logic +* some other fixes and optimizations + +##### 1.0.1 - 2015.07.31 +* some fixes for final MS Edge, replaced broken native `Reflect.defineProperty` +* some minor fixes and optimizations +* changed compression `client/*.min.js` options for safe `Function#name` and `Function#length`, should be fixed [#92](https://github.com/zloirock/core-js/issues/92) + +##### 1.0.0 - 2015.07.22 +* added logic for [well-known symbols](https://github.com/zloirock/core-js/#ecmascript-6-regexp): + * `Symbol.match` + * `Symbol.replace` + * `Symbol.split` + * `Symbol.search` +* actualized and optimized work with iterables: + * optimized [`Map`, `Set`, `WeakMap`, `WeakSet` constructors](https://github.com/zloirock/core-js/#ecmascript-6-collections), [`Promise.all`, `Promise.race`](https://github.com/zloirock/core-js/#ecmascript-6-promise) for default `Array Iterator` + * optimized [`Array.from`](https://github.com/zloirock/core-js/#ecmascript-6-array) for default `Array Iterator` + * added [`core.getIteratorMethod`](https://github.com/zloirock/core-js/#ecmascript-6-iterators) helper +* uses enumerable properties in shimmed instances - collections, iterators, etc for optimize performance +* added support native constructors to [`Reflect.construct`](https://github.com/zloirock/core-js/#ecmascript-6-reflect) with 2 arguments +* added support native constructors to [`Function#bind`](https://github.com/zloirock/core-js/#ecmascript-5) shim with `new` +* removed obsolete `.clear` methods native [`Weak`-collections](https://github.com/zloirock/core-js/#ecmascript-6-collections) +* maximum modularity, reduced minimal custom build size, separated into submodules: + * [`es6.reflect`](https://github.com/zloirock/core-js/#ecmascript-6-reflect) + * [`es6.regexp`](https://github.com/zloirock/core-js/#ecmascript-6-regexp) + * [`es6.math`](https://github.com/zloirock/core-js/#ecmascript-6-math) + * [`es6.number`](https://github.com/zloirock/core-js/#ecmascript-6-number) + * [`es7.object.to-array`](https://github.com/zloirock/core-js/#ecmascript-7-proposals) + * [`core.object`](https://github.com/zloirock/core-js/#object) + * [`core.string`](https://github.com/zloirock/core-js/#escaping-strings) + * [`core.iter-helpers`](https://github.com/zloirock/core-js/#ecmascript-6-iterators) + * internal modules (`$`, `$.iter`, etc) +* many other optimizations +* final cleaning non-standard features + * moved `$for` to [separate library](https://github.com/zloirock/forof). This work for syntax - `for-of` loop and comprehensions + * moved `Date#{format, formatUTC}` to [separate library](https://github.com/zloirock/dtf). Standard way for this - `ECMA-402` + * removed `Math` methods from `Number.prototype`. Slight sugar for simple `Math` methods calling + * removed `{Array#, Array, Dict}.turn` + * removed `core.global` +* uses `ToNumber` instead of `ToLength` in [`Number Iterator`](https://github.com/zloirock/core-js/#number-iterator), `Array.from(2.5)` will be `[0, 1, 2]` instead of `[0, 1]` +* fixed [#85](https://github.com/zloirock/core-js/issues/85) - invalid `Promise` unhandled rejection message in nested `setTimeout` +* fixed [#86](https://github.com/zloirock/core-js/issues/86) - support FF extensions +* fixed [#89](https://github.com/zloirock/core-js/issues/89) - behavior `Number` constructor in strange case + +##### 0.9.18 - 2015.06.17 +* removed `/` from [`RegExp.escape`](https://github.com/zloirock/core-js/#ecmascript-7-proposals) escaped characters + +##### 0.9.17 - 2015.06.14 +* updated [`RegExp.escape`](https://github.com/zloirock/core-js/#ecmascript-7-proposals) to the [latest proposal](https://github.com/benjamingr/RexExp.escape) +* fixed conflict with webpack dev server + IE buggy behavior + +##### 0.9.16 - 2015.06.11 +* more correct order resolving thenable in [`Promise`](https://github.com/zloirock/core-js/#ecmascript-6-promise) polyfill +* uses polyfill instead of [buggy V8 `Promise`](https://github.com/zloirock/core-js/issues/78) + +##### 0.9.15 - 2015.06.09 +* [collections](https://github.com/zloirock/core-js/#ecmascript-6-collections) from `library` version return wrapped native instances +* fixed collections prototype methods in `library` version +* optimized [`Math.hypot`](https://github.com/zloirock/core-js/#ecmascript-6-math) + +##### 0.9.14 - 2015.06.04 +* updated [`Promise.resolve` behavior](https://esdiscuss.org/topic/fixing-promise-resolve) +* added fallback for IE11 buggy `Object.getOwnPropertyNames` + iframe +* some other fixes + +##### 0.9.13 - 2015.05.25 +* added fallback for [`Symbol` polyfill](https://github.com/zloirock/core-js/#ecmascript-6-symbol) for old Android +* some other fixes + +##### 0.9.12 - 2015.05.24 +* different instances `core-js` should use / recognize the same symbols +* some fixes + +##### 0.9.11 - 2015.05.18 +* simplified [custom build](https://github.com/zloirock/core-js/#custom-build) + * add custom build js api + * added `grunt-cli` to `devDependencies` for `npm run grunt` +* some fixes + +##### 0.9.10 - 2015.05.16 +* wrapped `Function#toString` for correct work wrapped methods / constructors with methods similar to the [`lodash` `isNative`](https://github.com/lodash/lodash/issues/1197) +* added proto versions of methods to export object in `default` version for consistency with `library` version + +##### 0.9.9 - 2015.05.14 +* wrapped `Object#propertyIsEnumerable` for [`Symbol` polyfill](https://github.com/zloirock/core-js/#ecmascript-6-symbol) +* [added proto versions of methods to `library` for ES7 bind syntax](https://github.com/zloirock/core-js/issues/65) +* some other fixes + +##### 0.9.8 - 2015.05.12 +* fixed [`Math.hypot`](https://github.com/zloirock/core-js/#ecmascript-6-math) with negative arguments +* added `Object#toString.toString` as fallback for [`lodash` `isNative`](https://github.com/lodash/lodash/issues/1197) + +##### 0.9.7 - 2015.05.07 +* added [support DOM collections](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/slice#Streamlining_cross-browser_behavior) to IE8- `Array#slice` + +##### 0.9.6 - 2015.05.01 +* added [`String#lpad`, `String#rpad`](https://github.com/zloirock/core-js/#ecmascript-7-proposals) + +##### 0.9.5 - 2015.04.30 +* added cap for `Function#@@hasInstance` +* some fixes and optimizations + +##### 0.9.4 - 2015.04.27 +* fixed `RegExp` constructor + +##### 0.9.3 - 2015.04.26 +* some fixes and optimizations + +##### 0.9.2 - 2015.04.25 +* more correct [`Promise`](https://github.com/zloirock/core-js/#ecmascript-6-promise) unhandled rejection tracking and resolving / rejection priority + +##### 0.9.1 - 2015.04.25 +* fixed `__proto__`-based [`Promise`](https://github.com/zloirock/core-js/#ecmascript-6-promise) subclassing in some environments + +##### 0.9.0 - 2015.04.24 +* added correct [symbols](https://github.com/zloirock/core-js/#ecmascript-6-symbol) descriptors + * fixed behavior `Object.{assign, create, defineProperty, defineProperties, getOwnPropertyDescriptor, getOwnPropertyDescriptors}` with symbols + * added [single entry points](https://github.com/zloirock/core-js/#commonjs) for `Object.{create, defineProperty, defineProperties}` +* added [`Map#toJSON`](https://github.com/zloirock/core-js/#ecmascript-7-proposals) +* removed non-standard methods `Object#[_]` and `Function#only` - they solves syntax problems, but now in compilers available arrows and ~~in near future will be available~~ [available](http://babeljs.io/blog/2015/05/14/function-bind/) [bind syntax](https://github.com/zenparsing/es-function-bind) +* removed non-standard undocumented methods `Symbol.{pure, set}` +* some fixes and internal changes + +##### 0.8.4 - 2015.04.18 +* uses `webpack` instead of `browserify` for browser builds - more compression-friendly result + +##### 0.8.3 - 2015.04.14 +* fixed `Array` statics with single entry points + +##### 0.8.2 - 2015.04.13 +* [`Math.fround`](https://github.com/zloirock/core-js/#ecmascript-6-math) now also works in IE9- +* added [`Set#toJSON`](https://github.com/zloirock/core-js/#ecmascript-7-proposals) +* some optimizations and fixes + +##### 0.8.1 - 2015.04.03 +* fixed `Symbol.keyFor` + +##### 0.8.0 - 2015.04.02 +* changed [CommonJS API](https://github.com/zloirock/core-js/#commonjs) +* splitted and renamed some modules +* added support ES3 environment (ES5 polyfill) to **all** default versions - size increases slightly (+ ~4kb w/o gzip), many issues disappear, if you don't need it - [simply include only required namespaces / features / modules](https://github.com/zloirock/core-js/#commonjs) +* removed [abstract references](https://github.com/zenparsing/es-abstract-refs) support - proposal has been superseded =\ +* [`$for.isIterable` -> `core.isIterable`, `$for.getIterator` -> `core.getIterator`](https://github.com/zloirock/core-js/#ecmascript-6-iterators), temporary available in old namespace +* fixed iterators support in v8 `Promise.all` and `Promise.race` +* many other fixes + +##### 0.7.2 - 2015.03.09 +* some fixes + +##### 0.7.1 - 2015.03.07 +* some fixes + +##### 0.7.0 - 2015.03.06 +* rewritten and splitted into [CommonJS modules](https://github.com/zloirock/core-js/#commonjs) + +##### 0.6.1 - 2015.02.24 +* fixed support [`Object.defineProperty`](https://github.com/zloirock/core-js/#ecmascript-5) with accessors on DOM elements on IE8 + +##### 0.6.0 - 2015.02.23 +* added support safe closing iteration - calling `iterator.return` on abort iteration, if it exists +* added basic support [`Promise`](https://github.com/zloirock/core-js/#ecmascript-6-promise) unhandled rejection tracking in shim +* added [`Object.getOwnPropertyDescriptors`](https://github.com/zloirock/core-js/#ecmascript-7-proposals) +* removed `console` cap - creates too many problems +* restructuring [namespaces](https://github.com/zloirock/core-js/#custom-build) +* some fixes + +##### 0.5.4 - 2015.02.15 +* some fixes + +##### 0.5.3 - 2015.02.14 +* added [support binary and octal literals](https://github.com/zloirock/core-js/#ecmascript-6-number) to `Number` constructor +* added [`Date#toISOString`](https://github.com/zloirock/core-js/#ecmascript-5) + +##### 0.5.2 - 2015.02.10 +* some fixes + +##### 0.5.1 - 2015.02.09 +* some fixes + +##### 0.5.0 - 2015.02.08 +* systematization of modules +* splitted [`es6` module](https://github.com/zloirock/core-js/#ecmascript-6) +* splitted `console` module: `web.console` - only cap for missing methods, `core.log` - bound methods & additional features +* added [`delay` method](https://github.com/zloirock/core-js/#delay) +* some fixes + +##### 0.4.10 - 2015.01.28 +* [`Object.getOwnPropertySymbols`](https://github.com/zloirock/core-js/#ecmascript-6-symbol) polyfill returns array of wrapped keys + +##### 0.4.9 - 2015.01.27 +* FF20-24 fix + +##### 0.4.8 - 2015.01.25 +* some [collections](https://github.com/zloirock/core-js/#ecmascript-6-collections) fixes + +##### 0.4.7 - 2015.01.25 +* added support frozen objects as [collections](https://github.com/zloirock/core-js/#ecmascript-6-collections) keys + +##### 0.4.6 - 2015.01.21 +* added [`Object.getOwnPropertySymbols`](https://github.com/zloirock/core-js/#ecmascript-6-symbol) +* added [`NodeList.prototype[@@iterator]`](https://github.com/zloirock/core-js/#ecmascript-6-iterators) +* added basic `@@species` logic - getter in native constructors +* removed `Function#by` +* some fixes + +##### 0.4.5 - 2015.01.16 +* some fixes + +##### 0.4.4 - 2015.01.11 +* enabled CSP support + +##### 0.4.3 - 2015.01.10 +* added `Function` instances `name` property for IE9+ + +##### 0.4.2 - 2015.01.10 +* `Object` static methods accept primitives +* `RegExp` constructor can alter flags (IE9+) +* added `Array.prototype[Symbol.unscopables]` + +##### 0.4.1 - 2015.01.05 +* some fixes + +##### 0.4.0 - 2015.01.03 +* added [`es6.reflect`](https://github.com/zloirock/core-js/#ecmascript-6-reflect) module: + * added `Reflect.apply` + * added `Reflect.construct` + * added `Reflect.defineProperty` + * added `Reflect.deleteProperty` + * added `Reflect.enumerate` + * added `Reflect.get` + * added `Reflect.getOwnPropertyDescriptor` + * added `Reflect.getPrototypeOf` + * added `Reflect.has` + * added `Reflect.isExtensible` + * added `Reflect.preventExtensions` + * added `Reflect.set` + * added `Reflect.setPrototypeOf` +* `core-js` methods now can use external `Symbol.iterator` polyfill +* some fixes + +##### 0.3.3 - 2014.12.28 +* [console cap](https://github.com/zloirock/core-js/#console) excluded from node.js default builds + +##### 0.3.2 - 2014.12.25 +* added cap for [ES5](https://github.com/zloirock/core-js/#ecmascript-5) freeze-family methods +* fixed `console` bug + +##### 0.3.1 - 2014.12.23 +* some fixes + +##### 0.3.0 - 2014.12.23 +* Optimize [`Map` & `Set`](https://github.com/zloirock/core-js/#ecmascript-6-collections): + * use entries chain on hash table + * fast & correct iteration + * iterators moved to [`es6`](https://github.com/zloirock/core-js/#ecmascript-6) and [`es6.collections`](https://github.com/zloirock/core-js/#ecmascript-6-collections) modules + +##### 0.2.5 - 2014.12.20 +* `console` no longer shortcut for `console.log` (compatibility problems) +* some fixes + +##### 0.2.4 - 2014.12.17 +* better compliance of ES6 +* added [`Math.fround`](https://github.com/zloirock/core-js/#ecmascript-6-math) (IE10+) +* some fixes + +##### 0.2.3 - 2014.12.15 +* [Symbols](https://github.com/zloirock/core-js/#ecmascript-6-symbol): + * added option to disable addition setter to `Object.prototype` for Symbol polyfill: + * added `Symbol.useSimple` + * added `Symbol.useSetter` + * added cap for well-known Symbols: + * added `Symbol.hasInstance` + * added `Symbol.isConcatSpreadable` + * added `Symbol.match` + * added `Symbol.replace` + * added `Symbol.search` + * added `Symbol.species` + * added `Symbol.split` + * added `Symbol.toPrimitive` + * added `Symbol.unscopables` + +##### 0.2.2 - 2014.12.13 +* added [`RegExp#flags`](https://github.com/zloirock/core-js/#ecmascript-6-regexp) ([December 2014 Draft Rev 29](http://wiki.ecmascript.org/doku.php?id=harmony:specification_drafts#december_6_2014_draft_rev_29)) +* added [`String.raw`](https://github.com/zloirock/core-js/#ecmascript-6-string) + +##### 0.2.1 - 2014.12.12 +* repair converting -0 to +0 in [native collections](https://github.com/zloirock/core-js/#ecmascript-6-collections) + +##### 0.2.0 - 2014.12.06 +* added [`es7.proposals`](https://github.com/zloirock/core-js/#ecmascript-7-proposals) and [`es7.abstract-refs`](https://github.com/zenparsing/es-abstract-refs) modules +* added [`String#at`](https://github.com/zloirock/core-js/#ecmascript-7-proposals) +* added real [`String Iterator`](https://github.com/zloirock/core-js/#ecmascript-6-iterators), older versions used Array Iterator +* added abstract references support: + * added `Symbol.referenceGet` + * added `Symbol.referenceSet` + * added `Symbol.referenceDelete` + * added `Function#@@referenceGet` + * added `Map#@@referenceGet` + * added `Map#@@referenceSet` + * added `Map#@@referenceDelete` + * added `WeakMap#@@referenceGet` + * added `WeakMap#@@referenceSet` + * added `WeakMap#@@referenceDelete` + * added `Dict.{...methods}[@@referenceGet]` +* removed deprecated `.contains` methods +* some fixes + +##### 0.1.5 - 2014.12.01 +* added [`Array#copyWithin`](https://github.com/zloirock/core-js/#ecmascript-6-array) +* added [`String#codePointAt`](https://github.com/zloirock/core-js/#ecmascript-6-string) +* added [`String.fromCodePoint`](https://github.com/zloirock/core-js/#ecmascript-6-string) + +##### 0.1.4 - 2014.11.27 +* added [`Dict.mapPairs`](https://github.com/zloirock/core-js/#dict) + +##### 0.1.3 - 2014.11.20 +* [TC39 November meeting](https://github.com/rwaldron/tc39-notes/tree/master/es6/2014-11): + * [`.contains` -> `.includes`](https://github.com/rwaldron/tc39-notes/blob/master/es6/2014-11/nov-18.md#51--44-arrayprototypecontains-and-stringprototypecontains) + * `String#contains` -> [`String#includes`](https://github.com/zloirock/core-js/#ecmascript-6-string) + * `Array#contains` -> [`Array#includes`](https://github.com/zloirock/core-js/#ecmascript-7-proposals) + * `Dict.contains` -> [`Dict.includes`](https://github.com/zloirock/core-js/#dict) + * [removed `WeakMap#clear`](https://github.com/rwaldron/tc39-notes/blob/master/es6/2014-11/nov-19.md#412-should-weakmapweakset-have-a-clear-method-markm) + * [removed `WeakSet#clear`](https://github.com/rwaldron/tc39-notes/blob/master/es6/2014-11/nov-19.md#412-should-weakmapweakset-have-a-clear-method-markm) + +##### 0.1.2 - 2014.11.19 +* `Map` & `Set` bug fix + +##### 0.1.1 - 2014.11.18 +* public release \ No newline at end of file diff --git a/node_modules/core-js/Gruntfile.js b/node_modules/core-js/Gruntfile.js new file mode 100644 index 0000000..afbcd94 --- /dev/null +++ b/node_modules/core-js/Gruntfile.js @@ -0,0 +1,2 @@ +require('LiveScript'); +module.exports = require('./build/Gruntfile'); \ No newline at end of file diff --git a/node_modules/core-js/LICENSE b/node_modules/core-js/LICENSE new file mode 100644 index 0000000..c99b842 --- /dev/null +++ b/node_modules/core-js/LICENSE @@ -0,0 +1,19 @@ +Copyright (c) 2014-2016 Denis Pushkarev + +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. diff --git a/node_modules/core-js/README.md b/node_modules/core-js/README.md new file mode 100644 index 0000000..8873fdc --- /dev/null +++ b/node_modules/core-js/README.md @@ -0,0 +1,1987 @@ +# core-js + +[![Gitter](https://badges.gitter.im/Join%20Chat.svg)](https://gitter.im/zloirock/core-js?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge) [![version](https://img.shields.io/npm/v/core-js.svg)](https://www.npmjs.com/package/core-js) [![npm downloads](https://img.shields.io/npm/dm/core-js.svg)](http://npm-stat.com/charts.html?package=core-js&author=&from=2014-11-18&to=2114-11-18) [![Build Status](https://travis-ci.org/zloirock/core-js.svg)](https://travis-ci.org/zloirock/core-js) [![devDependency status](https://david-dm.org/zloirock/core-js/dev-status.svg)](https://david-dm.org/zloirock/core-js#info=devDependencies) +#### As advertising: the author is looking for a good job :) + +Modular standard library for JavaScript. Includes polyfills for [ECMAScript 5](#ecmascript-5), [ECMAScript 6](#ecmascript-6): [promises](#ecmascript-6-promise), [symbols](#ecmascript-6-symbol), [collections](#ecmascript-6-collections), iterators, [typed arrays](#ecmascript-6-typed-arrays), [ECMAScript 7+ proposals](#ecmascript-7-proposals), [setImmediate](#setimmediate), etc. Some additional features such as [dictionaries](#dict) or [extended partial application](#partial-application). You can require only needed features or use it without global namespace pollution. + +[*Example*](http://goo.gl/a2xexl): +```js +Array.from(new Set([1, 2, 3, 2, 1])); // => [1, 2, 3] +'*'.repeat(10); // => '**********' +Promise.resolve(32).then(x => console.log(x)); // => 32 +setImmediate(x => console.log(x), 42); // => 42 +``` + +[*Without global namespace pollution*](http://goo.gl/paOHb0): +```js +var core = require('core-js/library'); // With a modular system, otherwise use global `core` +core.Array.from(new core.Set([1, 2, 3, 2, 1])); // => [1, 2, 3] +core.String.repeat('*', 10); // => '**********' +core.Promise.resolve(32).then(x => console.log(x)); // => 32 +core.setImmediate(x => console.log(x), 42); // => 42 +``` + +### Index +- [Usage](#usage) + - [Basic](#basic) + - [CommonJS](#commonjs) + - [Custom build](#custom-build-from-the-command-line) +- [Supported engines](#supported-engines) +- [Features](#features) + - [ECMAScript 5](#ecmascript-5) + - [ECMAScript 6](#ecmascript-6) + - [ECMAScript 6: Object](#ecmascript-6-object) + - [ECMAScript 6: Function](#ecmascript-6-function) + - [ECMAScript 6: Array](#ecmascript-6-array) + - [ECMAScript 6: String](#ecmascript-6-string) + - [ECMAScript 6: RegExp](#ecmascript-6-regexp) + - [ECMAScript 6: Number](#ecmascript-6-number) + - [ECMAScript 6: Math](#ecmascript-6-math) + - [ECMAScript 6: Date](#ecmascript-6-date) + - [ECMAScript 6: Promise](#ecmascript-6-promise) + - [ECMAScript 6: Symbol](#ecmascript-6-symbol) + - [ECMAScript 6: Collections](#ecmascript-6-collections) + - [ECMAScript 6: Typed Arrays](#ecmascript-6-typed-arrays) + - [ECMAScript 6: Reflect](#ecmascript-6-reflect) + - [ECMAScript 7+ proposals](#ecmascript-7-proposals) + - [Web standards](#web-standards) + - [setTimeout / setInterval](#settimeout--setinterval) + - [setImmediate](#setimmediate) + - [Iterable DOM collections](#iterable-dom-collections) + - [Non-standard](#non-standard) + - [Object](#object) + - [Dict](#dict) + - [Partial application](#partial-application) + - [Number Iterator](#number-iterator) + - [Escaping strings](#escaping-strings) + - [delay](#delay) + - [Helpers for iterators](#helpers-for-iterators) +- [Missing polyfills](#missing-polyfills) +- [Changelog](./CHANGELOG.md) + +## Usage +### Basic +``` +npm i core-js +bower install core.js +``` + +```js +// Default +require('core-js'); +// Without global namespace pollution +var core = require('core-js/library'); +// Shim only +require('core-js/shim'); +``` +If you need complete build for browser, use builds from `core-js/client` path: + +* [default](https://raw.githack.com/zloirock/core-js/v2.3.0/client/core.min.js): Includes all features, standard and non-standard. +* [as a library](https://raw.githack.com/zloirock/core-js/v2.3.0/client/library.min.js): Like "default", but does not pollute the global namespace (see [2nd example at the top](#core-js)). +* [shim only](https://raw.githack.com/zloirock/core-js/v2.3.0/client/shim.min.js): Only includes the standard methods. + +Warning: if you use `core-js` with the extension of native objects, require all needed `core-js` modules at the beginning of entry point of your application, otherwise, conflicts may occur. + +### CommonJS +You can require only needed modules. + +```js +require('core-js/fn/set'); +require('core-js/fn/array/from'); +require('core-js/fn/array/find-index'); +Array.from(new Set([1, 2, 3, 2, 1])); // => [1, 2, 3] +[1, 2, NaN, 3, 4].findIndex(isNaN); // => 2 + +// or, w/o global namespace pollution: + +var Set = require('core-js/library/fn/set'); +var from = require('core-js/library/fn/array/from'); +var findIndex = require('core-js/library/fn/array/find-index'); +from(new Set([1, 2, 3, 2, 1])); // => [1, 2, 3] +findIndex([1, 2, NaN, 3, 4], isNaN); // => 2 +``` +Available entry points for methods / constructors, as above examples, and namespaces: for example, `core-js/es6/array` (`core-js/library/es6/array`) contains all [ES6 `Array` features](#ecmascript-6-array), `core-js/es6` (`core-js/library/es6`) contains all ES6 features. + +##### Caveats when using CommonJS API: + +* `modules` path is internal API, does not inject all required dependencies and can be changed in minor or patch releases. Use it only for a custom build and / or if you know what are you doing. +* `core-js` is extremely modular and uses a lot of very tiny modules, because of that for usage in browsers bundle up `core-js` instead of usage loader for each file, otherwise, you will have hundreds of requests. + +#### CommonJS and prototype methods without global namespace pollution +In the `library` version, we can't pollute prototypes of native constructors. Because of that, prototype methods transformed to static methods like in examples above. `babel` `runtime` transformer also can't transform them. But with transpilers we can use one more trick - [bind operator and virtual methods](https://github.com/zenparsing/es-function-bind). Special for that, available `/virtual/` entry points. Example: +```js +import fill from 'core-js/library/fn/array/virtual/fill'; +import findIndex from 'core-js/library/fn/array/virtual/find-index'; + +Array(10)::fill(0).map((a, b) => b * b)::findIndex(it => it && !(it % 8)); // => 4 + +// or + +import {fill, findIndex} from 'core-js/library/fn/array/virtual'; + +Array(10)::fill(0).map((a, b) => b * b)::findIndex(it => it && !(it % 8)); // => 4 + +``` + +### Custom build (from the command-line) +``` +npm i core-js && cd node_modules/core-js && npm i +npm run grunt build:core.dict,es6 -- --blacklist=es6.promise,es6.math --library=on --path=custom uglify +``` +Where `core.dict` and `es6` are modules (namespaces) names, which will be added to the build, `es6.promise` and `es6.math` are modules (namespaces) names, which will be excluded from the build, `--library=on` is flag for build without global namespace pollution and `custom` is target file name. + +Available namespaces: for example, `es6.array` contains [ES6 `Array` features](#ecmascript-6-array), `es6` contains all modules whose names start with `es6`. + +### Custom build (from external scripts) + +[`core-js-builder`](https://www.npmjs.com/package/core-js-builder) package exports a function that takes the same parameters as the `build` target from the previous section. This will conditionally include or exclude certain parts of `core-js`: + +```js +require('core-js-builder')({ + modules: ['es6', 'core.dict'], // modules / namespaces + blacklist: ['es6.reflect'], // blacklist of modules / namespaces, by default - empty list + library: false, // flag for build without global namespace pollution, by default - false + umd: true // use UMD wrapper for export `core` object, by default - true +}).then(code => { + // ... +}).catch(error => { + // ... +}); +``` +## Supported engines +**Tested in:** +- Chrome 26+ +- Firefox 4+ +- Safari 5+ +- Opera 12+ +- Internet Explorer 6+ (sure, IE8- with ES3 limitations) +- Edge +- Android Browser 2.3+ +- iOS Safari 5.1+ +- PhantomJS 1.9 / 2.1 +- NodeJS 0.8+ + +...and it doesn't mean `core-js` will not work in other engines, they just have not been tested. + +## Features: +[*CommonJS entry points:*](#commonjs) +``` +core-js(/library) <- all features +core-js(/library)/shim <- only polyfills +``` +### ECMAScript 5 +All features moved to the [`es6` namespace](#ecmascript-6), here just a list of features: +```js +Object + .create(proto | null, descriptors?) -> object + .getPrototypeOf(object) -> proto | null + .defineProperty(target, key, desc) -> target, cap for ie8- + .defineProperties(target, descriptors) -> target, cap for ie8- + .getOwnPropertyDescriptor(object, key) -> desc + .getOwnPropertyNames(object) -> array + .keys(object) -> array + .seal(object) -> object, cap for ie8- + .freeze(object) -> object, cap for ie8- + .preventExtensions(object) -> object, cap for ie8- + .isSealed(object) -> bool, cap for ie8- + .isFrozen(object) -> bool, cap for ie8- + .isExtensible(object) -> bool, cap for ie8- +Array + .isArray(var) -> bool + #slice(start?, end?) -> array, fix for ie7- + #join(string = ',') -> string, fix for ie7- + #indexOf(var, from?) -> int + #lastIndexOf(var, from?) -> int + #every(fn(val, index, @), that) -> bool + #some(fn(val, index, @), that) -> bool + #forEach(fn(val, index, @), that) -> void + #map(fn(val, index, @), that) -> array + #filter(fn(val, index, @), that) -> array + #reduce(fn(memo, val, index, @), memo?) -> var + #reduceRight(fn(memo, val, index, @), memo?) -> var + #sort(fn?) -> @, fixes for some engines +Function + #bind(object, ...args) -> boundFn(...args) +String + #split(separator, limit) -> array + #trim() -> str +RegExp + #toString() -> str +Number + #toFixed(digits) -> string + #toPrecision(precision) -> string +parseInt(str, radix) -> int +parseFloat(str) -> num +Date + .now() -> int + #toISOString() -> string + #toJSON() -> string +``` +[*CommonJS entry points:*](#commonjs) +``` +core-js(/library)/es5 +``` + +### ECMAScript 6 +[*CommonJS entry points:*](#commonjs) +``` +core-js(/library)/es6 +``` +#### ECMAScript 6: Object +Modules [`es6.object.assign`](https://github.com/zloirock/core-js/blob/v2.3.0/modules/es6.object.assign.js), [`es6.object.is`](https://github.com/zloirock/core-js/blob/v2.3.0/modules/es6.object.is.js), [`es6.object.set-prototype-of`](https://github.com/zloirock/core-js/blob/v2.3.0/modules/es6.object.set-prototype-of.js) and [`es6.object.to-string`](https://github.com/zloirock/core-js/blob/v2.3.0/modules/es6.object.to-string.js). + +In ES6 most `Object` static methods should work with primitives. Modules [`es6.object.freeze`](https://github.com/zloirock/core-js/blob/v2.3.0/modules/es6.object.freeze.js), [`es6.object.seal`](https://github.com/zloirock/core-js/blob/v2.3.0/modules/es6.object.seal.js), [`es6.object.prevent-extensions`](https://github.com/zloirock/core-js/blob/v2.3.0/modules/es6.object.prevent-extensions.js), [`es6.object.is-frozen`](https://github.com/zloirock/core-js/blob/v2.3.0/modules/es6.object.is-frozen.js), [`es6.object.is-sealed`](https://github.com/zloirock/core-js/blob/v2.3.0/modules/es6.object.is-sealed.js), [`es6.object.is-extensible`](https://github.com/zloirock/core-js/blob/v2.3.0/modules/es6.object.is-extensible.js), [`es6.object.get-own-property-descriptor`](https://github.com/zloirock/core-js/blob/v2.3.0/modules/es6.object.get-own-property-descriptor.js), [`es6.object.get-prototype-of`](https://github.com/zloirock/core-js/blob/v2.3.0/modules/es6.object.get-prototype-of.js), [`es6.object.keys`](https://github.com/zloirock/core-js/blob/v2.3.0/modules/es6.object.keys.js) and [`es6.object.get-own-property-names`](https://github.com/zloirock/core-js/blob/v2.3.0/modules/es6.object.get-own-property-names.js). + +Just ES5 features: [`es6.object.create`](https://github.com/zloirock/core-js/blob/v2.3.0/modules/es6.object.create.js), [`es6.object.define-property`](https://github.com/zloirock/core-js/blob/v2.3.0/modules/es6.object.define-property.js) and [`es6.object.define-properties`](https://github.com/zloirock/core-js/blob/v2.3.0/modules/es6.object.es6.object.define-properties.js). +```js +Object + .assign(target, ...src) -> target + .is(a, b) -> bool + .setPrototypeOf(target, proto | null) -> target (required __proto__ - IE11+) + .create(object | null, descriptors?) -> object + .getPrototypeOf(var) -> object | null + .defineProperty(object, key, desc) -> target + .defineProperties(object, descriptors) -> target + .getOwnPropertyDescriptor(var, key) -> desc | undefined + .keys(var) -> array + .getOwnPropertyNames(var) -> array + .freeze(var) -> var + .seal(var) -> var + .preventExtensions(var) -> var + .isFrozen(var) -> bool + .isSealed(var) -> bool + .isExtensible(var) -> bool + #toString() -> string, ES6 fix: @@toStringTag support +``` +[*CommonJS entry points:*](#commonjs) +``` +core-js(/library)/es6/object +core-js(/library)/fn/object/assign +core-js(/library)/fn/object/is +core-js(/library)/fn/object/set-prototype-of +core-js(/library)/fn/object/get-prototype-of +core-js(/library)/fn/object/create +core-js(/library)/fn/object/define-property +core-js(/library)/fn/object/define-properties +core-js(/library)/fn/object/get-own-property-descriptor +core-js(/library)/fn/object/keys +core-js(/library)/fn/object/get-own-property-names +core-js(/library)/fn/object/freeze +core-js(/library)/fn/object/seal +core-js(/library)/fn/object/prevent-extensions +core-js(/library)/fn/object/is-frozen +core-js(/library)/fn/object/is-sealed +core-js(/library)/fn/object/is-extensible +core-js/fn/object/to-string +``` +[*Examples*](http://goo.gl/ywdwPz): +```js +var foo = {q: 1, w: 2} + , bar = {e: 3, r: 4} + , baz = {t: 5, y: 6}; +Object.assign(foo, bar, baz); // => foo = {q: 1, w: 2, e: 3, r: 4, t: 5, y: 6} + +Object.is(NaN, NaN); // => true +Object.is(0, -0); // => false +Object.is(42, 42); // => true +Object.is(42, '42'); // => false + +function Parent(){} +function Child(){} +Object.setPrototypeOf(Child.prototype, Parent.prototype); +new Child instanceof Child; // => true +new Child instanceof Parent; // => true + +var O = {}; +O[Symbol.toStringTag] = 'Foo'; +'' + O; // => '[object Foo]' + +Object.keys('qwe'); // => ['0', '1', '2'] +Object.getPrototypeOf('qwe') === String.prototype; // => true +``` +#### ECMAScript 6: Function +Modules [`es6.function.name`](https://github.com/zloirock/core-js/blob/v2.3.0/modules/es6.function.name.js), [`es6.function.has-instance`](https://github.com/zloirock/core-js/blob/v2.3.0/modules/es6.function.has-instance.js). Just ES5: [`es6.function.bind`](https://github.com/zloirock/core-js/blob/v2.3.0/modules/es6.function.bind.js). +```js +Function + #bind(object, ...args) -> boundFn(...args) + #name -> string (IE9+) + #@@hasInstance(var) -> bool +``` +[*CommonJS entry points:*](#commonjs) +``` +core-js/es6/function +core-js/fn/function/name +core-js/fn/function/has-instance +core-js/fn/function/bind +core-js/fn/function/virtual/bind +``` +[*Example*](http://goo.gl/zqu3Wp): +```js +(function foo(){}).name // => 'foo' + +console.log.bind(console, 42)(43); // => 42 43 +``` +#### ECMAScript 6: Array +Modules [`es6.array.from`](https://github.com/zloirock/core-js/blob/v2.3.0/modules/es6.array.from.js), [`es6.array.of`](https://github.com/zloirock/core-js/blob/v2.3.0/modules/es6.array.of.js), [`es6.array.copy-within`](https://github.com/zloirock/core-js/blob/v2.3.0/modules/es6.array.copy-within.js), [`es6.array.fill`](https://github.com/zloirock/core-js/blob/v2.3.0/modules/es6.array.fill.js), [`es6.array.find`](https://github.com/zloirock/core-js/blob/v2.3.0/modules/es6.array.find.js), [`es6.array.find-index`](https://github.com/zloirock/core-js/blob/v2.3.0/modules/es6.array.find-index.js), [`es6.array.iterator`](https://github.com/zloirock/core-js/blob/v2.3.0/modules/es6.array.iterator.js). ES5 features with fixes: [`es6.array.is-array`](https://github.com/zloirock/core-js/blob/v2.3.0/modules/es6.array.is-array.js), [`es6.array.slice`](https://github.com/zloirock/core-js/blob/v2.3.0/modules/es6.array.slice.js), [`es6.array.join`](https://github.com/zloirock/core-js/blob/v2.3.0/modules/es6.array.join.js), [`es6.array.index-of`](https://github.com/zloirock/core-js/blob/v2.3.0/modules/es6.array.index-of.js), [`es6.array.last-index-of`](https://github.com/zloirock/core-js/blob/v2.3.0/modules/es6.array.last-index-of.js), [`es6.array.every`](https://github.com/zloirock/core-js/blob/v2.3.0/modules/es6.array.every.js), [`es6.array.some`](https://github.com/zloirock/core-js/blob/v2.3.0/modules/es6.array.some.js), [`es6.array.for-each`](https://github.com/zloirock/core-js/blob/v2.3.0/modules/es6.array.for-each.js), [`es6.array.map`](https://github.com/zloirock/core-js/blob/v2.3.0/modules/es6.array.map.js), [`es6.array.filter`](https://github.com/zloirock/core-js/blob/v2.3.0/modules/es6.array.filter.js), [`es6.array.reduce`](https://github.com/zloirock/core-js/blob/v2.3.0/modules/es6.array.reduce.js), [`es6.array.reduce-right`](https://github.com/zloirock/core-js/blob/v2.3.0/modules/es6.array.reduce-right.js), [`es6.array.sort`](https://github.com/zloirock/core-js/blob/v2.3.0/modules/es6.array.sort.js). +```js +Array + .from(iterable | array-like, mapFn(val, index)?, that) -> array + .of(...args) -> array + .isArray(var) -> bool + #copyWithin(target = 0, start = 0, end = @length) -> @ + #fill(val, start = 0, end = @length) -> @ + #find(fn(val, index, @), that) -> val + #findIndex(fn(val, index, @), that) -> index | -1 + #values() -> iterator + #keys() -> iterator + #entries() -> iterator + #join(string = ',') -> string, fix for ie7- + #slice(start?, end?) -> array, fix for ie7- + #indexOf(var, from?) -> index | -1 + #lastIndexOf(var, from?) -> index | -1 + #every(fn(val, index, @), that) -> bool + #some(fn(val, index, @), that) -> bool + #forEach(fn(val, index, @), that) -> void + #map(fn(val, index, @), that) -> array + #filter(fn(val, index, @), that) -> array + #reduce(fn(memo, val, index, @), memo?) -> var + #reduceRight(fn(memo, val, index, @), memo?) -> var + #sort(fn?) -> @, invalid arguments fix + #@@iterator() -> iterator (values) + #@@unscopables -> object (cap) +Arguments + #@@iterator() -> iterator (values, available only in core-js methods) +``` +[*CommonJS entry points:*](#commonjs) +``` +core-js(/library)/es6/array +core-js(/library)/fn/array/from +core-js(/library)/fn/array/of +core-js(/library)/fn/array/is-array +core-js(/library)/fn/array/iterator +core-js(/library)/fn/array/copy-within +core-js(/library)/fn/array/fill +core-js(/library)/fn/array/find +core-js(/library)/fn/array/find-index +core-js(/library)/fn/array/values +core-js(/library)/fn/array/keys +core-js(/library)/fn/array/entries +core-js(/library)/fn/array/slice +core-js(/library)/fn/array/join +core-js(/library)/fn/array/index-of +core-js(/library)/fn/array/last-index-of +core-js(/library)/fn/array/every +core-js(/library)/fn/array/some +core-js(/library)/fn/array/for-each +core-js(/library)/fn/array/map +core-js(/library)/fn/array/filter +core-js(/library)/fn/array/reduce +core-js(/library)/fn/array/reduce-right +core-js(/library)/fn/array/sort +core-js(/library)/fn/array/virtual/iterator +core-js(/library)/fn/array/virtual/copy-within +core-js(/library)/fn/array/virtual/fill +core-js(/library)/fn/array/virtual/find +core-js(/library)/fn/array/virtual/find-index +core-js(/library)/fn/array/virtual/values +core-js(/library)/fn/array/virtual/keys +core-js(/library)/fn/array/virtual/entries +core-js(/library)/fn/array/virtual/slice +core-js(/library)/fn/array/virtual/join +core-js(/library)/fn/array/virtual/index-of +core-js(/library)/fn/array/virtual/last-index-of +core-js(/library)/fn/array/virtual/every +core-js(/library)/fn/array/virtual/some +core-js(/library)/fn/array/virtual/for-each +core-js(/library)/fn/array/virtual/map +core-js(/library)/fn/array/virtual/filter +core-js(/library)/fn/array/virtual/reduce +core-js(/library)/fn/array/virtual/reduce-right +core-js(/library)/fn/array/virtual/sort +``` +[*Examples*](http://goo.gl/oaUFUf): +```js +Array.from(new Set([1, 2, 3, 2, 1])); // => [1, 2, 3] +Array.from({0: 1, 1: 2, 2: 3, length: 3}); // => [1, 2, 3] +Array.from('123', Number); // => [1, 2, 3] +Array.from('123', function(it){ + return it * it; +}); // => [1, 4, 9] + +Array.of(1); // => [1] +Array.of(1, 2, 3); // => [1, 2, 3] + +var array = ['a', 'b', 'c']; + +for(var val of array)console.log(val); // => 'a', 'b', 'c' +for(var val of array.values())console.log(val); // => 'a', 'b', 'c' +for(var key of array.keys())console.log(key); // => 0, 1, 2 +for(var [key, val] of array.entries()){ + console.log(key); // => 0, 1, 2 + console.log(val); // => 'a', 'b', 'c' +} + +function isOdd(val){ + return val % 2; +} +[4, 8, 15, 16, 23, 42].find(isOdd); // => 15 +[4, 8, 15, 16, 23, 42].findIndex(isOdd); // => 2 +[4, 8, 15, 16, 23, 42].find(isNaN); // => undefined +[4, 8, 15, 16, 23, 42].findIndex(isNaN); // => -1 + +Array(5).fill(42); // => [42, 42, 42, 42, 42] + +[1, 2, 3, 4, 5].copyWithin(0, 3); // => [4, 5, 3, 4, 5] +``` +#### ECMAScript 6: String +Modules [`es6.string.from-code-point`](https://github.com/zloirock/core-js/blob/v2.3.0/modules/es6.string.from-code-point.js), [`es6.string.raw`](https://github.com/zloirock/core-js/blob/v2.3.0/modules/es6.string.raw.js), [`es6.string.iterator`](https://github.com/zloirock/core-js/blob/v2.3.0/modules/es6.string.iterator.js), [`es6.string.code-point-at`](https://github.com/zloirock/core-js/blob/v2.3.0/modules/es6.string.code-point-at.js), [`es6.string.ends-with`](https://github.com/zloirock/core-js/blob/v2.3.0/modules/es6.string.ends-with.js), [`es6.string.includes`](https://github.com/zloirock/core-js/blob/v2.3.0/modules/es6.string.includes.js), [`es6.string.repeat`](https://github.com/zloirock/core-js/blob/v2.3.0/modules/es6.string.repeat.js), [`es6.string.starts-with`](https://github.com/zloirock/core-js/blob/v2.3.0/modules/es6.string.starts-with.js) and [`es6.string.trim`](https://github.com/zloirock/core-js/blob/v2.3.0/modules/es6.string.trim.js). + +Annex B HTML methods. Ugly, but it's also the part of the spec. Modules [`es6.string.anchor`](https://github.com/zloirock/core-js/blob/v2.3.0/modules/es6.string.anchor.js), [`es6.string.big`](https://github.com/zloirock/core-js/blob/v2.3.0/modules/es6.string.big.js), [`es6.string.blink`](https://github.com/zloirock/core-js/blob/v2.3.0/modules/es6.string.blink.js), [`es6.string.bold`](https://github.com/zloirock/core-js/blob/v2.3.0/modules/es6.string.bold.js), [`es6.string.fixed`](https://github.com/zloirock/core-js/blob/v2.3.0/modules/es6.string.fixed.js), [`es6.string.fontcolor`](https://github.com/zloirock/core-js/blob/v2.3.0/modules/es6.string.fontcolor.js), [`es6.string.fontsize`](https://github.com/zloirock/core-js/blob/v2.3.0/modules/es6.string.fontsize.js), [`es6.string.italics`](https://github.com/zloirock/core-js/blob/v2.3.0/modules/es6.string.italics.js), [`es6.string.link`](https://github.com/zloirock/core-js/blob/v2.3.0/modules/es6.string.link.js), [`es6.string.small`](https://github.com/zloirock/core-js/blob/v2.3.0/modules/es6.string.small.js), [`es6.string.strike`](https://github.com/zloirock/core-js/blob/v2.3.0/modules/es6.string.strike.js), [`es6.string.sub`](https://github.com/zloirock/core-js/blob/v2.3.0/modules/es6.string.sub.js) and [`es6.string.sup`](https://github.com/zloirock/core-js/blob/v2.3.0/modules/es6.string.sup.js). +```js +String + .fromCodePoint(...codePoints) -> str + .raw({raw}, ...substitutions) -> str + #includes(str, from?) -> bool + #startsWith(str, from?) -> bool + #endsWith(str, from?) -> bool + #repeat(num) -> str + #codePointAt(pos) -> uint + #trim() -> str, ES6 fix + #anchor(name) -> str + #big() -> str + #blink() -> str + #bold() -> str + #fixed() -> str + #fontcolor(color) -> str + #fontsize(size) -> str + #italics() -> str + #link(url) -> str + #small() -> str + #strike() -> str + #sub() -> str + #sup() -> str + #@@iterator() -> iterator (code points) +``` +[*CommonJS entry points:*](#commonjs) +``` +core-js(/library)/es6/string +core-js(/library)/fn/string/from-code-point +core-js(/library)/fn/string/raw +core-js(/library)/fn/string/includes +core-js(/library)/fn/string/starts-with +core-js(/library)/fn/string/ends-with +core-js(/library)/fn/string/repeat +core-js(/library)/fn/string/code-point-at +core-js(/library)/fn/string/trim +core-js(/library)/fn/string/anchor +core-js(/library)/fn/string/big +core-js(/library)/fn/string/blink +core-js(/library)/fn/string/bold +core-js(/library)/fn/string/fixed +core-js(/library)/fn/string/fontcolor +core-js(/library)/fn/string/fontsize +core-js(/library)/fn/string/italics +core-js(/library)/fn/string/link +core-js(/library)/fn/string/small +core-js(/library)/fn/string/strike +core-js(/library)/fn/string/sub +core-js(/library)/fn/string/sup +core-js(/library)/fn/string/iterator +core-js(/library)/fn/string/virtual/includes +core-js(/library)/fn/string/virtual/starts-with +core-js(/library)/fn/string/virtual/ends-with +core-js(/library)/fn/string/virtual/repeat +core-js(/library)/fn/string/virtual/code-point-at +core-js(/library)/fn/string/virtual/trim +core-js(/library)/fn/string/virtual/anchor +core-js(/library)/fn/string/virtual/big +core-js(/library)/fn/string/virtual/blink +core-js(/library)/fn/string/virtual/bold +core-js(/library)/fn/string/virtual/fixed +core-js(/library)/fn/string/virtual/fontcolor +core-js(/library)/fn/string/virtual/fontsize +core-js(/library)/fn/string/virtual/italics +core-js(/library)/fn/string/virtual/link +core-js(/library)/fn/string/virtual/small +core-js(/library)/fn/string/virtual/strike +core-js(/library)/fn/string/virtual/sub +core-js(/library)/fn/string/virtual/sup +core-js(/library)/fn/string/virtual/iterator +``` +[*Examples*](http://goo.gl/3UaQ93): +```js +for(var val of 'a𠮷b'){ + console.log(val); // => 'a', '𠮷', 'b' +} + +'foobarbaz'.includes('bar'); // => true +'foobarbaz'.includes('bar', 4); // => false +'foobarbaz'.startsWith('foo'); // => true +'foobarbaz'.startsWith('bar', 3); // => true +'foobarbaz'.endsWith('baz'); // => true +'foobarbaz'.endsWith('bar', 6); // => true + +'string'.repeat(3); // => 'stringstringstring' + +'𠮷'.codePointAt(0); // => 134071 +String.fromCodePoint(97, 134071, 98); // => 'a𠮷b' + +var name = 'Bob'; +String.raw`Hi\n${name}!`; // => 'Hi\\nBob!' (ES6 template string syntax) +String.raw({raw: 'test'}, 0, 1, 2); // => 't0e1s2t' + +'foo'.bold(); // => 'foo' +'bar'.anchor('a"b'); // => 'bar' +'baz'.link('http://example.com'); // => 'baz' +``` +#### ECMAScript 6: RegExp +Modules [`es6.regexp.constructor`](https://github.com/zloirock/core-js/blob/v2.3.0/modules/es6.regexp.constructor.js) and [`es6.regexp.flags`](https://github.com/zloirock/core-js/blob/v2.3.0/modules/es6.regexp.flags.js). + +Support well-known [symbols](#ecmascript-6-symbol) `@@match`, `@@replace`, `@@search` and `@@split`, modules [`es6.regexp.match`](https://github.com/zloirock/core-js/blob/v2.3.0/modules/es6.regexp.match.js), [`es6.regexp.replace`](https://github.com/zloirock/core-js/blob/v2.3.0/modules/es6.regexp.replace.js), [`es6.regexp.search`](https://github.com/zloirock/core-js/blob/v2.3.0/modules/es6.regexp.search.js) and [`es6.regexp.split`](https://github.com/zloirock/core-js/blob/v2.3.0/modules/es6.regexp.split.js). +``` +[new] RegExp(pattern, flags?) -> regexp, ES6 fix: can alter flags (IE9+) + #flags -> str (IE9+) + #toString() -> str, ES6 fixes + #@@match(str) -> array | null + #@@replace(str, replacer) -> string + #@@search(str) -> index + #@@split(str, limit) -> array +String + #match(tpl) -> var, ES6 fix for support @@match + #replace(tpl, replacer) -> var, ES6 fix for support @@replace + #search(tpl) -> var, ES6 fix for support @@search + #split(tpl, limit) -> var, ES6 fix for support @@split, some fixes for old engines +``` +[*CommonJS entry points:*](#commonjs) +``` +core-js/es6/regexp +core-js/fn/regexp/constructor +core-js(/library)/fn/regexp/flags +core-js/fn/regexp/to-string +core-js/fn/regexp/match +core-js/fn/regexp/replace +core-js/fn/regexp/search +core-js/fn/regexp/split +``` +[*Examples*](http://goo.gl/PiJxBD): +```js +RegExp(/./g, 'm'); // => /./m + +/foo/.flags; // => '' +/foo/gim.flags; // => 'gim' + +'foo'.match({[Symbol.match]: _ => 1}); // => 1 +'foo'.replace({[Symbol.replace]: _ => 2}); // => 2 +'foo'.search({[Symbol.search]: _ => 3}); // => 3 +'foo'.split({[Symbol.split]: _ => 4}); // => 4 + +RegExp.prototype.toString.call({source: 'foo', flags: 'bar'}); // => '/foo/bar' +``` +#### ECMAScript 6: Number +Module [`es6.number.constructor`](https://github.com/zloirock/core-js/blob/v2.3.0/modules/es6.number.constructor.js). `Number` constructor support binary and octal literals, [*example*](http://goo.gl/jRd6b3): +```js +Number('0b1010101'); // => 85 +Number('0o7654321'); // => 2054353 +``` +Modules [`es6.number.epsilon`](https://github.com/zloirock/core-js/blob/v2.3.0/modules/es6.number.epsilon.js), [`es6.number.is-finite`](https://github.com/zloirock/core-js/blob/v2.3.0/modules/es6.number.is-finite.js), [`es6.number.is-integer`](https://github.com/zloirock/core-js/blob/v2.3.0/modules/es6.number.is-integer.js), [`es6.number.is-nan`](https://github.com/zloirock/core-js/blob/v2.3.0/modules/es6.number.is-nan.js), [`es6.number.is-safe-integer`](https://github.com/zloirock/core-js/blob/v2.3.0/modules/es6.number.is-safe-integer.js), [`es6.number.max-safe-integer`](https://github.com/zloirock/core-js/blob/v2.3.0/modules/es6.number.max-safe-integer.js), [`es6.number.min-safe-integer`](https://github.com/zloirock/core-js/blob/v2.3.0/modules/es6.number.min-safe-integer.js), [`es6.number.parse-float`](https://github.com/zloirock/core-js/blob/v2.3.0/modules/es6.number.parse-float.js), [`es6.number.parse-int`](https://github.com/zloirock/core-js/blob/v2.3.0/modules/es6.number.parse-int.js), [`es6.number.to-fixed`](https://github.com/zloirock/core-js/blob/v2.3.0/modules/es6.number.to-fixed.js), [`es6.number.to-precision`](https://github.com/zloirock/core-js/blob/v2.3.0/modules/es6.number.to-precision.js), [`es6.parse-int`](https://github.com/zloirock/core-js/blob/v2.3.0/modules/es6.parse-int.js), [`es6.parse-float`](https://github.com/zloirock/core-js/blob/v2.3.0/modules/es6.parse-float.js). +```js +[new] Number(var) -> number | number object + .isFinite(num) -> bool + .isNaN(num) -> bool + .isInteger(num) -> bool + .isSafeInteger(num) -> bool + .parseFloat(str) -> num + .parseInt(str) -> int + .EPSILON -> num + .MAX_SAFE_INTEGER -> int + .MIN_SAFE_INTEGER -> int + #toFixed(digits) -> string, fixes + #toPrecision(precision) -> string, fixes +parseFloat(str) -> num, fixes +parseInt(str) -> int, fixes +``` +[*CommonJS entry points:*](#commonjs) +``` +core-js(/library)/es6/number +core-js/es6/number/constructor +core-js(/library)/fn/number/is-finite +core-js(/library)/fn/number/is-nan +core-js(/library)/fn/number/is-integer +core-js(/library)/fn/number/is-safe-integer +core-js(/library)/fn/number/parse-float +core-js(/library)/fn/number/parse-int +core-js(/library)/fn/number/epsilon +core-js(/library)/fn/number/max-safe-integer +core-js(/library)/fn/number/min-safe-integer +core-js(/library)/fn/number/to-fixed +core-js(/library)/fn/number/to-precision +core-js(/library)/fn/parse-float +core-js(/library)/fn/parse-int +``` +#### ECMAScript 6: Math +Modules [`es6.math.acosh`](https://github.com/zloirock/core-js/blob/v2.3.0/modules/es6.math.acosh.js), [`es6.math.asinh`](https://github.com/zloirock/core-js/blob/v2.3.0/modules/es6.math.asinh.js), [`es6.math.atanh`](https://github.com/zloirock/core-js/blob/v2.3.0/modules/es6.math.atanh.js), [`es6.math.cbrt`](https://github.com/zloirock/core-js/blob/v2.3.0/modules/es6.math.cbrt.js), [`es6.math.clz32`](https://github.com/zloirock/core-js/blob/v2.3.0/modules/es6.math.clz32.js), [`es6.math.cosh`](https://github.com/zloirock/core-js/blob/v2.3.0/modules/es6.math.cosh.js), [`es6.math.expm1`](https://github.com/zloirock/core-js/blob/v2.3.0/modules/es6.math.expm1.js), [`es6.math.fround`](https://github.com/zloirock/core-js/blob/v2.3.0/modules/es6.math.fround.js), [`es6.math.hypot`](https://github.com/zloirock/core-js/blob/v2.3.0/modules/es6.math.hypot.js), [`es6.math.imul`](https://github.com/zloirock/core-js/blob/v2.3.0/modules/es6.math.imul.js), [`es6.math.log10`](https://github.com/zloirock/core-js/blob/v2.3.0/modules/es6.math.log10.js), [`es6.math.log1p`](https://github.com/zloirock/core-js/blob/v2.3.0/modules/es6.math.log1p.js), [`es6.math.log2`](https://github.com/zloirock/core-js/blob/v2.3.0/modules/es6.math.log2.js), [`es6.math.sign`](https://github.com/zloirock/core-js/blob/v2.3.0/modules/es6.math.sign.js), [`es6.math.sinh`](https://github.com/zloirock/core-js/blob/v2.3.0/modules/es6.math.sinh.js), [`es6.math.tanh`](https://github.com/zloirock/core-js/blob/v2.3.0/modules/es6.math.tanh.js), [`es6.math.trunc`](https://github.com/zloirock/core-js/blob/v2.3.0/modules/es6.math.trunc.js). +```js +Math + .acosh(num) -> num + .asinh(num) -> num + .atanh(num) -> num + .cbrt(num) -> num + .clz32(num) -> uint + .cosh(num) -> num + .expm1(num) -> num + .fround(num) -> num + .hypot(...args) -> num + .imul(num, num) -> int + .log1p(num) -> num + .log10(num) -> num + .log2(num) -> num + .sign(num) -> 1 | -1 | 0 | -0 | NaN + .sinh(num) -> num + .tanh(num) -> num + .trunc(num) -> num +``` +[*CommonJS entry points:*](#commonjs) +``` +core-js(/library)/es6/math +core-js(/library)/fn/math/acosh +core-js(/library)/fn/math/asinh +core-js(/library)/fn/math/atanh +core-js(/library)/fn/math/cbrt +core-js(/library)/fn/math/clz32 +core-js(/library)/fn/math/cosh +core-js(/library)/fn/math/expm1 +core-js(/library)/fn/math/fround +core-js(/library)/fn/math/hypot +core-js(/library)/fn/math/imul +core-js(/library)/fn/math/log1p +core-js(/library)/fn/math/log10 +core-js(/library)/fn/math/log2 +core-js(/library)/fn/math/sign +core-js(/library)/fn/math/sinh +core-js(/library)/fn/math/tanh +core-js(/library)/fn/math/trunc +``` +#### ECMAScript 6: Date +Modules [`es6.date.to-string`](https://github.com/zloirock/core-js/blob/v2.3.0/modules/es6.date.to-string.js), ES5 features with fixes: [`es6.date.now`](https://github.com/zloirock/core-js/blob/v2.3.0/modules/es6.date.now.js), [`es6.date.to-iso-string`](https://github.com/zloirock/core-js/blob/v2.3.0/modules/es6.date.to-iso-string.js), [`es6.date.to-json`](https://github.com/zloirock/core-js/blob/v2.3.0/modules/es6.date.to-json.js) and [`es6.date.to-primitive`](https://github.com/zloirock/core-js/blob/v2.3.0/modules/es6.date.to-primitive.js). +```js +Date + .now() -> int + #toISOString() -> string + #toJSON() -> string + #toString() -> string + #@@toPrimitive(hint) -> primitive +``` +[*CommonJS entry points:*](#commonjs) +``` +core-js/es6/date +core-js/fn/date/to-string +core-js(/library)/fn/date/now +core-js(/library)/fn/date/to-iso-string +core-js(/library)/fn/date/to-json +core-js(/library)/fn/date/to-primitive +``` +[*Example*](http://goo.gl/haeHLR): +```js +new Date(NaN).toString(); // => 'Invalid Date' +``` + +#### ECMAScript 6: Promise +Module [`es6.promise`](https://github.com/zloirock/core-js/blob/v2.3.0/modules/es6.promise.js). +```js +new Promise(executor(resolve(var), reject(var))) -> promise + #then(resolved(var), rejected(var)) -> promise + #catch(rejected(var)) -> promise + .resolve(promise | var) -> promise + .reject(var) -> promise + .all(iterable) -> promise + .race(iterable) -> promise +``` +[*CommonJS entry points:*](#commonjs) +``` +core-js(/library)/es6/promise +core-js(/library)/fn/promise +``` +Basic [*example*](http://goo.gl/vGrtUC): +```js +function sleepRandom(time){ + return new Promise(function(resolve, reject){ + setTimeout(resolve, time * 1e3, 0 | Math.random() * 1e3); + }); +} + +console.log('Run'); // => Run +sleepRandom(5).then(function(result){ + console.log(result); // => 869, after 5 sec. + return sleepRandom(10); +}).then(function(result){ + console.log(result); // => 202, after 10 sec. +}).then(function(){ + console.log('immediately after'); // => immediately after + throw Error('Irror!'); +}).then(function(){ + console.log('will not be displayed'); +}).catch(x => console.log(x)); // => => Error: Irror! +``` +`Promise.resolve` and `Promise.reject` [*example*](http://goo.gl/vr8TN3): +```js +Promise.resolve(42).then(x => console.log(x)); // => 42 +Promise.reject(42).catch(x => console.log(x)); // => 42 + +Promise.resolve($.getJSON('/data.json')); // => ES6 promise +``` +`Promise.all` [*example*](http://goo.gl/RdoDBZ): +```js +Promise.all([ + 'foo', + sleepRandom(5), + sleepRandom(15), + sleepRandom(10) // after 15 sec: +]).then(x => console.log(x)); // => ['foo', 956, 85, 382] +``` +`Promise.race` [*example*](http://goo.gl/L8ovkJ): +```js +function timeLimit(promise, time){ + return Promise.race([promise, new Promise(function(resolve, reject){ + setTimeout(reject, time * 1e3, Error('Await > ' + time + ' sec')); + })]); +} + +timeLimit(sleepRandom(5), 10).then(x => console.log(x)); // => 853, after 5 sec. +timeLimit(sleepRandom(15), 10).catch(x => console.log(x)); // Error: Await > 10 sec +``` +ECMAScript 7 [async functions](https://tc39.github.io/ecmascript-asyncawait) [example](http://goo.gl/wnQS4j): +```js +var delay = time => new Promise(resolve => setTimeout(resolve, time)) + +async function sleepRandom(time){ + await delay(time * 1e3); + return 0 | Math.random() * 1e3; +}; +async function sleepError(time, msg){ + await delay(time * 1e3); + throw Error(msg); +}; + +(async () => { + try { + console.log('Run'); // => Run + console.log(await sleepRandom(5)); // => 936, after 5 sec. + var [a, b, c] = await Promise.all([ + sleepRandom(5), + sleepRandom(15), + sleepRandom(10) + ]); + console.log(a, b, c); // => 210 445 71, after 15 sec. + await sleepError(5, 'Irror!'); + console.log('Will not be displayed'); + } catch(e){ + console.log(e); // => Error: 'Irror!', after 5 sec. + } +})(); +``` + +##### Unhandled rejection tracking + +In Node.js, like in native implementation, available events [`unhandledRejection`](https://nodejs.org/api/process.html#process_event_unhandledrejection) and [`rejectionHandled`](https://nodejs.org/api/process.html#process_event_rejectionhandled): +```js +process.on('unhandledRejection', (reason, promise) => console.log('unhandled', reason, promise)); +process.on('rejectionHandled', (promise) => console.log('handled', promise)); + +var p = Promise.reject(42); +// unhandled 42 [object Promise] + +setTimeout(() => p.catch(_ => _), 1e3); +// handled [object Promise] +``` +In a browser on rejection, by default, you will see notify in the console, or you can add a custom handler and a handler on handling unhandled, [*example*](http://goo.gl/Wozskl): +```js +window.onunhandledrejection = e => console.log('unhandled', e.reason, e.promise); +window.onrejectionhandled = e => console.log('handled', e.reason, e.promise); + +var p = Promise.reject(42); +// unhandled 42 [object Promise] + +setTimeout(() => p.catch(_ => _), 1e3); +// handled 42 [object Promise] +``` + +#### ECMAScript 6: Symbol +Module [`es6.symbol`](https://github.com/zloirock/core-js/blob/v2.3.0/modules/es6.symbol.js). +```js +Symbol(description?) -> symbol + .hasInstance -> @@hasInstance + .isConcatSpreadable -> @@isConcatSpreadable + .iterator -> @@iterator + .match -> @@match + .replace -> @@replace + .search -> @@search + .species -> @@species + .split -> @@split + .toPrimitive -> @@toPrimitive + .toStringTag -> @@toStringTag + .unscopables -> @@unscopables + .for(key) -> symbol + .keyFor(symbol) -> key + .useSimple() -> void + .useSetter() -> void +Object + .getOwnPropertySymbols(object) -> array +``` +Also wrapped some methods for correct work with `Symbol` polyfill. +```js +Object + .create(proto | null, descriptors?) -> object + .defineProperty(target, key, desc) -> target + .defineProperties(target, descriptors) -> target + .getOwnPropertyDescriptor(var, key) -> desc | undefined + .getOwnPropertyNames(var) -> array + #propertyIsEnumerable(key) -> bool +JSON + .stringify(target, replacer?, space?) -> string | undefined +``` +[*CommonJS entry points:*](#commonjs) +``` +core-js(/library)/es6/symbol +core-js(/library)/fn/symbol +core-js(/library)/fn/symbol/has-instance +core-js(/library)/fn/symbol/is-concat-spreadable +core-js(/library)/fn/symbol/iterator +core-js(/library)/fn/symbol/match +core-js(/library)/fn/symbol/replace +core-js(/library)/fn/symbol/search +core-js(/library)/fn/symbol/species +core-js(/library)/fn/symbol/split +core-js(/library)/fn/symbol/to-primitive +core-js(/library)/fn/symbol/to-string-tag +core-js(/library)/fn/symbol/unscopables +core-js(/library)/fn/symbol/for +core-js(/library)/fn/symbol/key-for +``` +[*Basic example*](http://goo.gl/BbvWFc): +```js +var Person = (function(){ + var NAME = Symbol('name'); + function Person(name){ + this[NAME] = name; + } + Person.prototype.getName = function(){ + return this[NAME]; + }; + return Person; +})(); + +var person = new Person('Vasya'); +console.log(person.getName()); // => 'Vasya' +console.log(person['name']); // => undefined +console.log(person[Symbol('name')]); // => undefined, symbols are uniq +for(var key in person)console.log(key); // => only 'getName', symbols are not enumerable +``` +`Symbol.for` & `Symbol.keyFor` [*example*](http://goo.gl/0pdJjX): +```js +var symbol = Symbol.for('key'); +symbol === Symbol.for('key'); // true +Symbol.keyFor(symbol); // 'key' +``` +[*Example*](http://goo.gl/mKVOQJ) with methods for getting own object keys: +```js +var O = {a: 1}; +Object.defineProperty(O, 'b', {value: 2}); +O[Symbol('c')] = 3; +Object.keys(O); // => ['a'] +Object.getOwnPropertyNames(O); // => ['a', 'b'] +Object.getOwnPropertySymbols(O); // => [Symbol(c)] +Reflect.ownKeys(O); // => ['a', 'b', Symbol(c)] +``` +##### Caveats when using `Symbol` polyfill: + +* We can't add new primitive type, `Symbol` returns object. +* `Symbol.for` and `Symbol.keyFor` can't be shimmed cross-realm. +* By default, to hide the keys, `Symbol` polyfill defines setter in `Object.prototype`. For this reason, uncontrolled creation of symbols can cause memory leak and the `in` operator is not working correctly with `Symbol` polyfill: `Symbol() in {} // => true`. + +You can disable defining setters in `Object.prototype`. [Example](http://goo.gl/N5UD7J): +```js +Symbol.useSimple(); +var s1 = Symbol('s1') + , o1 = {}; +o1[s1] = true; +for(var key in o1)console.log(key); // => 'Symbol(s1)_t.qamkg9f3q', w/o native Symbol + +Symbol.useSetter(); +var s2 = Symbol('s2') + , o2 = {}; +o2[s2] = true; +for(var key in o2)console.log(key); // nothing +``` +* Currently, `core-js` not adds setters to `Object.prototype` for well-known symbols for correct work something like `Symbol.iterator in foo`. It can cause problems with their enumerability. +* Some problems possible with environment exotic objects (for example, IE `localStorage`). + +#### ECMAScript 6: Collections +`core-js` uses native collections in most case, just fixes methods / constructor, if it's required, and in old environment uses fast polyfill (O(1) lookup). +#### Map +Module [`es6.map`](https://github.com/zloirock/core-js/blob/v2.3.0/modules/es6.map.js). +```js +new Map(iterable (entries) ?) -> map + #clear() -> void + #delete(key) -> bool + #forEach(fn(val, key, @), that) -> void + #get(key) -> val + #has(key) -> bool + #set(key, val) -> @ + #size -> uint + #values() -> iterator + #keys() -> iterator + #entries() -> iterator + #@@iterator() -> iterator (entries) +``` +[*CommonJS entry points:*](#commonjs) +``` +core-js(/library)/es6/map +core-js(/library)/fn/map +``` +[*Examples*](http://goo.gl/GWR7NI): +```js +var a = [1]; + +var map = new Map([['a', 1], [42, 2]]); +map.set(a, 3).set(true, 4); + +console.log(map.size); // => 4 +console.log(map.has(a)); // => true +console.log(map.has([1])); // => false +console.log(map.get(a)); // => 3 +map.forEach(function(val, key){ + console.log(val); // => 1, 2, 3, 4 + console.log(key); // => 'a', 42, [1], true +}); +map.delete(a); +console.log(map.size); // => 3 +console.log(map.get(a)); // => undefined +console.log(Array.from(map)); // => [['a', 1], [42, 2], [true, 4]] + +var map = new Map([['a', 1], ['b', 2], ['c', 3]]); + +for(var [key, val] of map){ + console.log(key); // => 'a', 'b', 'c' + console.log(val); // => 1, 2, 3 +} +for(var val of map.values())console.log(val); // => 1, 2, 3 +for(var key of map.keys())console.log(key); // => 'a', 'b', 'c' +for(var [key, val] of map.entries()){ + console.log(key); // => 'a', 'b', 'c' + console.log(val); // => 1, 2, 3 +} +``` +#### Set +Module [`es6.set`](https://github.com/zloirock/core-js/blob/v2.3.0/modules/es6.set.js). +```js +new Set(iterable?) -> set + #add(key) -> @ + #clear() -> void + #delete(key) -> bool + #forEach(fn(el, el, @), that) -> void + #has(key) -> bool + #size -> uint + #values() -> iterator + #keys() -> iterator + #entries() -> iterator + #@@iterator() -> iterator (values) +``` +[*CommonJS entry points:*](#commonjs) +``` +core-js(/library)/es6/set +core-js(/library)/fn/set +``` +[*Examples*](http://goo.gl/bmhLwg): +```js +var set = new Set(['a', 'b', 'a', 'c']); +set.add('d').add('b').add('e'); +console.log(set.size); // => 5 +console.log(set.has('b')); // => true +set.forEach(function(it){ + console.log(it); // => 'a', 'b', 'c', 'd', 'e' +}); +set.delete('b'); +console.log(set.size); // => 4 +console.log(set.has('b')); // => false +console.log(Array.from(set)); // => ['a', 'c', 'd', 'e'] + +var set = new Set([1, 2, 3, 2, 1]); + +for(var val of set)console.log(val); // => 1, 2, 3 +for(var val of set.values())console.log(val); // => 1, 2, 3 +for(var key of set.keys())console.log(key); // => 1, 2, 3 +for(var [key, val] of set.entries()){ + console.log(key); // => 1, 2, 3 + console.log(val); // => 1, 2, 3 +} +``` +#### WeakMap +Module [`es6.weak-map`](https://github.com/zloirock/core-js/blob/v2.3.0/modules/es6.weak-map.js). +```js +new WeakMap(iterable (entries) ?) -> weakmap + #delete(key) -> bool + #get(key) -> val + #has(key) -> bool + #set(key, val) -> @ +``` +[*CommonJS entry points:*](#commonjs) +``` +core-js(/library)/es6/weak-map +core-js(/library)/fn/weak-map +``` +[*Examples*](http://goo.gl/SILXyw): +```js +var a = [1] + , b = [2] + , c = [3]; + +var wmap = new WeakMap([[a, 1], [b, 2]]); +wmap.set(c, 3).set(b, 4); +console.log(wmap.has(a)); // => true +console.log(wmap.has([1])); // => false +console.log(wmap.get(a)); // => 1 +wmap.delete(a); +console.log(wmap.get(a)); // => undefined + +// Private properties store: +var Person = (function(){ + var names = new WeakMap; + function Person(name){ + names.set(this, name); + } + Person.prototype.getName = function(){ + return names.get(this); + }; + return Person; +})(); + +var person = new Person('Vasya'); +console.log(person.getName()); // => 'Vasya' +for(var key in person)console.log(key); // => only 'getName' +``` +#### WeakSet +Module [`es6.weak-set`](https://github.com/zloirock/core-js/blob/v2.3.0/modules/es6.weak-set.js). +```js +new WeakSet(iterable?) -> weakset + #add(key) -> @ + #delete(key) -> bool + #has(key) -> bool +``` +[*CommonJS entry points:*](#commonjs) +``` +core-js(/library)/es6/weak-set +core-js(/library)/fn/weak-set +``` +[*Examples*](http://goo.gl/TdFbEx): +```js +var a = [1] + , b = [2] + , c = [3]; + +var wset = new WeakSet([a, b, a]); +wset.add(c).add(b).add(c); +console.log(wset.has(b)); // => true +console.log(wset.has([2])); // => false +wset.delete(b); +console.log(wset.has(b)); // => false +``` +##### Caveats when using collections polyfill: + +* Weak-collections polyfill stores values as hidden properties of keys. It works correct and not leak in most cases. However, it is desirable to store a collection longer than its keys. + +#### ECMAScript 6: Typed Arrays +Implementations and fixes `ArrayBuffer`, `DataView`, typed arrays constructors, static and prototype methods. Typed Arrays work only in environments with support descriptors (IE9+), `ArrayBuffer` and `DataView` should work anywhere. + +Modules [`es6.typed.array-buffer`](https://github.com/zloirock/core-js/blob/v2.3.0/modules/es6.typed.array-buffer.js), [`es6.typed.data-view`](https://github.com/zloirock/core-js/blob/v2.3.0/modules/es6.typed.data-view.js), [`es6.typed.int8-array`](https://github.com/zloirock/core-js/blob/v2.3.0/modules/es6.typed.int8-array.js), [`es6.typed.uint8-array`](https://github.com/zloirock/core-js/blob/v2.3.0/modules/es6.typed.uint8-array.js), [`es6.typed.uint8-clamped-array`](https://github.com/zloirock/core-js/blob/v2.3.0/modules/es6.typed.uint8-clamped-array.js), [`es6.typed.int16-array`](https://github.com/zloirock/core-js/blob/v2.3.0/modules/es6.typed.int16-array.js), [`es6.typed.uint16-array`](https://github.com/zloirock/core-js/blob/v2.3.0/modules/es6.typed.uint16-array.js), [`es6.typed.int32-array`](https://github.com/zloirock/core-js/blob/v2.3.0/modules/es6.typed.int32-array.js), [`es6.typed.uint32-array`](https://github.com/zloirock/core-js/blob/v2.3.0/modules/es6.typed.uint32-array.js), [`es6.typed.float32-array`](https://github.com/zloirock/core-js/blob/v2.3.0/modules/es6.typed.float32-array.js) and [`es6.typed.float64-array`](https://github.com/zloirock/core-js/blob/v2.3.0/modules/es6.typed.float64-array.js). +```js +new ArrayBuffer(length) -> buffer + .isView(var) -> bool + #slice(start = 0, end = @length) -> buffer + #byteLength -> uint + +new DataView(buffer, byteOffset = 0, byteLength = buffer.byteLength - byteOffset) -> view + #getInt8(offset) -> int8 + #getUint8(offset) -> uint8 + #getInt16(offset, littleEndian = false) -> int16 + #getUint16(offset, littleEndian = false) -> uint16 + #getInt32(offset, littleEndian = false) -> int32 + #getUint32(offset, littleEndian = false) -> uint32 + #getFloat32(offset, littleEndian = false) -> float32 + #getFloat64(offset, littleEndian = false) -> float64 + #setInt8(offset, value) -> void + #setUint8(offset, value) -> void + #setInt16(offset, value, littleEndian = false) -> void + #setUint16(offset, value, littleEndian = false) -> void + #setInt32(offset, value, littleEndian = false) -> void + #setUint32(offset, value, littleEndian = false) -> void + #setFloat32(offset, value, littleEndian = false) -> void + #setFloat64(offset, value, littleEndian = false) -> void + #buffer -> buffer + #byteLength -> uint + #byteOffset -> uint + +{ + Int8Array, + Uint8Array, + Uint8ClampedArray, + Int16Array, + Uint16Array, + Int32Array, + Uint32Array, + Float32Array, + Float64Array +} + new %TypedArray%(length) -> typed + new %TypedArray%(typed) -> typed + new %TypedArray%(arrayLike) -> typed + new %TypedArray%(iterable) -> typed + new %TypedArray%(buffer, byteOffset = 0, length = (buffer.byteLength - byteOffset) / @BYTES_PER_ELEMENT) -> typed + .BYTES_PER_ELEMENT -> uint + .from(arrayLike | iterable, mapFn(val, index)?, that) -> typed + .of(...args) -> typed + #BYTES_PER_ELEMENT -> uint + #copyWithin(target = 0, start = 0, end = @length) -> @ + #every(fn(val, index, @), that) -> bool + #fill(val, start = 0, end = @length) -> @ + #filter(fn(val, index, @), that) -> typed + #find(fn(val, index, @), that) -> val + #findIndex(fn(val, index, @), that) -> index + #forEach(fn(val, index, @), that) -> void + #indexOf(var, from?) -> int + #includes(var, from?) -> bool + #join(string = ',') -> string + #lastIndexOf(var, from?) -> int + #map(fn(val, index, @), that) -> typed + #reduce(fn(memo, val, index, @), memo?) -> var + #reduceRight(fn(memo, val, index, @), memo?) -> var + #reverse() -> @ + #set(arrayLike, offset = 0) -> void + #slice(start = 0, end = @length) -> typed + #some(fn(val, index, @), that) -> bool + #sort(fn(a, b)?) -> @ + #subarray(start = 0, end = @length) -> typed + #toString() -> string + #toLocaleString() -> string + #values() -> iterator + #keys() -> iterator + #entries() -> iterator + #@@iterator() -> iterator (values) + #buffer -> buffer + #byteLength -> uint + #byteOffset -> uint + #length -> uint +``` +[*CommonJS entry points:*](#commonjs) +``` +core-js(/library)/es6/typed +core-js(/library)/fn/typed +core-js(/library)/fn/typed/array-buffer +core-js(/library)/fn/typed/data-view +core-js(/library)/fn/typed/int8-array +core-js(/library)/fn/typed/uint8-array +core-js(/library)/fn/typed/uint8-clamped-array +core-js(/library)/fn/typed/int16-array +core-js(/library)/fn/typed/uint16-array +core-js(/library)/fn/typed/int32-array +core-js(/library)/fn/typed/uint32-array +core-js(/library)/fn/typed/float32-array +core-js(/library)/fn/typed/float64-array +``` +[*Examples*](http://goo.gl/yla75z): +```js +new Int32Array(4); // => [0, 0, 0, 0] +new Uint8ClampedArray([1, 2, 3, 666]); // => [1, 2, 3, 255] +new Float32Array(new Set([1, 2, 3, 2, 1])); // => [1, 2, 3] + +var buffer = new ArrayBuffer(8); +var view = new DataView(buffer); +view.setFloat64(0, 123.456, true); +new Uint8Array(buffer.slice(4)); // => [47, 221, 94, 64] + +Int8Array.of(1, 1.5, 5.7, 745); // => [1, 1, 5, -23] +Uint8Array.from([1, 1.5, 5.7, 745]); // => [1, 1, 5, 233] + +var typed = new Uint8Array([1, 2, 3]); + +var a = typed.slice(1); // => [2, 3] +typed.buffer === a.buffer; // => false +var b = typed.subarray(1); // => [2, 3] +typed.buffer === b.buffer; // => true + +typed.filter(it => it % 2); // => [1, 3] +typed.map(it => it * 1.5); // => [1, 3, 4] + +for(var val of typed)console.log(val); // => 1, 2, 3 +for(var val of typed.values())console.log(val); // => 1, 2, 3 +for(var key of typed.keys())console.log(key); // => 0, 1, 2 +for(var [key, val] of typed.entries()){ + console.log(key); // => 0, 1, 2 + console.log(val); // => 1, 2, 3 +} +``` +##### Caveats when using typed arrays: + +* Typed Arrays polyfills works completely how should work by the spec, but because of internal use getter / setters on each instance, is slow and consumes significant memory. However, typed arrays polyfills required mainly for IE9 (and for `Uint8ClampedArray` in IE10 and early IE11), all modern engines have native typed arrays and requires only constructors fixes and methods. +* The current version hasn't special entry points for methods, they can be added only with constructors. It can be added in the future. +* In the `library` version we can't pollute native prototypes, so prototype methods available as constructors static. + +#### ECMAScript 6: Reflect +Modules [`es6.reflect.apply`](https://github.com/zloirock/core-js/blob/v2.3.0/modules/es6.reflect.apply.js), [`es6.reflect.construct`](https://github.com/zloirock/core-js/blob/v2.3.0/modules/es6.reflect.construct.js), [`es6.reflect.define-property`](https://github.com/zloirock/core-js/blob/v2.3.0/modules/es6.reflect.define-property.js), [`es6.reflect.delete-property`](https://github.com/zloirock/core-js/blob/v2.3.0/modules/es6.reflect.delete-property.js), [`es6.reflect.enumerate`](https://github.com/zloirock/core-js/blob/v2.3.0/modules/es6.reflect.enumerate.js), [`es6.reflect.get`](https://github.com/zloirock/core-js/blob/v2.3.0/modules/es6.reflect.get.js), [`es6.reflect.get-own-property-descriptor`](https://github.com/zloirock/core-js/blob/v2.3.0/modules/es6.reflect.get-own-property-descriptor.js), [`es6.reflect.get-prototype-of`](https://github.com/zloirock/core-js/blob/v2.3.0/modules/es6.reflect.get-prototype-of.js), [`es6.reflect.has`](https://github.com/zloirock/core-js/blob/v2.3.0/modules/es6.reflect.has.js), [`es6.reflect.is-extensible`](https://github.com/zloirock/core-js/blob/v2.3.0/modules/es6.reflect.is-extensible.js), [`es6.reflect.own-keys`](https://github.com/zloirock/core-js/blob/v2.3.0/modules/es6.reflect.own-keys.js), [`es6.reflect.prevent-extensions`](https://github.com/zloirock/core-js/blob/v2.3.0/modules/es6.reflect.prevent-extensions.js), [`es6.reflect.set`](https://github.com/zloirock/core-js/blob/v2.3.0/modules/es6.reflect.set.js), [`es6.reflect.set-prototype-of`](https://github.com/zloirock/core-js/blob/v2.3.0/modules/es6.reflect.set-prototype-of.js). +```js +Reflect + .apply(target, thisArgument, argumentsList) -> var + .construct(target, argumentsList, newTarget?) -> object + .defineProperty(target, propertyKey, attributes) -> bool + .deleteProperty(target, propertyKey) -> bool + .enumerate(target) -> iterator (removed from the spec and will be removed from core-js@3) + .get(target, propertyKey, receiver?) -> var + .getOwnPropertyDescriptor(target, propertyKey) -> desc + .getPrototypeOf(target) -> object | null + .has(target, propertyKey) -> bool + .isExtensible(target) -> bool + .ownKeys(target) -> array + .preventExtensions(target) -> bool + .set(target, propertyKey, V, receiver?) -> bool + .setPrototypeOf(target, proto) -> bool (required __proto__ - IE11+) +``` +[*CommonJS entry points:*](#commonjs) +``` +core-js(/library)/es6/reflect +core-js(/library)/fn/reflect +core-js(/library)/fn/reflect/apply +core-js(/library)/fn/reflect/construct +core-js(/library)/fn/reflect/define-property +core-js(/library)/fn/reflect/delete-property +core-js(/library)/fn/reflect/enumerate (deprecated and will be removed from the next major release) +core-js(/library)/fn/reflect/get +core-js(/library)/fn/reflect/get-own-property-descriptor +core-js(/library)/fn/reflect/get-prototype-of +core-js(/library)/fn/reflect/has +core-js(/library)/fn/reflect/is-extensible +core-js(/library)/fn/reflect/own-keys +core-js(/library)/fn/reflect/prevent-extensions +core-js(/library)/fn/reflect/set +core-js(/library)/fn/reflect/set-prototype-of +``` +[*Examples*](http://goo.gl/gVT0cH): +```js +var O = {a: 1}; +Object.defineProperty(O, 'b', {value: 2}); +O[Symbol('c')] = 3; +Reflect.ownKeys(O); // => ['a', 'b', Symbol(c)] + +function C(a, b){ + this.c = a + b; +} + +var instance = Reflect.construct(C, [20, 22]); +instance.c; // => 42 +``` +### ECMAScript 7+ proposals +[The TC39 process.](https://tc39.github.io/process-document/) + +[*CommonJS entry points:*](#commonjs) +``` +core-js(/library)/es7 +core-js(/library)/es7/array +core-js(/library)/es7/string +core-js(/library)/es7/map +core-js(/library)/es7/set +core-js(/library)/es7/math +core-js(/library)/es7/system +core-js(/library)/es7/error +core-js(/library)/es7/reflect +``` +`core-js/stage/4` entry point contains only stage 4 proposals, `core-js/stage/3` - stage 3 and stage 4, etc. +##### Stage 4: +* `{Array, %TypedArray%}#includes` [proposal](https://github.com/tc39/Array.prototype.includes) - module [`es7.array.includes`](https://github.com/zloirock/core-js/blob/v2.3.0/modules/es7.array.includes.js), `%TypedArray%` version in modules from [this section](#ecmascript-6-typed-arrays). +* `Object.values`, `Object.entries` [proposal](https://github.com/tc39/proposal-object-values-entries) - modules [`es7.object.values`](https://github.com/zloirock/core-js/blob/v2.3.0/modules/es7.object.values.js), [`es7.object.entries`](https://github.com/zloirock/core-js/blob/v2.3.0/modules/es7.object.entries.js) +* `Object#__(define|lookup)[GS]etter__`, [annex B ES2017](https://github.com/tc39/ecma262/pull/381), but we haven't special namespace for that - modules [`es7.object.define-setter`](https://github.com/zloirock/core-js/blob/v2.3.0/modules/es7.object.define-setter.js), [`es7.object.define-getter`](https://github.com/zloirock/core-js/blob/v2.3.0/modules/es7.object.define-getter.js), [`es7.object.lookup-setter`](https://github.com/zloirock/core-js/blob/v2.3.0/modules/es7.object.lookup-setter.js) and [`es7.object.lookup-getter`](https://github.com/zloirock/core-js/blob/v2.3.0/modules/es7.object.lookup-getter.js). + +[*CommonJS entry points:*](#commonjs) +```js +core-js(/library)/stage/4 +core-js(/library)/fn/array/includes +core-js(/library)/fn/object/values +core-js(/library)/fn/object/entries +core-js(/library)/fn/object/define-getter +core-js(/library)/fn/object/define-setter +core-js(/library)/fn/object/lookup-getter +core-js(/library)/fn/object/lookup-setter +``` + +##### Stage 3: +* `Object.getOwnPropertyDescriptors` [proposal](https://github.com/tc39/proposal-object-getownpropertydescriptors) - module [`es7.object.get-own-property-descriptors`](https://github.com/zloirock/core-js/blob/v2.3.0/modules/es7.object.get-own-property-descriptors.js) +* `String#padStart`, `String#padEnd` [proposal](https://github.com/tc39/proposal-string-pad-start-end) - modules [`es7.string.pad-left`](https://github.com/zloirock/core-js/blob/v2.3.0/modules/es7.string.pad-left.js), [`es7.string.pad-right`](https://github.com/zloirock/core-js/blob/v2.3.0/modules/es7.string.pad-right.js) + +[*CommonJS entry points:*](#commonjs) +```js +core-js(/library)/stage/3 +core-js(/library)/fn/object/get-own-property-descriptors +core-js(/library)/fn/string/pad-start +core-js(/library)/fn/string/pad-end +core-js(/library)/fn/string/virtual/pad-start +core-js(/library)/fn/string/virtual/pad-end +``` + +##### Stage 2: +* `System.global` [proposal](https://github.com/tc39/proposal-global) - module [`es7.system.global`](https://github.com/zloirock/core-js/blob/v2.3.0/modules/es7.system.global.js) +* `Symbol.asyncIterator` for [async iteration proposal](https://github.com/tc39/proposal-async-iteration) - module [`es7.symbol.async-iterator`](https://github.com/zloirock/core-js/blob/v2.3.0/modules/es7.symbol.async-iterator.js) + +[*CommonJS entry points:*](#commonjs) +```js +core-js(/library)/stage/2 +core-js(/library)/fn/system/global +core-js(/library)/fn/symbol/async-iterator +``` + +##### Stage 1: +* `String#trimLeft`, `String#trimRight` / `String#trimStart`, `String#trimEnd` [proposal](https://github.com/sebmarkbage/ecmascript-string-left-right-trim) - modules [`es7.string.trim-left`](https://github.com/zloirock/core-js/blob/v2.3.0/modules/es7.string.trim-right.js), [`es7.string.trim-right`](https://github.com/zloirock/core-js/blob/v2.3.0/modules/es7.string.trim-right.js) +* `String#matchAll` [proposal](https://github.com/tc39/String.prototype.matchAll) - module [`es7.string.match-all`](https://github.com/zloirock/core-js/blob/v2.3.0/modules/es7.string.match-all.js) +* `Symbol.observable` for [observables proposal](https://github.com/zenparsing/es-observable) - module [`es7.symbol.observable`](https://github.com/zloirock/core-js/blob/v2.3.0/modules/es7.symbol.observable.js) + +[*CommonJS entry points:*](#commonjs) +```js +core-js(/library)/stage/1 +core-js(/library)/fn/string/trim-start +core-js(/library)/fn/string/trim-end +core-js(/library)/fn/string/trim-left +core-js(/library)/fn/string/trim-right +core-js(/library)/fn/string/match-all +core-js(/library)/fn/string/virtual/trim-start +core-js(/library)/fn/string/virtual/trim-end +core-js(/library)/fn/string/virtual/trim-left +core-js(/library)/fn/string/virtual/trim-right +core-js(/library)/fn/string/virtual/match-all +core-js(/library)/fn/symbol/observable +``` + +##### Stage 0: +* `String#at` [proposal](https://github.com/mathiasbynens/String.prototype.at) - module [`es7.string.at`](https://github.com/zloirock/core-js/blob/v2.3.0/modules/es7.string.at.js) +* `Map#toJSON`, `Set#toJSON` [proposal](https://github.com/DavidBruant/Map-Set.prototype.toJSON) - modules [`es7.map.to-json`](https://github.com/zloirock/core-js/blob/v2.3.0/modules/es7.map.to-json.js), [`es7.set.to-json`](https://github.com/zloirock/core-js/blob/v2.3.0/modules/es7.set.to-json.js) (rejected and will be removed from `core-js@3`) +* `Error.isError` [proposal](https://github.com/ljharb/proposal-is-error) - module [`es7.error.is-error`](https://github.com/zloirock/core-js/blob/v2.3.0/modules/es7.error.is-error.js) (withdrawn and will be removed from `core-js@3`) +* `Math.{iaddh, isubh, imulh, umulh}` [proposal](https://gist.github.com/BrendanEich/4294d5c212a6d2254703) - modules [`es7.math.iaddh`](https://github.com/zloirock/core-js/blob/v2.3.0/modules/es7.math.iaddh.js), [`es7.math.isubh`](https://github.com/zloirock/core-js/blob/v2.3.0/modules/es7.math.isubh.js), [`es7.math.imulh`](https://github.com/zloirock/core-js/blob/v2.3.0/modules/es7.math.imulh.js) and [`es7.math.umulh`](https://github.com/zloirock/core-js/blob/v2.3.0/modules/es7.math.umulh.js) +* `glogal.asap`, [TC39 discussion](https://github.com/rwaldron/tc39-notes/blob/master/es6/2014-09/sept-25.md#510-globalasap-for-enqueuing-a-microtask), module [`es7.asap`](https://github.com/zloirock/core-js/blob/v2.3.0/modules/es7.asap.js) + +[*CommonJS entry points:*](#commonjs) +```js +core-js(/library)/stage/0 +core-js(/library)/fn/string/at +core-js(/library)/fn/string/virtual/at +core-js(/library)/fn/map +core-js(/library)/fn/set +core-js(/library)/fn/error/is-error +core-js(/library)/fn/math/iaddh +core-js(/library)/fn/math/isubh +core-js(/library)/fn/math/imulh +core-js(/library)/fn/math/umulh +core-js(/library)/fn/asap +``` + +##### Pre-stage 0 proposals: +* `Reflect` metadata [proposal](https://github.com/jonathandturner/decorators/blob/master/specs/metadata.md) - modules [`es7.reflect.define-metadata`](https://github.com/zloirock/core-js/blob/v2.3.0/modules/es7.reflect.define-metadata.js), [`es7.reflect.delete-metadata`](https://github.com/zloirock/core-js/blob/v2.3.0/modules/es7.reflect.delete-metadata.js), [`es7.reflect.get-metadata`](https://github.com/zloirock/core-js/blob/v2.3.0/modules/es7.reflect.get-metadata.js), [`es7.reflect.get-metadata-keys`](https://github.com/zloirock/core-js/blob/v2.3.0/modules/es7.reflect.get-metadata-keys.js), [`es7.reflect.get-own-metadata`](https://github.com/zloirock/core-js/blob/v2.3.0/modules/es7.reflect.get-own-metadata.js), [`es7.reflect.get-own-metadata-keys`](https://github.com/zloirock/core-js/blob/v2.3.0/modules/es7.reflect.get-own-metadata-keys.js), [`es7.reflect.has-metadata`](https://github.com/zloirock/core-js/blob/v2.3.0/modules/es7.reflect.has-metadata.js), [`es7.reflect.has-own-metadata`](https://github.com/zloirock/core-js/blob/v2.3.0/modules/es7.reflect.has-own-metadata.js) and [`es7.reflect.metadata`](https://github.com/zloirock/core-js/blob/v2.3.0/modules/es7.reflect.metadata.js). + +[*CommonJS entry points:*](#commonjs) +```js +core-js(/library)/stage/pre +core-js(/library)/fn/reflect/define-metadata +core-js(/library)/fn/reflect/delete-metadata +core-js(/library)/fn/reflect/get-metadata +core-js(/library)/fn/reflect/get-metadata-keys +core-js(/library)/fn/reflect/get-own-metadata +core-js(/library)/fn/reflect/get-own-metadata-keys +core-js(/library)/fn/reflect/has-metadata +core-js(/library)/fn/reflect/has-own-metadata +core-js(/library)/fn/reflect/metadata +``` + +```js +asap(fn) -> void +Array + #includes(var, from?) -> bool +String + #at(index) -> string + #padStart(length, fillStr = ' ') -> string + #padEnd(length, fillStr = ' ') -> string + #trimLeft() -> string + #trimRight() -> string + #trimStart() -> string + #trimEnd() -> string + #marchAll(regexp) -> iterator +Object + .values(object) -> array + .entries(object) -> array + .getOwnPropertyDescriptors(object) -> object + #__defineSetter__(key, fn) -> void + #__defineGetter__(key, fn) -> void + #__lookupSetter__(key) -> fn | void + #__lookupGetter__(key) -> fn | void +Map + #toJSON() -> array (rejected and will be removed from core-js@3) +Set + #toJSON() -> array (rejected and will be removed from core-js@3) +System + .global -> object +Symbol + .asyncIterator -> @@asyncIterator + .observable -> @@observable +Error + .isError(it) -> bool (withdrawn and will be removed from core-js@3) +Math + .iaddh(lo0, hi0, lo1, hi1) -> int32 + .isubh(lo0, hi0, lo1, hi1) -> int32 + .imulh(a, b) -> int32 + .umulh(a, b) -> uint32 +Reflect + .defineMetadata(metadataKey, metadataValue, target, propertyKey?) -> void + .getMetadata(metadataKey, target, propertyKey?) -> var + .getOwnMetadata(metadataKey, target, propertyKey?) -> var + .hasMetadata(metadataKey, target, propertyKey?) -> bool + .hasOwnMetadata(metadataKey, target, propertyKey?) -> bool + .deleteMetadata(metadataKey, target, propertyKey?) -> bool + .getMetadataKeys(target, propertyKey?) -> array + .getOwnMetadataKeys(target, propertyKey?) -> array + .metadata(metadataKey, metadataValue) -> decorator(target, targetKey?) -> void +``` +[*Examples*](http://goo.gl/DVGima): +```js +asap(() => console.log('called as microtask')); + +[1, 2, 3].includes(2); // => true +[1, 2, 3].includes(4); // => false +[1, 2, 3].includes(2, 2); // => false + +[NaN].indexOf(NaN); // => -1 +[NaN].includes(NaN); // => true +Array(1).indexOf(undefined); // => -1 +Array(1).includes(undefined); // => true + +'a𠮷b'.at(1); // => '𠮷' +'a𠮷b'.at(1).length; // => 2 + +'hello'.padStart(10); // => ' hello' +'hello'.padStart(10, '1234'); // => '12341hello' +'hello'.padEnd(10); // => 'hello ' +'hello'.padEnd(10, '1234'); // => 'hello12341' + +' hello '.trimLeft(); // => 'hello ' +' hello '.trimRight(); // => ' hello' + +for(let [_, d, D] of '1111a2b3cccc'.matchAll(/(\d)(\D)/)){ + console.log(d, D); // => 1 a, 2 b, 3 c +} + +Object.values({a: 1, b: 2, c: 3}); // => [1, 2, 3] +Object.entries({a: 1, b: 2, c: 3}); // => [['a', 1], ['b', 2], ['c', 3]] + +// Shallow object cloning with prototype and descriptors: +var copy = Object.create(Object.getPrototypeOf(O), Object.getOwnPropertyDescriptors(O)); +// Mixin: +Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); + +System.global.Array === Array; // => true + +var O = {}; +Reflect.defineMetadata('foo', 'bar', O); +Reflect.ownKeys(O); // => [] +Reflect.getOwnMetadataKeys(O); // => ['foo'] +Reflect.getOwnMetadata('foo', O); // => 'bar' +``` +### Web standards +[*CommonJS entry points:*](#commonjs) +```js +core-js(/library)/web +``` +#### setTimeout / setInterval +Module [`web.timers`](https://github.com/zloirock/core-js/blob/v2.3.0/modules/web.timers.js). Additional arguments fix for IE9-. +```js +setTimeout(fn(...args), time, ...args) -> id +setInterval(fn(...args), time, ...args) -> id +``` +[*CommonJS entry points:*](#commonjs) +```js +core-js(/library)/web/timers +core-js(/library)/fn/set-timeout +core-js(/library)/fn/set-interval +``` +```js +// Before: +setTimeout(log.bind(null, 42), 1000); +// After: +setTimeout(log, 1000, 42); +``` +#### setImmediate +Module [`web.immediate`](https://github.com/zloirock/core-js/blob/v2.3.0/modules/web.immediate.js). [`setImmediate` proposal](https://developer.mozilla.org/en-US/docs/Web/API/Window.setImmediate) polyfill. +```js +setImmediate(fn(...args), ...args) -> id +clearImmediate(id) -> void +``` +[*CommonJS entry points:*](#commonjs) +```js +core-js(/library)/web/immediate +core-js(/library)/fn/set-immediate +core-js(/library)/fn/clear-immediate +``` +[*Examples*](http://goo.gl/6nXGrx): +```js +setImmediate(function(arg1, arg2){ + console.log(arg1, arg2); // => Message will be displayed with minimum delay +}, 'Message will be displayed', 'with minimum delay'); + +clearImmediate(setImmediate(function(){ + console.log('Message will not be displayed'); +})); +``` +#### Iterable DOM collections +Some DOM collections should have [iterable interface](https://heycam.github.io/webidl/#idl-iterable) or should be [inherited from `Array`](https://heycam.github.io/webidl/#LegacyArrayClass). That mean they should have `keys`, `values`, `entries` and `@@iterator` methods for iteration. So add them. Module [`web.dom.iterable`](https://github.com/zloirock/core-js/blob/v2.3.0/modules/web.dom.iterable.js): +```js +{ + NodeList, + DOMTokenList, + MediaList, + StyleSheetList, + CSSRuleList +} + #values() -> iterator + #keys() -> iterator + #entries() -> iterator + #@@iterator() -> iterator (values) +``` +[*CommonJS entry points:*](#commonjs) +```js +core-js(/library)/web/dom-collections +core-js(/library)/fn/dom-collections/iterator +``` +[*Examples*](http://goo.gl/lfXVFl): +```js +for(var {id} of document.querySelectorAll('*')){ + if(id)console.log(id); +} + +for(var [index, {id}] of document.querySelectorAll('*').entries()){ + if(id)console.log(index, id); +} +``` +### Non-standard +[*CommonJS entry points:*](#commonjs) +```js +core-js(/library)/core +``` +#### Object +Modules [`core.object.is-object`](https://github.com/zloirock/core-js/blob/v2.3.0/modules/core.object.is-object.js), [`core.object.classof`](https://github.com/zloirock/core-js/blob/v2.3.0/modules/core.object.classof.js), [`core.object.define`](https://github.com/zloirock/core-js/blob/v2.3.0/modules/core.object.define.js), [`core.object.make`](https://github.com/zloirock/core-js/blob/v2.3.0/modules/core.object.make.js). +```js +Object + .isObject(var) -> bool + .classof(var) -> string + .define(target, mixin) -> target + .make(proto | null, mixin?) -> object +``` + +[*CommonJS entry points:*](#commonjs) +```js +core-js(/library)/core/object +core-js(/library)/fn/object/is-object +core-js(/library)/fn/object/define +core-js(/library)/fn/object/make +``` +Object classify [*examples*](http://goo.gl/YZQmGo): +```js +Object.isObject({}); // => true +Object.isObject(isNaN); // => true +Object.isObject(null); // => false + +var classof = Object.classof; + +classof(null); // => 'Null' +classof(undefined); // => 'Undefined' +classof(1); // => 'Number' +classof(true); // => 'Boolean' +classof('string'); // => 'String' +classof(Symbol()); // => 'Symbol' + +classof(new Number(1)); // => 'Number' +classof(new Boolean(true)); // => 'Boolean' +classof(new String('string')); // => 'String' + +var fn = function(){} + , list = (function(){return arguments})(1, 2, 3); + +classof({}); // => 'Object' +classof(fn); // => 'Function' +classof([]); // => 'Array' +classof(list); // => 'Arguments' +classof(/./); // => 'RegExp' +classof(new TypeError); // => 'Error' + +classof(new Set); // => 'Set' +classof(new Map); // => 'Map' +classof(new WeakSet); // => 'WeakSet' +classof(new WeakMap); // => 'WeakMap' +classof(new Promise(fn)); // => 'Promise' + +classof([].values()); // => 'Array Iterator' +classof(new Set().values()); // => 'Set Iterator' +classof(new Map().values()); // => 'Map Iterator' + +classof(Math); // => 'Math' +classof(JSON); // => 'JSON' + +function Example(){} +Example.prototype[Symbol.toStringTag] = 'Example'; + +classof(new Example); // => 'Example' +``` +`Object.define` and `Object.make` [*examples*](http://goo.gl/rtpD5Z): +```js +// Before: +Object.defineProperty(target, 'c', { + enumerable: true, + configurable: true, + get: function(){ + return this.a + this.b; + } +}); + +// After: +Object.define(target, { + get c(){ + return this.a + this.b; + } +}); + +// Shallow object cloning with prototype and descriptors: +var copy = Object.make(Object.getPrototypeOf(src), src); + +// Simple inheritance: +function Vector2D(x, y){ + this.x = x; + this.y = y; +} +Object.define(Vector2D.prototype, { + get xy(){ + return Math.hypot(this.x, this.y); + } +}); +function Vector3D(x, y, z){ + Vector2D.apply(this, arguments); + this.z = z; +} +Vector3D.prototype = Object.make(Vector2D.prototype, { + constructor: Vector3D, + get xyz(){ + return Math.hypot(this.x, this.y, this.z); + } +}); + +var vector = new Vector3D(9, 12, 20); +console.log(vector.xy); // => 15 +console.log(vector.xyz); // => 25 +vector.y++; +console.log(vector.xy); // => 15.811388300841896 +console.log(vector.xyz); // => 25.495097567963924 +``` +#### Dict +Module [`core.dict`](https://github.com/zloirock/core-js/blob/v2.3.0/modules/core.dict.js). Based on [TC39 discuss](https://github.com/rwaldron/tc39-notes/blob/master/es6/2012-11/nov-29.md#collection-apis-review) / [strawman](http://wiki.ecmascript.org/doku.php?id=harmony:modules_standard#dictionaries). +```js +[new] Dict(iterable (entries) | object ?) -> dict + .isDict(var) -> bool + .values(object) -> iterator + .keys(object) -> iterator + .entries(object) -> iterator (entries) + .has(object, key) -> bool + .get(object, key) -> val + .set(object, key, value) -> object + .forEach(object, fn(val, key, @), that) -> void + .map(object, fn(val, key, @), that) -> new @ + .mapPairs(object, fn(val, key, @), that) -> new @ + .filter(object, fn(val, key, @), that) -> new @ + .some(object, fn(val, key, @), that) -> bool + .every(object, fn(val, key, @), that) -> bool + .find(object, fn(val, key, @), that) -> val + .findKey(object, fn(val, key, @), that) -> key + .keyOf(object, var) -> key + .includes(object, var) -> bool + .reduce(object, fn(memo, val, key, @), memo?) -> var +``` + +[*CommonJS entry points:*](#commonjs) +```js +core-js(/library)/core/dict +core-js(/library)/fn/dict +``` +`Dict` create object without prototype from iterable or simple object. + +[*Examples*](http://goo.gl/pnp8Vr): +```js +var map = new Map([['a', 1], ['b', 2], ['c', 3]]); + +Dict(); // => {__proto__: null} +Dict({a: 1, b: 2, c: 3}); // => {__proto__: null, a: 1, b: 2, c: 3} +Dict(map); // => {__proto__: null, a: 1, b: 2, c: 3} +Dict([1, 2, 3].entries()); // => {__proto__: null, 0: 1, 1: 2, 2: 3} + +var dict = Dict({a: 42}); +dict instanceof Object; // => false +dict.a; // => 42 +dict.toString; // => undefined +'a' in dict; // => true +'hasOwnProperty' in dict; // => false + +Dict.isDict({}); // => false +Dict.isDict(Dict()); // => true +``` +`Dict.keys`, `Dict.values` and `Dict.entries` returns iterators for objects. + +[*Examples*](http://goo.gl/xAvECH): +```js +var dict = {a: 1, b: 2, c: 3}; + +for(var key of Dict.keys(dict))console.log(key); // => 'a', 'b', 'c' + +for(var val of Dict.values(dict))console.log(val); // => 1, 2, 3 + +for(var [key, val] of Dict.entries(dict)){ + console.log(key); // => 'a', 'b', 'c' + console.log(val); // => 1, 2, 3 +} + +new Map(Dict.entries(dict)); // => Map {a: 1, b: 2, c: 3} +``` +Basic dict operations for objects with prototype [*examples*](http://goo.gl/B28UnG): +```js +'q' in {q: 1}; // => true +'toString' in {}; // => true + +Dict.has({q: 1}, 'q'); // => true +Dict.has({}, 'toString'); // => false + +({q: 1})['q']; // => 1 +({}).toString; // => function toString(){ [native code] } + +Dict.get({q: 1}, 'q'); // => 1 +Dict.get({}, 'toString'); // => undefined + +var O = {}; +O['q'] = 1; +O['q']; // => 1 +O['__proto__'] = {w: 2}; +O['__proto__']; // => {w: 2} +O['w']; // => 2 + +var O = {}; +Dict.set(O, 'q', 1); +O['q']; // => 1 +Dict.set(O, '__proto__', {w: 2}); +O['__proto__']; // => {w: 2} +O['w']; // => undefined +``` +Other methods of `Dict` module are static equialents of `Array.prototype` methods for dictionaries. + +[*Examples*](http://goo.gl/xFi1RH): +```js +var dict = {a: 1, b: 2, c: 3}; + +Dict.forEach(dict, console.log, console); +// => 1, 'a', {a: 1, b: 2, c: 3} +// => 2, 'b', {a: 1, b: 2, c: 3} +// => 3, 'c', {a: 1, b: 2, c: 3} + +Dict.map(dict, function(it){ + return it * it; +}); // => {a: 1, b: 4, c: 9} + +Dict.mapPairs(dict, function(val, key){ + if(key != 'b')return [key + key, val * val]; +}); // => {aa: 1, cc: 9} + +Dict.filter(dict, function(it){ + return it % 2; +}); // => {a: 1, c: 3} + +Dict.some(dict, function(it){ + return it === 2; +}); // => true + +Dict.every(dict, function(it){ + return it === 2; +}); // => false + +Dict.find(dict, function(it){ + return it > 2; +}); // => 3 +Dict.find(dict, function(it){ + return it > 4; +}); // => undefined + +Dict.findKey(dict, function(it){ + return it > 2; +}); // => 'c' +Dict.findKey(dict, function(it){ + return it > 4; +}); // => undefined + +Dict.keyOf(dict, 2); // => 'b' +Dict.keyOf(dict, 4); // => undefined + +Dict.includes(dict, 2); // => true +Dict.includes(dict, 4); // => false + +Dict.reduce(dict, function(memo, it){ + return memo + it; +}); // => 6 +Dict.reduce(dict, function(memo, it){ + return memo + it; +}, ''); // => '123' +``` +#### Partial application +Module [`core.function.part`](https://github.com/zloirock/core-js/blob/v2.3.0/modules/core.function.part.js). +```js +Function + #part(...args | _) -> fn(...args) +``` + +[*CommonJS entry points:*](#commonjs) +```js +core-js/core/function +core-js(/library)/fn/function/part +core-js(/library)/fn/function/virtual/part +core-js(/library)/fn/_ +``` +`Function#part` partial apply function without `this` binding. Uses global variable `_` (`core._` for builds without global namespace pollution) as placeholder and not conflict with `Underscore` / `LoDash`. + +[*Examples*](http://goo.gl/p9ZJ8K): +```js +var fn1 = log.part(1, 2); +fn1(3, 4); // => 1, 2, 3, 4 + +var fn2 = log.part(_, 2, _, 4); +fn2(1, 3); // => 1, 2, 3, 4 + +var fn3 = log.part(1, _, _, 4); +fn3(2, 3); // => 1, 2, 3, 4 + +fn2(1, 3, 5); // => 1, 2, 3, 4, 5 +fn2(1); // => 1, 2, undefined, 4 +``` +#### Number Iterator +Module [`core.number.iterator`](https://github.com/zloirock/core-js/blob/v2.3.0/modules/core.number.iterator.js). +```js +Number + #@@iterator() -> iterator +``` + +[*CommonJS entry points:*](#commonjs) +```js +core-js(/library)/core/number +core-js(/library)/fn/number/iterator +core-js(/library)/fn/number/virtual/iterator +``` +[*Examples*](http://goo.gl/o45pCN): +```js +for(var i of 3)console.log(i); // => 0, 1, 2 + +[...10]; // => [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] + +Array.from(10, Math.random); // => [0.9817775336559862, 0.02720663254149258, ...] + +Array.from(10, function(it){ + return this + it * it; +}, .42); // => [0.42, 1.42, 4.42, 9.42, 16.42, 25.42, 36.42, 49.42, 64.42, 81.42] +``` +#### Escaping strings +Modules [`core.regexp.escape`](https://github.com/zloirock/core-js/blob/v2.3.0/modules/core.regexp.escape.js), [`core.string.escape-html`](https://github.com/zloirock/core-js/blob/v2.3.0/modules/core.string.escape-html.js) and [`core.string.unescape-html`](https://github.com/zloirock/core-js/blob/v2.3.0/modules/core.string.unescape-html.js). +```js +RegExp + .escape(str) -> str +String + #escapeHTML() -> str + #unescapeHTML() -> str +``` +[*CommonJS entry points:*](#commonjs) +```js +core-js(/library)/core/regexp +core-js(/library)/core/string +core-js(/library)/fn/regexp/escape +core-js(/library)/fn/string/escape-html +core-js(/library)/fn/string/unescape-html +core-js(/library)/fn/string/virtual/escape-html +core-js(/library)/fn/string/virtual/unescape-html +``` +[*Examples*](http://goo.gl/6bOvsQ): +```js +RegExp.escape('Hello, []{}()*+?.\\^$|!'); // => 'Hello, \[\]\{\}\(\)\*\+\?\.\\\^\$\|!' + +''.escapeHTML(); // => '<script>doSomething();</script>' +'<script>doSomething();</script>'.unescapeHTML(); // => '' +``` +#### delay +Module [`core.delay`](https://github.com/zloirock/core-js/blob/v2.3.0/modules/core.delay.js). [Promise](#ecmascript-6-promise)-returning delay function, [esdiscuss](https://esdiscuss.org/topic/promise-returning-delay-function). +```js +delay(ms) -> promise +``` +[*CommonJS entry points:*](#commonjs) +```js +core-js(/library)/core/delay +core-js(/library)/fn/delay +``` +[*Examples*](http://goo.gl/lbucba): +```js +delay(1e3).then(() => console.log('after 1 sec')); + +(async () => { + await delay(3e3); + console.log('after 3 sec'); + + while(await delay(3e3))console.log('each 3 sec'); +})(); +``` +#### Helpers for iterators +Modules [`core.is-iterable`](https://github.com/zloirock/core-js/blob/v2.3.0/modules/core.is-iterable.js), [`core.get-iterator`](https://github.com/zloirock/core-js/blob/v2.3.0/modules/core.get-iterator.js), [`core.get-iterator-method`](https://github.com/zloirock/core-js/blob/v2.3.0/modules/core.get-iterator-method.js) - helpers for check iterability / get iterator in the `library` version or, for example, for `arguments` object: +```js +core + .isIterable(var) -> bool + .getIterator(iterable) -> iterator + .getIteratorMethod(var) -> function | undefined +``` +[*CommonJS entry points:*](#commonjs) +```js +core-js(/library)/fn/is-iterable +core-js(/library)/fn/get-iterator +core-js(/library)/fn/get-iterator-method +``` +[*Examples*](http://goo.gl/SXsM6D): +```js +var list = (function(){ + return arguments; +})(1, 2, 3); + +console.log(core.isIterable(list)); // true; + +var iter = core.getIterator(list); +console.log(iter.next().value); // 1 +console.log(iter.next().value); // 2 +console.log(iter.next().value); // 3 +console.log(iter.next().value); // undefined + +core.getIterator({}); // TypeError: [object Object] is not iterable! + +var iterFn = core.getIteratorMethod(list); +console.log(typeof iterFn); // 'function' +var iter = iterFn.call(list); +console.log(iter.next().value); // 1 +console.log(iter.next().value); // 2 +console.log(iter.next().value); // 3 +console.log(iter.next().value); // undefined + +console.log(core.getIteratorMethod({})); // undefined +``` + +## Missing polyfills +- ES5 `JSON` is missing now only in IE7- and never will it be added to `core-js`, if you need it in these old browsers, many implementations are available, for example, [json3](https://github.com/bestiejs/json3). +- ES6 `String#normalize` is not a very useful feature, but this polyfill will be very large. If you need it, you can use [unorm](https://github.com/walling/unorm/). +- ES6 `Proxy` can't be polyfilled, but for Node.js / Chromium with additional flags you can try [harmony-reflect](https://github.com/tvcutsem/harmony-reflect) for adapt old style `Proxy` API to final ES6 version. +- ES6 logic for `@@isConcatSpreadable` and `@@species` (in most places) can be polyfilled without problems, but it will cause a serious slowdown in popular cases in some engines. It will be polyfilled when it will be implemented in modern engines. +- ES7 `SIMD`. `core-js` doesn't add polyfill of this feature because of large size and some other reasons. You can use [this polyfill](https://github.com/tc39/ecmascript_simd/blob/master/src/ecmascript_simd.js). +- `window.fetch` is not a cross-platform feature, in some environments it makes no sense. For this reason, I don't think it should be in `core-js`. Looking at a large number of requests it *may be* added in the future. Now you can use, for example, [this polyfill](https://github.com/github/fetch). +- ECMA-402 `Intl` is missed because of size. You can use [this polyfill](https://github.com/andyearnshaw/Intl.js/). diff --git a/node_modules/core-js/bower.json b/node_modules/core-js/bower.json new file mode 100644 index 0000000..1558e09 --- /dev/null +++ b/node_modules/core-js/bower.json @@ -0,0 +1,47 @@ +{ + "name": "core.js", + "main": "client/core.js", + "version": "2.3.0", + "description": "Standard Library", + "keywords": [ + "ES3", + "ECMAScript 3", + "ES5", + "ECMAScript 5", + "ES6", + "ES2015", + "ECMAScript 6", + "ECMAScript 2015", + "ES7", + "ES2016", + "ECMAScript 7", + "ECMAScript 2016", + "Harmony", + "Strawman", + "Map", + "Set", + "WeakMap", + "WeakSet", + "Promise", + "Symbol", + "TypedArray", + "setImmediate", + "Dict", + "polyfill", + "shim" + ], + "authors": [ + "Denis Pushkarev (http://zloirock.ru/)" + ], + "license": "MIT", + "homepage": "https://github.com/zloirock/core-js", + "repository": { + "type": "git", + "url": "https://github.com/zloirock/core-js.git" + }, + "ignore": [ + "build", + "node_modules", + "tests" + ] +} diff --git a/node_modules/core-js/build/Gruntfile.ls b/node_modules/core-js/build/Gruntfile.ls new file mode 100644 index 0000000..f4b5380 --- /dev/null +++ b/node_modules/core-js/build/Gruntfile.ls @@ -0,0 +1,84 @@ +require! <[./build fs ./config]> +module.exports = (grunt)-> + grunt.loadNpmTasks \grunt-contrib-clean + grunt.loadNpmTasks \grunt-contrib-copy + grunt.loadNpmTasks \grunt-contrib-uglify + grunt.loadNpmTasks \grunt-contrib-watch + grunt.loadNpmTasks \grunt-livescript + grunt.loadNpmTasks \grunt-karma + grunt.initConfig do + pkg: grunt.file.readJSON './package.json' + uglify: build: + files: '<%=grunt.option("path")%>.min.js': '<%=grunt.option("path")%>.js' + options: + mangle: {+sort, +keep_fnames} + compress: {+pure_getters, +keep_fargs, +keep_fnames} + sourceMap: on + banner: config.banner + livescript: src: files: + './tests/helpers.js': './tests/helpers/*' + './tests/tests.js': './tests/tests/*' + './tests/library.js': './tests/library/*' + './tests/es.js': './tests/tests/es*' + './tests/experimental.js': './tests/experimental/*' + './build/index.js': './build/build.ls*' + clean: <[./library]> + copy: lib: files: + * expand: on + cwd: './' + src: <[es5/** es6/** es7/** stage/** web/** core/** fn/** index.js shim.js]> + dest: './library/' + * expand: on + cwd: './' + src: <[modules/*]> + dest: './library/' + filter: \isFile + * expand: on + cwd: './modules/library/' + src: '*' + dest: './library/modules/' + watch: + core: + files: './modules/*' + tasks: \default + tests: + files: './tests/tests/*' + tasks: \livescript + karma: + 'options': + configFile: './tests/karma.conf.js' + browsers: <[PhantomJS]> + singleRun: on + 'default': {} + 'library': files: <[client/library.js tests/helpers.js tests/library.js]>map -> src: it + grunt.registerTask \build (options)-> + done = @async! + build { + modules: (options || 'es5,es6,es7,js,web,core')split \, + blacklist: (grunt.option(\blacklist) || '')split \, + library: grunt.option(\library) in <[yes on true]> + umd: grunt.option(\umd) not in <[no off false]> + } + .then !-> + grunt.option(\path) || grunt.option(\path, './custom') + fs.writeFile grunt.option(\path) + '.js', it, done + .catch !-> + console.error it + process.exit 1 + grunt.registerTask \client -> + grunt.option \library '' + grunt.option \path './client/core' + grunt.task.run <[build:es5,es6,es7,js,web,core uglify]> + grunt.registerTask \library -> + grunt.option \library 'true' + grunt.option \path './client/library' + grunt.task.run <[build:es5,es6,es7,js,web,core uglify]> + grunt.registerTask \shim -> + grunt.option \library '' + grunt.option \path './client/shim' + grunt.task.run <[build:es5,es6,es7,js,web uglify]> + grunt.registerTask \e -> + grunt.option \library ''> + grunt.option \path './client/core' + grunt.task.run <[build:es5,es6,es7,js,web,core,exp uglify]> + grunt.registerTask \default <[clean copy client library shim]> \ No newline at end of file diff --git a/node_modules/core-js/build/build.ls b/node_modules/core-js/build/build.ls new file mode 100644 index 0000000..0cf210d --- /dev/null +++ b/node_modules/core-js/build/build.ls @@ -0,0 +1,62 @@ +require! { + '../library/fn/promise': Promise + './config': {list, experimental, libraryBlacklist, es5SpecialCase, banner} + fs: {readFile, writeFile, unlink} + path: {join} + webpack, temp +} + +module.exports = ({modules = [], blacklist = [], library = no, umd = on})-> + resolve, reject <~! new Promise _ + let @ = modules.reduce ((memo, it)-> memo[it] = on; memo), {} + if @exp => for experimental => @[..] = on + if @es5 => for es5SpecialCase => @[..] = on + for ns of @ + if @[ns] + for name in list + if name.indexOf("#ns.") is 0 and name not in experimental + @[name] = on + + if library => blacklist ++= libraryBlacklist + for ns in blacklist + for name in list + if name is ns or name.indexOf("#ns.") is 0 + @[name] = no + + TARGET = temp.path {suffix: '.js'} + + err, info <~! webpack do + entry: list.filter(~> @[it]).map ~> + if library => join __dirname, '..', 'library', 'modules', it + else join __dirname, '..', 'modules', it + output: + path: '' + filename: TARGET + if err => return reject err + + err, script <~! readFile TARGET + if err => return reject err + + err <~! unlink TARGET + if err => return reject err + + if umd + exportScript = """ + // CommonJS export + if(typeof module != 'undefined' && module.exports)module.exports = __e; + // RequireJS export + else if(typeof define == 'function' && define.amd)define(function(){return __e}); + // Export to global object + else __g.core = __e; + """ + else + exportScript = "" + + resolve """ + #banner + !function(__e, __g, undefined){ + 'use strict'; + #script + #exportScript + }(1, 1); + """ \ No newline at end of file diff --git a/node_modules/core-js/build/config.js b/node_modules/core-js/build/config.js new file mode 100644 index 0000000..c784cef --- /dev/null +++ b/node_modules/core-js/build/config.js @@ -0,0 +1,252 @@ +module.exports = { + list: [ + 'es6.symbol', + 'es6.object.define-property', + 'es6.object.define-properties', + 'es6.object.get-own-property-descriptor', + 'es6.object.create', + 'es6.object.get-prototype-of', + 'es6.object.keys', + 'es6.object.get-own-property-names', + 'es6.object.freeze', + 'es6.object.seal', + 'es6.object.prevent-extensions', + 'es6.object.is-frozen', + 'es6.object.is-sealed', + 'es6.object.is-extensible', + 'es6.object.assign', + 'es6.object.is', + 'es6.object.set-prototype-of', + 'es6.object.to-string', + 'es6.function.bind', + 'es6.function.name', + 'es6.function.has-instance', + 'es6.number.constructor', + 'es6.number.to-fixed', + 'es6.number.to-precision', + 'es6.number.epsilon', + 'es6.number.is-finite', + 'es6.number.is-integer', + 'es6.number.is-nan', + 'es6.number.is-safe-integer', + 'es6.number.max-safe-integer', + 'es6.number.min-safe-integer', + 'es6.number.parse-float', + 'es6.number.parse-int', + 'es6.parse-int', + 'es6.parse-float', + 'es6.math.acosh', + 'es6.math.asinh', + 'es6.math.atanh', + 'es6.math.cbrt', + 'es6.math.clz32', + 'es6.math.cosh', + 'es6.math.expm1', + 'es6.math.fround', + 'es6.math.hypot', + 'es6.math.imul', + 'es6.math.log10', + 'es6.math.log1p', + 'es6.math.log2', + 'es6.math.sign', + 'es6.math.sinh', + 'es6.math.tanh', + 'es6.math.trunc', + 'es6.string.from-code-point', + 'es6.string.raw', + 'es6.string.trim', + 'es6.string.code-point-at', + 'es6.string.ends-with', + 'es6.string.includes', + 'es6.string.repeat', + 'es6.string.starts-with', + 'es6.string.iterator', + 'es6.string.anchor', + 'es6.string.big', + 'es6.string.blink', + 'es6.string.bold', + 'es6.string.fixed', + 'es6.string.fontcolor', + 'es6.string.fontsize', + 'es6.string.italics', + 'es6.string.link', + 'es6.string.small', + 'es6.string.strike', + 'es6.string.sub', + 'es6.string.sup', + 'es6.array.is-array', + 'es6.array.from', + 'es6.array.of', + 'es6.array.join', + 'es6.array.slice', + 'es6.array.sort', + 'es6.array.for-each', + 'es6.array.map', + 'es6.array.filter', + 'es6.array.some', + 'es6.array.every', + 'es6.array.reduce', + 'es6.array.reduce-right', + 'es6.array.index-of', + 'es6.array.last-index-of', + 'es6.array.copy-within', + 'es6.array.fill', + 'es6.array.find', + 'es6.array.find-index', + 'es6.array.iterator', + 'es6.array.species', + 'es6.regexp.constructor', + 'es6.regexp.to-string', + 'es6.regexp.flags', + 'es6.regexp.match', + 'es6.regexp.replace', + 'es6.regexp.search', + 'es6.regexp.split', + 'es6.promise', + 'es6.map', + 'es6.set', + 'es6.weak-map', + 'es6.weak-set', + 'es6.reflect.apply', + 'es6.reflect.construct', + 'es6.reflect.define-property', + 'es6.reflect.delete-property', + 'es6.reflect.enumerate', + 'es6.reflect.get', + 'es6.reflect.get-own-property-descriptor', + 'es6.reflect.get-prototype-of', + 'es6.reflect.has', + 'es6.reflect.is-extensible', + 'es6.reflect.own-keys', + 'es6.reflect.prevent-extensions', + 'es6.reflect.set', + 'es6.reflect.set-prototype-of', + 'es6.date.now', + 'es6.date.to-json', + 'es6.date.to-iso-string', + 'es6.date.to-string', + 'es6.date.to-primitive', + 'es6.typed.array-buffer', + 'es6.typed.data-view', + 'es6.typed.int8-array', + 'es6.typed.uint8-array', + 'es6.typed.uint8-clamped-array', + 'es6.typed.int16-array', + 'es6.typed.uint16-array', + 'es6.typed.int32-array', + 'es6.typed.uint32-array', + 'es6.typed.float32-array', + 'es6.typed.float64-array', + 'es7.array.includes', + 'es7.string.at', + 'es7.string.pad-start', + 'es7.string.pad-end', + 'es7.string.trim-left', + 'es7.string.trim-right', + 'es7.string.match-all', + 'es7.symbol.async-iterator', + 'es7.symbol.observable', + 'es7.object.get-own-property-descriptors', + 'es7.object.values', + 'es7.object.entries', + 'es7.object.define-getter', + 'es7.object.define-setter', + 'es7.object.lookup-getter', + 'es7.object.lookup-setter', + 'es7.map.to-json', + 'es7.set.to-json', + 'es7.system.global', + 'es7.error.is-error', + 'es7.math.iaddh', + 'es7.math.isubh', + 'es7.math.imulh', + 'es7.math.umulh', + 'es7.reflect.define-metadata', + 'es7.reflect.delete-metadata', + 'es7.reflect.get-metadata', + 'es7.reflect.get-metadata-keys', + 'es7.reflect.get-own-metadata', + 'es7.reflect.get-own-metadata-keys', + 'es7.reflect.has-metadata', + 'es7.reflect.has-own-metadata', + 'es7.reflect.metadata', + 'es7.asap', + 'web.immediate', + 'web.dom.iterable', + 'web.timers', + 'core.dict', + 'core.get-iterator-method', + 'core.get-iterator', + 'core.is-iterable', + 'core.delay', + 'core.function.part', + 'core.object.is-object', + 'core.object.classof', + 'core.object.define', + 'core.object.make', + 'core.number.iterator', + 'core.regexp.escape', + 'core.string.escape-html', + 'core.string.unescape-html' + ], + experimental: [ + ], + libraryBlacklist: [ + 'es6.object.to-string', + 'es6.function.name', + 'es6.regexp.constructor', + 'es6.regexp.to-string', + 'es6.regexp.flags', + 'es6.regexp.match', + 'es6.regexp.replace', + 'es6.regexp.search', + 'es6.regexp.split', + 'es6.number.constructor', + 'es6.date.to-string', + 'es6.date.to-primitive' + ], + es5SpecialCase: [ + 'es6.object.create', + 'es6.object.define-property', + 'es6.object.define-properties', + 'es6.object.get-own-property-descriptor', + 'es6.object.get-prototype-of', + 'es6.object.keys', + 'es6.object.get-own-property-names', + 'es6.object.freeze', + 'es6.object.seal', + 'es6.object.prevent-extensions', + 'es6.object.is-frozen', + 'es6.object.is-sealed', + 'es6.object.is-extensible', + 'es6.function.bind', + 'es6.array.is-array', + 'es6.array.join', + 'es6.array.slice', + 'es6.array.sort', + 'es6.array.for-each', + 'es6.array.map', + 'es6.array.filter', + 'es6.array.some', + 'es6.array.every', + 'es6.array.reduce', + 'es6.array.reduce-right', + 'es6.array.index-of', + 'es6.array.last-index-of', + 'es6.number.to-fixed', + 'es6.number.to-precision', + 'es6.date.now', + 'es6.date.to-iso-string', + 'es6.date.to-json', + 'es6.string.trim', + 'es6.regexp.to-string', + 'es6.parse-int', + 'es6.parse-float' + ], + banner: '/**\n' + + ' * core-js ' + require('../package').version + '\n' + + ' * https://github.com/zloirock/core-js\n' + + ' * License: http://rock.mit-license.org\n' + + ' * © ' + new Date().getFullYear() + ' Denis Pushkarev\n' + + ' */' +}; \ No newline at end of file diff --git a/node_modules/core-js/build/index.js b/node_modules/core-js/build/index.js new file mode 100644 index 0000000..26bdec4 --- /dev/null +++ b/node_modules/core-js/build/index.js @@ -0,0 +1,104 @@ +// Generated by LiveScript 1.4.0 +(function(){ + var Promise, ref$, list, experimental, libraryBlacklist, es5SpecialCase, banner, readFile, writeFile, unlink, join, webpack, temp; + Promise = require('../library/fn/promise'); + ref$ = require('./config'), list = ref$.list, experimental = ref$.experimental, libraryBlacklist = ref$.libraryBlacklist, es5SpecialCase = ref$.es5SpecialCase, banner = ref$.banner; + ref$ = require('fs'), readFile = ref$.readFile, writeFile = ref$.writeFile, unlink = ref$.unlink; + join = require('path').join; + webpack = require('webpack'); + temp = require('temp'); + module.exports = function(arg$){ + var modules, ref$, blacklist, library, umd, this$ = this; + modules = (ref$ = arg$.modules) != null + ? ref$ + : [], blacklist = (ref$ = arg$.blacklist) != null + ? ref$ + : [], library = (ref$ = arg$.library) != null ? ref$ : false, umd = (ref$ = arg$.umd) != null ? ref$ : true; + return new Promise(function(resolve, reject){ + (function(){ + var i$, x$, ref$, len$, y$, ns, name, j$, len1$, TARGET, this$ = this; + if (this.exp) { + for (i$ = 0, len$ = (ref$ = experimental).length; i$ < len$; ++i$) { + x$ = ref$[i$]; + this[x$] = true; + } + } + if (this.es5) { + for (i$ = 0, len$ = (ref$ = es5SpecialCase).length; i$ < len$; ++i$) { + y$ = ref$[i$]; + this[y$] = true; + } + } + for (ns in this) { + if (this[ns]) { + for (i$ = 0, len$ = (ref$ = list).length; i$ < len$; ++i$) { + name = ref$[i$]; + if (name.indexOf(ns + ".") === 0 && !in$(name, experimental)) { + this[name] = true; + } + } + } + } + if (library) { + blacklist = blacklist.concat(libraryBlacklist); + } + for (i$ = 0, len$ = blacklist.length; i$ < len$; ++i$) { + ns = blacklist[i$]; + for (j$ = 0, len1$ = (ref$ = list).length; j$ < len1$; ++j$) { + name = ref$[j$]; + if (name === ns || name.indexOf(ns + ".") === 0) { + this[name] = false; + } + } + } + TARGET = temp.path({ + suffix: '.js' + }); + webpack({ + entry: list.filter(function(it){ + return this$[it]; + }).map(function(it){ + if (library) { + return join(__dirname, '..', 'library', 'modules', it); + } else { + return join(__dirname, '..', 'modules', it); + } + }), + output: { + path: '', + filename: TARGET + } + }, function(err, info){ + if (err) { + return reject(err); + } + readFile(TARGET, function(err, script){ + if (err) { + return reject(err); + } + unlink(TARGET, function(err){ + var exportScript; + if (err) { + return reject(err); + } + if (umd) { + exportScript = "// CommonJS export\nif(typeof module != 'undefined' && module.exports)module.exports = __e;\n// RequireJS export\nelse if(typeof define == 'function' && define.amd)define(function(){return __e});\n// Export to global object\nelse __g.core = __e;"; + } else { + exportScript = ""; + } + resolve("" + banner + "\n!function(__e, __g, undefined){\n'use strict';\n" + script + "\n" + exportScript + "\n}(1, 1);"); + }); + }); + }); + }.call(modules.reduce(function(memo, it){ + memo[it] = true; + return memo; + }, {}))); + }); + }; + function in$(x, xs){ + var i = -1, l = xs.length >>> 0; + while (++i < l) if (x === xs[i]) return true; + return false; + } +}).call(this); diff --git a/node_modules/core-js/client/core.js b/node_modules/core-js/client/core.js new file mode 100644 index 0000000..f46cba0 --- /dev/null +++ b/node_modules/core-js/client/core.js @@ -0,0 +1,7386 @@ +/** + * core-js 2.3.0 + * https://github.com/zloirock/core-js + * License: http://rock.mit-license.org + * © 2016 Denis Pushkarev + */ +!function(__e, __g, undefined){ +'use strict'; +/******/ (function(modules) { // webpackBootstrap +/******/ // The module cache +/******/ var installedModules = {}; + +/******/ // The require function +/******/ function __webpack_require__(moduleId) { + +/******/ // Check if module is in cache +/******/ if(installedModules[moduleId]) +/******/ return installedModules[moduleId].exports; + +/******/ // Create a new module (and put it into the cache) +/******/ var module = installedModules[moduleId] = { +/******/ exports: {}, +/******/ id: moduleId, +/******/ loaded: false +/******/ }; + +/******/ // Execute the module function +/******/ modules[moduleId].call(module.exports, module, module.exports, __webpack_require__); + +/******/ // Flag the module as loaded +/******/ module.loaded = true; + +/******/ // Return the exports of the module +/******/ return module.exports; +/******/ } + + +/******/ // expose the modules object (__webpack_modules__) +/******/ __webpack_require__.m = modules; + +/******/ // expose the module cache +/******/ __webpack_require__.c = installedModules; + +/******/ // __webpack_public_path__ +/******/ __webpack_require__.p = ""; + +/******/ // Load entry module and return exports +/******/ return __webpack_require__(0); +/******/ }) +/************************************************************************/ +/******/ ([ +/* 0 */ +/***/ function(module, exports, __webpack_require__) { + + __webpack_require__(1); + __webpack_require__(50); + __webpack_require__(51); + __webpack_require__(52); + __webpack_require__(54); + __webpack_require__(55); + __webpack_require__(58); + __webpack_require__(59); + __webpack_require__(60); + __webpack_require__(61); + __webpack_require__(62); + __webpack_require__(63); + __webpack_require__(64); + __webpack_require__(65); + __webpack_require__(66); + __webpack_require__(68); + __webpack_require__(70); + __webpack_require__(72); + __webpack_require__(74); + __webpack_require__(77); + __webpack_require__(78); + __webpack_require__(79); + __webpack_require__(83); + __webpack_require__(87); + __webpack_require__(88); + __webpack_require__(89); + __webpack_require__(90); + __webpack_require__(92); + __webpack_require__(93); + __webpack_require__(94); + __webpack_require__(95); + __webpack_require__(96); + __webpack_require__(98); + __webpack_require__(100); + __webpack_require__(101); + __webpack_require__(102); + __webpack_require__(104); + __webpack_require__(105); + __webpack_require__(106); + __webpack_require__(108); + __webpack_require__(109); + __webpack_require__(110); + __webpack_require__(112); + __webpack_require__(113); + __webpack_require__(114); + __webpack_require__(115); + __webpack_require__(116); + __webpack_require__(117); + __webpack_require__(118); + __webpack_require__(119); + __webpack_require__(120); + __webpack_require__(121); + __webpack_require__(122); + __webpack_require__(123); + __webpack_require__(124); + __webpack_require__(125); + __webpack_require__(127); + __webpack_require__(131); + __webpack_require__(132); + __webpack_require__(133); + __webpack_require__(134); + __webpack_require__(138); + __webpack_require__(140); + __webpack_require__(141); + __webpack_require__(142); + __webpack_require__(143); + __webpack_require__(144); + __webpack_require__(145); + __webpack_require__(146); + __webpack_require__(147); + __webpack_require__(148); + __webpack_require__(149); + __webpack_require__(150); + __webpack_require__(151); + __webpack_require__(152); + __webpack_require__(153); + __webpack_require__(159); + __webpack_require__(160); + __webpack_require__(162); + __webpack_require__(163); + __webpack_require__(164); + __webpack_require__(168); + __webpack_require__(169); + __webpack_require__(170); + __webpack_require__(171); + __webpack_require__(172); + __webpack_require__(174); + __webpack_require__(175); + __webpack_require__(176); + __webpack_require__(177); + __webpack_require__(180); + __webpack_require__(182); + __webpack_require__(183); + __webpack_require__(184); + __webpack_require__(186); + __webpack_require__(188); + __webpack_require__(190); + __webpack_require__(191); + __webpack_require__(192); + __webpack_require__(194); + __webpack_require__(195); + __webpack_require__(196); + __webpack_require__(197); + __webpack_require__(203); + __webpack_require__(206); + __webpack_require__(207); + __webpack_require__(209); + __webpack_require__(210); + __webpack_require__(211); + __webpack_require__(212); + __webpack_require__(213); + __webpack_require__(214); + __webpack_require__(215); + __webpack_require__(216); + __webpack_require__(217); + __webpack_require__(218); + __webpack_require__(219); + __webpack_require__(220); + __webpack_require__(222); + __webpack_require__(223); + __webpack_require__(224); + __webpack_require__(225); + __webpack_require__(226); + __webpack_require__(227); + __webpack_require__(228); + __webpack_require__(229); + __webpack_require__(231); + __webpack_require__(234); + __webpack_require__(235); + __webpack_require__(238); + __webpack_require__(239); + __webpack_require__(240); + __webpack_require__(241); + __webpack_require__(242); + __webpack_require__(243); + __webpack_require__(244); + __webpack_require__(245); + __webpack_require__(246); + __webpack_require__(247); + __webpack_require__(248); + __webpack_require__(250); + __webpack_require__(251); + __webpack_require__(252); + __webpack_require__(253); + __webpack_require__(254); + __webpack_require__(255); + __webpack_require__(256); + __webpack_require__(257); + __webpack_require__(259); + __webpack_require__(260); + __webpack_require__(262); + __webpack_require__(263); + __webpack_require__(264); + __webpack_require__(265); + __webpack_require__(268); + __webpack_require__(269); + __webpack_require__(270); + __webpack_require__(271); + __webpack_require__(272); + __webpack_require__(273); + __webpack_require__(274); + __webpack_require__(275); + __webpack_require__(277); + __webpack_require__(278); + __webpack_require__(279); + __webpack_require__(280); + __webpack_require__(281); + __webpack_require__(282); + __webpack_require__(283); + __webpack_require__(284); + __webpack_require__(285); + __webpack_require__(286); + __webpack_require__(287); + __webpack_require__(288); + __webpack_require__(291); + __webpack_require__(157); + __webpack_require__(292); + __webpack_require__(237); + __webpack_require__(293); + __webpack_require__(294); + __webpack_require__(295); + __webpack_require__(296); + __webpack_require__(297); + __webpack_require__(299); + __webpack_require__(300); + __webpack_require__(301); + __webpack_require__(303); + module.exports = __webpack_require__(304); + + +/***/ }, +/* 1 */ +/***/ function(module, exports, __webpack_require__) { + + 'use strict'; + // ECMAScript 6 symbols shim + var global = __webpack_require__(2) + , has = __webpack_require__(3) + , DESCRIPTORS = __webpack_require__(4) + , $export = __webpack_require__(6) + , redefine = __webpack_require__(16) + , META = __webpack_require__(20).KEY + , $fails = __webpack_require__(5) + , shared = __webpack_require__(21) + , setToStringTag = __webpack_require__(22) + , uid = __webpack_require__(17) + , wks = __webpack_require__(23) + , wksExt = __webpack_require__(24) + , wksDefine = __webpack_require__(25) + , keyOf = __webpack_require__(27) + , enumKeys = __webpack_require__(40) + , isArray = __webpack_require__(43) + , anObject = __webpack_require__(10) + , toIObject = __webpack_require__(30) + , toPrimitive = __webpack_require__(14) + , createDesc = __webpack_require__(15) + , _create = __webpack_require__(44) + , gOPNExt = __webpack_require__(47) + , $GOPD = __webpack_require__(49) + , $DP = __webpack_require__(9) + , $keys = __webpack_require__(28) + , gOPD = $GOPD.f + , dP = $DP.f + , gOPN = gOPNExt.f + , $Symbol = global.Symbol + , $JSON = global.JSON + , _stringify = $JSON && $JSON.stringify + , PROTOTYPE = 'prototype' + , HIDDEN = wks('_hidden') + , TO_PRIMITIVE = wks('toPrimitive') + , isEnum = {}.propertyIsEnumerable + , SymbolRegistry = shared('symbol-registry') + , AllSymbols = shared('symbols') + , ObjectProto = Object[PROTOTYPE] + , USE_NATIVE = typeof $Symbol == 'function' + , QObject = global.QObject; + // Don't use setters in Qt Script, https://github.com/zloirock/core-js/issues/173 + var setter = !QObject || !QObject[PROTOTYPE] || !QObject[PROTOTYPE].findChild; + + // fallback for old Android, https://code.google.com/p/v8/issues/detail?id=687 + var setSymbolDesc = DESCRIPTORS && $fails(function(){ + return _create(dP({}, 'a', { + get: function(){ return dP(this, 'a', {value: 7}).a; } + })).a != 7; + }) ? function(it, key, D){ + var protoDesc = gOPD(ObjectProto, key); + if(protoDesc)delete ObjectProto[key]; + dP(it, key, D); + if(protoDesc && it !== ObjectProto)dP(ObjectProto, key, protoDesc); + } : dP; + + var wrap = function(tag){ + var sym = AllSymbols[tag] = _create($Symbol[PROTOTYPE]); + sym._k = tag; + return sym; + }; + + var isSymbol = USE_NATIVE && typeof $Symbol.iterator == 'symbol' ? function(it){ + return typeof it == 'symbol'; + } : function(it){ + return it instanceof $Symbol; + }; + + var $defineProperty = function defineProperty(it, key, D){ + anObject(it); + key = toPrimitive(key, true); + anObject(D); + if(has(AllSymbols, key)){ + if(!D.enumerable){ + if(!has(it, HIDDEN))dP(it, HIDDEN, createDesc(1, {})); + it[HIDDEN][key] = true; + } else { + if(has(it, HIDDEN) && it[HIDDEN][key])it[HIDDEN][key] = false; + D = _create(D, {enumerable: createDesc(0, false)}); + } return setSymbolDesc(it, key, D); + } return dP(it, key, D); + }; + var $defineProperties = function defineProperties(it, P){ + anObject(it); + var keys = enumKeys(P = toIObject(P)) + , i = 0 + , l = keys.length + , key; + while(l > i)$defineProperty(it, key = keys[i++], P[key]); + return it; + }; + var $create = function create(it, P){ + return P === undefined ? _create(it) : $defineProperties(_create(it), P); + }; + var $propertyIsEnumerable = function propertyIsEnumerable(key){ + var E = isEnum.call(this, key = toPrimitive(key, true)); + return E || !has(this, key) || !has(AllSymbols, key) || has(this, HIDDEN) && this[HIDDEN][key] ? E : true; + }; + var $getOwnPropertyDescriptor = function getOwnPropertyDescriptor(it, key){ + var D = gOPD(it = toIObject(it), key = toPrimitive(key, true)); + if(D && has(AllSymbols, key) && !(has(it, HIDDEN) && it[HIDDEN][key]))D.enumerable = true; + return D; + }; + var $getOwnPropertyNames = function getOwnPropertyNames(it){ + var names = gOPN(toIObject(it)) + , result = [] + , i = 0 + , key; + while(names.length > i)if(!has(AllSymbols, key = names[i++]) && key != HIDDEN && key != META)result.push(key); + return result; + }; + var $getOwnPropertySymbols = function getOwnPropertySymbols(it){ + var names = gOPN(toIObject(it)) + , result = [] + , i = 0 + , key; + while(names.length > i)if(has(AllSymbols, key = names[i++]))result.push(AllSymbols[key]); + return result; + }; + + // 19.4.1.1 Symbol([description]) + if(!USE_NATIVE){ + $Symbol = function Symbol(){ + if(this instanceof $Symbol)throw TypeError('Symbol is not a constructor!'); + var tag = uid(arguments.length > 0 ? arguments[0] : undefined); + DESCRIPTORS && setter && setSymbolDesc(ObjectProto, tag, { + configurable: true, + set: function(value){ + if(has(this, HIDDEN) && has(this[HIDDEN], tag))this[HIDDEN][tag] = false; + setSymbolDesc(this, tag, createDesc(1, value)); + } + }); + return wrap(tag); + }; + redefine($Symbol[PROTOTYPE], 'toString', function toString(){ + return this._k; + }); + + $GOPD.f = $getOwnPropertyDescriptor; + $DP.f = $defineProperty; + __webpack_require__(48).f = gOPNExt.f = $getOwnPropertyNames; + __webpack_require__(42).f = $propertyIsEnumerable; + __webpack_require__(41).f = $getOwnPropertySymbols; + + if(DESCRIPTORS && !__webpack_require__(26)){ + redefine(ObjectProto, 'propertyIsEnumerable', $propertyIsEnumerable, true); + } + + wksExt.f = function(name){ + return wrap(wks(name)); + } + } + + $export($export.G + $export.W + $export.F * !USE_NATIVE, {Symbol: $Symbol}); + + for(var symbols = ( + // 19.4.2.2, 19.4.2.3, 19.4.2.4, 19.4.2.6, 19.4.2.8, 19.4.2.9, 19.4.2.10, 19.4.2.11, 19.4.2.12, 19.4.2.13, 19.4.2.14 + 'hasInstance,isConcatSpreadable,iterator,match,replace,search,species,split,toPrimitive,toStringTag,unscopables' + ).split(','), i = 0; symbols.length > i; )wks(symbols[i++]); + + for(var symbols = $keys(wks.store), i = 0; symbols.length > i; )wksDefine(symbols[i++]); + + $export($export.S + $export.F * !USE_NATIVE, 'Symbol', { + // 19.4.2.1 Symbol.for(key) + 'for': function(key){ + return has(SymbolRegistry, key += '') + ? SymbolRegistry[key] + : SymbolRegistry[key] = $Symbol(key); + }, + // 19.4.2.5 Symbol.keyFor(sym) + keyFor: function keyFor(key){ + if(isSymbol(key))return keyOf(SymbolRegistry, key); + throw TypeError(key + ' is not a symbol!'); + }, + useSetter: function(){ setter = true; }, + useSimple: function(){ setter = false; } + }); + + $export($export.S + $export.F * !USE_NATIVE, 'Object', { + // 19.1.2.2 Object.create(O [, Properties]) + create: $create, + // 19.1.2.4 Object.defineProperty(O, P, Attributes) + defineProperty: $defineProperty, + // 19.1.2.3 Object.defineProperties(O, Properties) + defineProperties: $defineProperties, + // 19.1.2.6 Object.getOwnPropertyDescriptor(O, P) + getOwnPropertyDescriptor: $getOwnPropertyDescriptor, + // 19.1.2.7 Object.getOwnPropertyNames(O) + getOwnPropertyNames: $getOwnPropertyNames, + // 19.1.2.8 Object.getOwnPropertySymbols(O) + getOwnPropertySymbols: $getOwnPropertySymbols + }); + + // 24.3.2 JSON.stringify(value [, replacer [, space]]) + $JSON && $export($export.S + $export.F * (!USE_NATIVE || $fails(function(){ + var S = $Symbol(); + // MS Edge converts symbol values to JSON as {} + // WebKit converts symbol values to JSON as null + // V8 throws on boxed symbols + return _stringify([S]) != '[null]' || _stringify({a: S}) != '{}' || _stringify(Object(S)) != '{}'; + })), 'JSON', { + stringify: function stringify(it){ + if(it === undefined || isSymbol(it))return; // IE8 returns string on undefined + var args = [it] + , i = 1 + , replacer, $replacer; + while(arguments.length > i)args.push(arguments[i++]); + replacer = args[1]; + if(typeof replacer == 'function')$replacer = replacer; + if($replacer || !isArray(replacer))replacer = function(key, value){ + if($replacer)value = $replacer.call(this, key, value); + if(!isSymbol(value))return value; + }; + args[1] = replacer; + return _stringify.apply($JSON, args); + } + }); + + // 19.4.3.4 Symbol.prototype[@@toPrimitive](hint) + $Symbol[PROTOTYPE][TO_PRIMITIVE] || __webpack_require__(8)($Symbol[PROTOTYPE], TO_PRIMITIVE, $Symbol[PROTOTYPE].valueOf); + // 19.4.3.5 Symbol.prototype[@@toStringTag] + setToStringTag($Symbol, 'Symbol'); + // 20.2.1.9 Math[@@toStringTag] + setToStringTag(Math, 'Math', true); + // 24.3.3 JSON[@@toStringTag] + setToStringTag(global.JSON, 'JSON', true); + +/***/ }, +/* 2 */ +/***/ function(module, exports) { + + // https://github.com/zloirock/core-js/issues/86#issuecomment-115759028 + var global = module.exports = typeof window != 'undefined' && window.Math == Math + ? window : typeof self != 'undefined' && self.Math == Math ? self : Function('return this')(); + if(typeof __g == 'number')__g = global; // eslint-disable-line no-undef + +/***/ }, +/* 3 */ +/***/ function(module, exports) { + + var hasOwnProperty = {}.hasOwnProperty; + module.exports = function(it, key){ + return hasOwnProperty.call(it, key); + }; + +/***/ }, +/* 4 */ +/***/ function(module, exports, __webpack_require__) { + + // Thank's IE8 for his funny defineProperty + module.exports = !__webpack_require__(5)(function(){ + return Object.defineProperty({}, 'a', {get: function(){ return 7; }}).a != 7; + }); + +/***/ }, +/* 5 */ +/***/ function(module, exports) { + + module.exports = function(exec){ + try { + return !!exec(); + } catch(e){ + return true; + } + }; + +/***/ }, +/* 6 */ +/***/ function(module, exports, __webpack_require__) { + + var global = __webpack_require__(2) + , core = __webpack_require__(7) + , hide = __webpack_require__(8) + , redefine = __webpack_require__(16) + , ctx = __webpack_require__(18) + , PROTOTYPE = 'prototype'; + + var $export = function(type, name, source){ + var IS_FORCED = type & $export.F + , IS_GLOBAL = type & $export.G + , IS_STATIC = type & $export.S + , IS_PROTO = type & $export.P + , IS_BIND = type & $export.B + , target = IS_GLOBAL ? global : IS_STATIC ? global[name] || (global[name] = {}) : (global[name] || {})[PROTOTYPE] + , exports = IS_GLOBAL ? core : core[name] || (core[name] = {}) + , expProto = exports[PROTOTYPE] || (exports[PROTOTYPE] = {}) + , key, own, out, exp; + if(IS_GLOBAL)source = name; + for(key in source){ + // contains in native + own = !IS_FORCED && target && target[key] !== undefined; + // export native or passed + out = (own ? target : source)[key]; + // bind timers to global for call from export context + exp = IS_BIND && own ? ctx(out, global) : IS_PROTO && typeof out == 'function' ? ctx(Function.call, out) : out; + // extend global + if(target)redefine(target, key, out, type & $export.U); + // export + if(exports[key] != out)hide(exports, key, exp); + if(IS_PROTO && expProto[key] != out)expProto[key] = out; + } + }; + global.core = core; + // type bitmap + $export.F = 1; // forced + $export.G = 2; // global + $export.S = 4; // static + $export.P = 8; // proto + $export.B = 16; // bind + $export.W = 32; // wrap + $export.U = 64; // safe + $export.R = 128; // real proto method for `library` + module.exports = $export; + +/***/ }, +/* 7 */ +/***/ function(module, exports) { + + var core = module.exports = {version: '2.3.0'}; + if(typeof __e == 'number')__e = core; // eslint-disable-line no-undef + +/***/ }, +/* 8 */ +/***/ function(module, exports, __webpack_require__) { + + var dP = __webpack_require__(9) + , createDesc = __webpack_require__(15); + module.exports = __webpack_require__(4) ? function(object, key, value){ + return dP.f(object, key, createDesc(1, value)); + } : function(object, key, value){ + object[key] = value; + return object; + }; + +/***/ }, +/* 9 */ +/***/ function(module, exports, __webpack_require__) { + + var anObject = __webpack_require__(10) + , IE8_DOM_DEFINE = __webpack_require__(12) + , toPrimitive = __webpack_require__(14) + , dP = Object.defineProperty; + + exports.f = __webpack_require__(4) ? Object.defineProperty : function defineProperty(O, P, Attributes){ + anObject(O); + P = toPrimitive(P, true); + anObject(Attributes); + if(IE8_DOM_DEFINE)try { + return dP(O, P, Attributes); + } catch(e){ /* empty */ } + if('get' in Attributes || 'set' in Attributes)throw TypeError('Accessors not supported!'); + if('value' in Attributes)O[P] = Attributes.value; + return O; + }; + +/***/ }, +/* 10 */ +/***/ function(module, exports, __webpack_require__) { + + var isObject = __webpack_require__(11); + module.exports = function(it){ + if(!isObject(it))throw TypeError(it + ' is not an object!'); + return it; + }; + +/***/ }, +/* 11 */ +/***/ function(module, exports) { + + module.exports = function(it){ + return typeof it === 'object' ? it !== null : typeof it === 'function'; + }; + +/***/ }, +/* 12 */ +/***/ function(module, exports, __webpack_require__) { + + module.exports = !__webpack_require__(4) && !__webpack_require__(5)(function(){ + return Object.defineProperty(__webpack_require__(13)('div'), 'a', {get: function(){ return 7; }}).a != 7; + }); + +/***/ }, +/* 13 */ +/***/ function(module, exports, __webpack_require__) { + + var isObject = __webpack_require__(11) + , document = __webpack_require__(2).document + // in old IE typeof document.createElement is 'object' + , is = isObject(document) && isObject(document.createElement); + module.exports = function(it){ + return is ? document.createElement(it) : {}; + }; + +/***/ }, +/* 14 */ +/***/ function(module, exports, __webpack_require__) { + + // 7.1.1 ToPrimitive(input [, PreferredType]) + var isObject = __webpack_require__(11); + // instead of the ES6 spec version, we didn't implement @@toPrimitive case + // and the second argument - flag - preferred type is a string + module.exports = function(it, S){ + if(!isObject(it))return it; + var fn, val; + if(S && typeof (fn = it.toString) == 'function' && !isObject(val = fn.call(it)))return val; + if(typeof (fn = it.valueOf) == 'function' && !isObject(val = fn.call(it)))return val; + if(!S && typeof (fn = it.toString) == 'function' && !isObject(val = fn.call(it)))return val; + throw TypeError("Can't convert object to primitive value"); + }; + +/***/ }, +/* 15 */ +/***/ function(module, exports) { + + module.exports = function(bitmap, value){ + return { + enumerable : !(bitmap & 1), + configurable: !(bitmap & 2), + writable : !(bitmap & 4), + value : value + }; + }; + +/***/ }, +/* 16 */ +/***/ function(module, exports, __webpack_require__) { + + var global = __webpack_require__(2) + , hide = __webpack_require__(8) + , has = __webpack_require__(3) + , SRC = __webpack_require__(17)('src') + , TO_STRING = 'toString' + , $toString = Function[TO_STRING] + , TPL = ('' + $toString).split(TO_STRING); + + __webpack_require__(7).inspectSource = function(it){ + return $toString.call(it); + }; + + (module.exports = function(O, key, val, safe){ + var isFunction = typeof val == 'function'; + if(isFunction)has(val, 'name') || hide(val, 'name', key); + if(O[key] === val)return; + if(isFunction)has(val, SRC) || hide(val, SRC, O[key] ? '' + O[key] : TPL.join(String(key))); + if(O === global){ + O[key] = val; + } else { + if(!safe){ + delete O[key]; + hide(O, key, val); + } else { + if(O[key])O[key] = val; + else hide(O, key, val); + } + } + // add fake Function#toString for correct work wrapped methods / constructors with methods like LoDash isNative + })(Function.prototype, TO_STRING, function toString(){ + return typeof this == 'function' && this[SRC] || $toString.call(this); + }); + +/***/ }, +/* 17 */ +/***/ function(module, exports) { + + var id = 0 + , px = Math.random(); + module.exports = function(key){ + return 'Symbol('.concat(key === undefined ? '' : key, ')_', (++id + px).toString(36)); + }; + +/***/ }, +/* 18 */ +/***/ function(module, exports, __webpack_require__) { + + // optional / simple context binding + var aFunction = __webpack_require__(19); + module.exports = function(fn, that, length){ + aFunction(fn); + if(that === undefined)return fn; + switch(length){ + case 1: return function(a){ + return fn.call(that, a); + }; + case 2: return function(a, b){ + return fn.call(that, a, b); + }; + case 3: return function(a, b, c){ + return fn.call(that, a, b, c); + }; + } + return function(/* ...args */){ + return fn.apply(that, arguments); + }; + }; + +/***/ }, +/* 19 */ +/***/ function(module, exports) { + + module.exports = function(it){ + if(typeof it != 'function')throw TypeError(it + ' is not a function!'); + return it; + }; + +/***/ }, +/* 20 */ +/***/ function(module, exports, __webpack_require__) { + + var META = __webpack_require__(17)('meta') + , isObject = __webpack_require__(11) + , has = __webpack_require__(3) + , setDesc = __webpack_require__(9).f + , id = 0; + var isExtensible = Object.isExtensible || function(){ + return true; + }; + var FREEZE = !__webpack_require__(5)(function(){ + return isExtensible(Object.preventExtensions({})); + }); + var setMeta = function(it){ + setDesc(it, META, {value: { + i: 'O' + ++id, // object ID + w: {} // weak collections IDs + }}); + }; + var fastKey = function(it, create){ + // return primitive with prefix + if(!isObject(it))return typeof it == 'symbol' ? it : (typeof it == 'string' ? 'S' : 'P') + it; + if(!has(it, META)){ + // can't set metadata to uncaught frozen object + if(!isExtensible(it))return 'F'; + // not necessary to add metadata + if(!create)return 'E'; + // add missing metadata + setMeta(it); + // return object ID + } return it[META].i; + }; + var getWeak = function(it, create){ + if(!has(it, META)){ + // can't set metadata to uncaught frozen object + if(!isExtensible(it))return true; + // not necessary to add metadata + if(!create)return false; + // add missing metadata + setMeta(it); + // return hash weak collections IDs + } return it[META].w; + }; + // add metadata on freeze-family methods calling + var onFreeze = function(it){ + if(FREEZE && meta.NEED && isExtensible(it) && !has(it, META))setMeta(it); + return it; + }; + var meta = module.exports = { + KEY: META, + NEED: false, + fastKey: fastKey, + getWeak: getWeak, + onFreeze: onFreeze + }; + +/***/ }, +/* 21 */ +/***/ function(module, exports, __webpack_require__) { + + var global = __webpack_require__(2) + , SHARED = '__core-js_shared__' + , store = global[SHARED] || (global[SHARED] = {}); + module.exports = function(key){ + return store[key] || (store[key] = {}); + }; + +/***/ }, +/* 22 */ +/***/ function(module, exports, __webpack_require__) { + + var def = __webpack_require__(9).f + , has = __webpack_require__(3) + , TAG = __webpack_require__(23)('toStringTag'); + + module.exports = function(it, tag, stat){ + if(it && !has(it = stat ? it : it.prototype, TAG))def(it, TAG, {configurable: true, value: tag}); + }; + +/***/ }, +/* 23 */ +/***/ function(module, exports, __webpack_require__) { + + var store = __webpack_require__(21)('wks') + , uid = __webpack_require__(17) + , Symbol = __webpack_require__(2).Symbol + , USE_SYMBOL = typeof Symbol == 'function'; + + var $exports = module.exports = function(name){ + return store[name] || (store[name] = + USE_SYMBOL && Symbol[name] || (USE_SYMBOL ? Symbol : uid)('Symbol.' + name)); + }; + + $exports.store = store; + +/***/ }, +/* 24 */ +/***/ function(module, exports, __webpack_require__) { + + exports.f = __webpack_require__(23); + +/***/ }, +/* 25 */ +/***/ function(module, exports, __webpack_require__) { + + var global = __webpack_require__(2) + , core = __webpack_require__(7) + , LIBRARY = __webpack_require__(26) + , wksExt = __webpack_require__(24) + , defineProperty = __webpack_require__(9).f; + module.exports = function(name){ + var $Symbol = core.Symbol || (core.Symbol = LIBRARY ? {} : global.Symbol || {}); + if(name.charAt(0) != '_' && !(name in $Symbol))defineProperty($Symbol, name, {value: wksExt.f(name)}); + }; + +/***/ }, +/* 26 */ +/***/ function(module, exports) { + + module.exports = false; + +/***/ }, +/* 27 */ +/***/ function(module, exports, __webpack_require__) { + + var getKeys = __webpack_require__(28) + , toIObject = __webpack_require__(30); + module.exports = function(object, el){ + var O = toIObject(object) + , keys = getKeys(O) + , length = keys.length + , index = 0 + , key; + while(length > index)if(O[key = keys[index++]] === el)return key; + }; + +/***/ }, +/* 28 */ +/***/ function(module, exports, __webpack_require__) { + + // 19.1.2.14 / 15.2.3.14 Object.keys(O) + var $keys = __webpack_require__(29) + , enumBugKeys = __webpack_require__(39); + + module.exports = Object.keys || function keys(O){ + return $keys(O, enumBugKeys); + }; + +/***/ }, +/* 29 */ +/***/ function(module, exports, __webpack_require__) { + + var has = __webpack_require__(3) + , toIObject = __webpack_require__(30) + , arrayIndexOf = __webpack_require__(34)(false) + , IE_PROTO = __webpack_require__(38)('IE_PROTO'); + + module.exports = function(object, names){ + var O = toIObject(object) + , i = 0 + , result = [] + , key; + for(key in O)if(key != IE_PROTO)has(O, key) && result.push(key); + // Don't enum bug & hidden keys + while(names.length > i)if(has(O, key = names[i++])){ + ~arrayIndexOf(result, key) || result.push(key); + } + return result; + }; + +/***/ }, +/* 30 */ +/***/ function(module, exports, __webpack_require__) { + + // to indexed object, toObject with fallback for non-array-like ES3 strings + var IObject = __webpack_require__(31) + , defined = __webpack_require__(33); + module.exports = function(it){ + return IObject(defined(it)); + }; + +/***/ }, +/* 31 */ +/***/ function(module, exports, __webpack_require__) { + + // fallback for non-array-like ES3 and non-enumerable old V8 strings + var cof = __webpack_require__(32); + module.exports = Object('z').propertyIsEnumerable(0) ? Object : function(it){ + return cof(it) == 'String' ? it.split('') : Object(it); + }; + +/***/ }, +/* 32 */ +/***/ function(module, exports) { + + var toString = {}.toString; + + module.exports = function(it){ + return toString.call(it).slice(8, -1); + }; + +/***/ }, +/* 33 */ +/***/ function(module, exports) { + + // 7.2.1 RequireObjectCoercible(argument) + module.exports = function(it){ + if(it == undefined)throw TypeError("Can't call method on " + it); + return it; + }; + +/***/ }, +/* 34 */ +/***/ function(module, exports, __webpack_require__) { + + // false -> Array#indexOf + // true -> Array#includes + var toIObject = __webpack_require__(30) + , toLength = __webpack_require__(35) + , toIndex = __webpack_require__(37); + module.exports = function(IS_INCLUDES){ + return function($this, el, fromIndex){ + var O = toIObject($this) + , length = toLength(O.length) + , index = toIndex(fromIndex, length) + , value; + // Array#includes uses SameValueZero equality algorithm + if(IS_INCLUDES && el != el)while(length > index){ + value = O[index++]; + if(value != value)return true; + // Array#toIndex ignores holes, Array#includes - not + } else for(;length > index; index++)if(IS_INCLUDES || index in O){ + if(O[index] === el)return IS_INCLUDES || index || 0; + } return !IS_INCLUDES && -1; + }; + }; + +/***/ }, +/* 35 */ +/***/ function(module, exports, __webpack_require__) { + + // 7.1.15 ToLength + var toInteger = __webpack_require__(36) + , min = Math.min; + module.exports = function(it){ + return it > 0 ? min(toInteger(it), 0x1fffffffffffff) : 0; // pow(2, 53) - 1 == 9007199254740991 + }; + +/***/ }, +/* 36 */ +/***/ function(module, exports) { + + // 7.1.4 ToInteger + var ceil = Math.ceil + , floor = Math.floor; + module.exports = function(it){ + return isNaN(it = +it) ? 0 : (it > 0 ? floor : ceil)(it); + }; + +/***/ }, +/* 37 */ +/***/ function(module, exports, __webpack_require__) { + + var toInteger = __webpack_require__(36) + , max = Math.max + , min = Math.min; + module.exports = function(index, length){ + index = toInteger(index); + return index < 0 ? max(index + length, 0) : min(index, length); + }; + +/***/ }, +/* 38 */ +/***/ function(module, exports, __webpack_require__) { + + var shared = __webpack_require__(21)('keys') + , uid = __webpack_require__(17); + module.exports = function(key){ + return shared[key] || (shared[key] = uid(key)); + }; + +/***/ }, +/* 39 */ +/***/ function(module, exports) { + + // IE 8- don't enum bug keys + module.exports = ( + 'constructor,hasOwnProperty,isPrototypeOf,propertyIsEnumerable,toLocaleString,toString,valueOf' + ).split(','); + +/***/ }, +/* 40 */ +/***/ function(module, exports, __webpack_require__) { + + // all enumerable object keys, includes symbols + var getKeys = __webpack_require__(28) + , gOPS = __webpack_require__(41) + , pIE = __webpack_require__(42); + module.exports = function(it){ + var result = getKeys(it) + , getSymbols = gOPS.f; + if(getSymbols){ + var symbols = getSymbols(it) + , isEnum = pIE.f + , i = 0 + , key; + while(symbols.length > i)if(isEnum.call(it, key = symbols[i++]))result.push(key); + } return result; + }; + +/***/ }, +/* 41 */ +/***/ function(module, exports) { + + exports.f = Object.getOwnPropertySymbols; + +/***/ }, +/* 42 */ +/***/ function(module, exports) { + + exports.f = {}.propertyIsEnumerable; + +/***/ }, +/* 43 */ +/***/ function(module, exports, __webpack_require__) { + + // 7.2.2 IsArray(argument) + var cof = __webpack_require__(32); + module.exports = Array.isArray || function isArray(arg){ + return cof(arg) == 'Array'; + }; + +/***/ }, +/* 44 */ +/***/ function(module, exports, __webpack_require__) { + + // 19.1.2.2 / 15.2.3.5 Object.create(O [, Properties]) + var anObject = __webpack_require__(10) + , dPs = __webpack_require__(45) + , enumBugKeys = __webpack_require__(39) + , IE_PROTO = __webpack_require__(38)('IE_PROTO') + , Empty = function(){ /* empty */ } + , PROTOTYPE = 'prototype'; + + // Create object with fake `null` prototype: use iframe Object with cleared prototype + var createDict = function(){ + // Thrash, waste and sodomy: IE GC bug + var iframe = __webpack_require__(13)('iframe') + , i = enumBugKeys.length + , gt = '>' + , iframeDocument; + iframe.style.display = 'none'; + __webpack_require__(46).appendChild(iframe); + iframe.src = 'javascript:'; // eslint-disable-line no-script-url + // createDict = iframe.contentWindow.Object; + // html.removeChild(iframe); + iframeDocument = iframe.contentWindow.document; + iframeDocument.open(); + iframeDocument.write('