├── CHANGELOG.md ├── LICENSE.md ├── README.md ├── images ├── command_compile.png ├── command_execute.png ├── command_redirect.png └── command_runinwindow.png ├── keymaps └── atom-shell-commands.cson ├── lib ├── atom-shell-commands.js ├── config.js ├── sounds.js └── terminal.js ├── menus └── atom-shell-commands.json ├── node_modules ├── atom-message-panel │ ├── CHANGELOG.md │ ├── CONTRIBUTING.md │ ├── LICENSE.md │ ├── README.md │ ├── lib │ │ ├── LineMessageView.js │ │ ├── MessagePanelView.js │ │ ├── PlainMessageView.js │ │ ├── index.js │ │ └── utils.js │ ├── node_modules │ │ ├── atom-space-pen-views │ │ │ ├── Gruntfile.coffee │ │ │ ├── LICENSE.md │ │ │ ├── README.md │ │ │ ├── package.json │ │ │ ├── spec │ │ │ │ ├── select-list-view-spec.coffee │ │ │ │ └── spec-helper.coffee │ │ │ ├── src │ │ │ │ ├── main.coffee │ │ │ │ ├── scroll-view.coffee │ │ │ │ ├── select-list-view.coffee │ │ │ │ └── text-editor-view.coffee │ │ │ └── stylesheets │ │ │ │ └── select-list.less │ │ └── space-pen │ │ │ ├── LICENSE │ │ │ ├── README.md │ │ │ ├── api.json │ │ │ ├── lib │ │ │ └── space-pen.js │ │ │ ├── node_modules │ │ │ └── grim │ │ │ │ ├── LICENSE.md │ │ │ │ ├── README.md │ │ │ │ ├── lib │ │ │ │ ├── deprecation.js │ │ │ │ └── grim.js │ │ │ │ └── package.json │ │ │ ├── package.json │ │ │ └── vendor │ │ │ └── jquery.js │ └── package.json ├── emissary │ ├── LICENSE.md │ ├── README.md │ ├── lib │ │ ├── behavior.js │ │ ├── emissary.js │ │ ├── emitter.js │ │ ├── helpers.js │ │ ├── signal.js │ │ ├── subscriber.js │ │ └── subscription.js │ ├── node_modules │ │ ├── es6-weak-map │ │ │ ├── .lint │ │ │ ├── .npmignore │ │ │ ├── .travis.yml │ │ │ ├── CHANGES │ │ │ ├── LICENCE │ │ │ ├── README.md │ │ │ ├── implement.js │ │ │ ├── index.js │ │ │ ├── is-implemented.js │ │ │ ├── is-native-implemented.js │ │ │ ├── is-weak-map.js │ │ │ ├── node_modules │ │ │ │ ├── d │ │ │ │ │ ├── .lint │ │ │ │ │ ├── .npmignore │ │ │ │ │ ├── .travis.yml │ │ │ │ │ ├── CHANGES │ │ │ │ │ ├── LICENCE │ │ │ │ │ ├── README.md │ │ │ │ │ ├── auto-bind.js │ │ │ │ │ ├── index.js │ │ │ │ │ ├── lazy.js │ │ │ │ │ ├── package.json │ │ │ │ │ └── test │ │ │ │ │ │ ├── auto-bind.js │ │ │ │ │ │ ├── index.js │ │ │ │ │ │ └── lazy.js │ │ │ │ ├── es5-ext │ │ │ │ │ ├── .lint │ │ │ │ │ ├── .lintignore │ │ │ │ │ ├── .npmignore │ │ │ │ │ ├── .travis.yml │ │ │ │ │ ├── CHANGES │ │ │ │ │ ├── LICENSE │ │ │ │ │ ├── README.md │ │ │ │ │ ├── array │ │ │ │ │ │ ├── # │ │ │ │ │ │ │ ├── @@iterator │ │ │ │ │ │ │ │ ├── implement.js │ │ │ │ │ │ │ │ ├── index.js │ │ │ │ │ │ │ │ ├── is-implemented.js │ │ │ │ │ │ │ │ └── shim.js │ │ │ │ │ │ │ ├── _compare-by-length.js │ │ │ │ │ │ │ ├── binary-search.js │ │ │ │ │ │ │ ├── clear.js │ │ │ │ │ │ │ ├── compact.js │ │ │ │ │ │ │ ├── concat │ │ │ │ │ │ │ │ ├── implement.js │ │ │ │ │ │ │ │ ├── index.js │ │ │ │ │ │ │ │ ├── is-implemented.js │ │ │ │ │ │ │ │ └── shim.js │ │ │ │ │ │ │ ├── contains.js │ │ │ │ │ │ │ ├── copy-within │ │ │ │ │ │ │ │ ├── implement.js │ │ │ │ │ │ │ │ ├── index.js │ │ │ │ │ │ │ │ ├── is-implemented.js │ │ │ │ │ │ │ │ └── shim.js │ │ │ │ │ │ │ ├── diff.js │ │ │ │ │ │ │ ├── e-index-of.js │ │ │ │ │ │ │ ├── e-last-index-of.js │ │ │ │ │ │ │ ├── entries │ │ │ │ │ │ │ │ ├── implement.js │ │ │ │ │ │ │ │ ├── index.js │ │ │ │ │ │ │ │ ├── is-implemented.js │ │ │ │ │ │ │ │ └── shim.js │ │ │ │ │ │ │ ├── exclusion.js │ │ │ │ │ │ │ ├── fill │ │ │ │ │ │ │ │ ├── implement.js │ │ │ │ │ │ │ │ ├── index.js │ │ │ │ │ │ │ │ ├── is-implemented.js │ │ │ │ │ │ │ │ └── shim.js │ │ │ │ │ │ │ ├── filter │ │ │ │ │ │ │ │ ├── implement.js │ │ │ │ │ │ │ │ ├── index.js │ │ │ │ │ │ │ │ ├── is-implemented.js │ │ │ │ │ │ │ │ └── shim.js │ │ │ │ │ │ │ ├── find-index │ │ │ │ │ │ │ │ ├── implement.js │ │ │ │ │ │ │ │ ├── index.js │ │ │ │ │ │ │ │ ├── is-implemented.js │ │ │ │ │ │ │ │ └── shim.js │ │ │ │ │ │ │ ├── find │ │ │ │ │ │ │ │ ├── implement.js │ │ │ │ │ │ │ │ ├── index.js │ │ │ │ │ │ │ │ ├── is-implemented.js │ │ │ │ │ │ │ │ └── shim.js │ │ │ │ │ │ │ ├── first-index.js │ │ │ │ │ │ │ ├── first.js │ │ │ │ │ │ │ ├── flatten.js │ │ │ │ │ │ │ ├── for-each-right.js │ │ │ │ │ │ │ ├── group.js │ │ │ │ │ │ │ ├── index.js │ │ │ │ │ │ │ ├── indexes-of.js │ │ │ │ │ │ │ ├── intersection.js │ │ │ │ │ │ │ ├── is-copy.js │ │ │ │ │ │ │ ├── is-uniq.js │ │ │ │ │ │ │ ├── keys │ │ │ │ │ │ │ │ ├── implement.js │ │ │ │ │ │ │ │ ├── index.js │ │ │ │ │ │ │ │ ├── is-implemented.js │ │ │ │ │ │ │ │ └── shim.js │ │ │ │ │ │ │ ├── last-index.js │ │ │ │ │ │ │ ├── last.js │ │ │ │ │ │ │ ├── map │ │ │ │ │ │ │ │ ├── implement.js │ │ │ │ │ │ │ │ ├── index.js │ │ │ │ │ │ │ │ ├── is-implemented.js │ │ │ │ │ │ │ │ └── shim.js │ │ │ │ │ │ │ ├── remove.js │ │ │ │ │ │ │ ├── separate.js │ │ │ │ │ │ │ ├── slice │ │ │ │ │ │ │ │ ├── implement.js │ │ │ │ │ │ │ │ ├── index.js │ │ │ │ │ │ │ │ ├── is-implemented.js │ │ │ │ │ │ │ │ └── shim.js │ │ │ │ │ │ │ ├── some-right.js │ │ │ │ │ │ │ ├── splice │ │ │ │ │ │ │ │ ├── implement.js │ │ │ │ │ │ │ │ ├── index.js │ │ │ │ │ │ │ │ ├── is-implemented.js │ │ │ │ │ │ │ │ └── shim.js │ │ │ │ │ │ │ ├── uniq.js │ │ │ │ │ │ │ └── values │ │ │ │ │ │ │ │ ├── implement.js │ │ │ │ │ │ │ │ ├── index.js │ │ │ │ │ │ │ │ ├── is-implemented.js │ │ │ │ │ │ │ │ └── shim.js │ │ │ │ │ │ ├── _is-extensible.js │ │ │ │ │ │ ├── _sub-array-dummy-safe.js │ │ │ │ │ │ ├── _sub-array-dummy.js │ │ │ │ │ │ ├── from │ │ │ │ │ │ │ ├── implement.js │ │ │ │ │ │ │ ├── index.js │ │ │ │ │ │ │ ├── is-implemented.js │ │ │ │ │ │ │ └── shim.js │ │ │ │ │ │ ├── generate.js │ │ │ │ │ │ ├── index.js │ │ │ │ │ │ ├── is-plain-array.js │ │ │ │ │ │ ├── of │ │ │ │ │ │ │ ├── implement.js │ │ │ │ │ │ │ ├── index.js │ │ │ │ │ │ │ ├── is-implemented.js │ │ │ │ │ │ │ └── shim.js │ │ │ │ │ │ ├── to-array.js │ │ │ │ │ │ └── valid-array.js │ │ │ │ │ ├── boolean │ │ │ │ │ │ ├── index.js │ │ │ │ │ │ └── is-boolean.js │ │ │ │ │ ├── date │ │ │ │ │ │ ├── # │ │ │ │ │ │ │ ├── copy.js │ │ │ │ │ │ │ ├── days-in-month.js │ │ │ │ │ │ │ ├── floor-day.js │ │ │ │ │ │ │ ├── floor-month.js │ │ │ │ │ │ │ ├── floor-year.js │ │ │ │ │ │ │ ├── format.js │ │ │ │ │ │ │ └── index.js │ │ │ │ │ │ ├── index.js │ │ │ │ │ │ ├── is-date.js │ │ │ │ │ │ └── valid-date.js │ │ │ │ │ ├── error │ │ │ │ │ │ ├── # │ │ │ │ │ │ │ ├── index.js │ │ │ │ │ │ │ └── throw.js │ │ │ │ │ │ ├── custom.js │ │ │ │ │ │ ├── index.js │ │ │ │ │ │ ├── is-error.js │ │ │ │ │ │ └── valid-error.js │ │ │ │ │ ├── function │ │ │ │ │ │ ├── # │ │ │ │ │ │ │ ├── compose.js │ │ │ │ │ │ │ ├── copy.js │ │ │ │ │ │ │ ├── curry.js │ │ │ │ │ │ │ ├── index.js │ │ │ │ │ │ │ ├── lock.js │ │ │ │ │ │ │ ├── not.js │ │ │ │ │ │ │ ├── partial.js │ │ │ │ │ │ │ ├── spread.js │ │ │ │ │ │ │ └── to-string-tokens.js │ │ │ │ │ │ ├── _define-length.js │ │ │ │ │ │ ├── constant.js │ │ │ │ │ │ ├── identity.js │ │ │ │ │ │ ├── index.js │ │ │ │ │ │ ├── invoke.js │ │ │ │ │ │ ├── is-arguments.js │ │ │ │ │ │ ├── is-function.js │ │ │ │ │ │ ├── noop.js │ │ │ │ │ │ ├── pluck.js │ │ │ │ │ │ └── valid-function.js │ │ │ │ │ ├── global.js │ │ │ │ │ ├── index.js │ │ │ │ │ ├── iterable │ │ │ │ │ │ ├── for-each.js │ │ │ │ │ │ ├── index.js │ │ │ │ │ │ ├── is.js │ │ │ │ │ │ ├── validate-object.js │ │ │ │ │ │ └── validate.js │ │ │ │ │ ├── math │ │ │ │ │ │ ├── _pack-ieee754.js │ │ │ │ │ │ ├── _unpack-ieee754.js │ │ │ │ │ │ ├── acosh │ │ │ │ │ │ │ ├── implement.js │ │ │ │ │ │ │ ├── index.js │ │ │ │ │ │ │ ├── is-implemented.js │ │ │ │ │ │ │ └── shim.js │ │ │ │ │ │ ├── asinh │ │ │ │ │ │ │ ├── implement.js │ │ │ │ │ │ │ ├── index.js │ │ │ │ │ │ │ ├── is-implemented.js │ │ │ │ │ │ │ └── shim.js │ │ │ │ │ │ ├── atanh │ │ │ │ │ │ │ ├── implement.js │ │ │ │ │ │ │ ├── index.js │ │ │ │ │ │ │ ├── is-implemented.js │ │ │ │ │ │ │ └── shim.js │ │ │ │ │ │ ├── cbrt │ │ │ │ │ │ │ ├── implement.js │ │ │ │ │ │ │ ├── index.js │ │ │ │ │ │ │ ├── is-implemented.js │ │ │ │ │ │ │ └── shim.js │ │ │ │ │ │ ├── clz32 │ │ │ │ │ │ │ ├── implement.js │ │ │ │ │ │ │ ├── index.js │ │ │ │ │ │ │ ├── is-implemented.js │ │ │ │ │ │ │ └── shim.js │ │ │ │ │ │ ├── cosh │ │ │ │ │ │ │ ├── implement.js │ │ │ │ │ │ │ ├── index.js │ │ │ │ │ │ │ ├── is-implemented.js │ │ │ │ │ │ │ └── shim.js │ │ │ │ │ │ ├── expm1 │ │ │ │ │ │ │ ├── implement.js │ │ │ │ │ │ │ ├── index.js │ │ │ │ │ │ │ ├── is-implemented.js │ │ │ │ │ │ │ └── shim.js │ │ │ │ │ │ ├── fround │ │ │ │ │ │ │ ├── implement.js │ │ │ │ │ │ │ ├── index.js │ │ │ │ │ │ │ ├── is-implemented.js │ │ │ │ │ │ │ └── shim.js │ │ │ │ │ │ ├── hypot │ │ │ │ │ │ │ ├── implement.js │ │ │ │ │ │ │ ├── index.js │ │ │ │ │ │ │ ├── is-implemented.js │ │ │ │ │ │ │ └── shim.js │ │ │ │ │ │ ├── imul │ │ │ │ │ │ │ ├── implement.js │ │ │ │ │ │ │ ├── index.js │ │ │ │ │ │ │ ├── is-implemented.js │ │ │ │ │ │ │ └── shim.js │ │ │ │ │ │ ├── index.js │ │ │ │ │ │ ├── log10 │ │ │ │ │ │ │ ├── implement.js │ │ │ │ │ │ │ ├── index.js │ │ │ │ │ │ │ ├── is-implemented.js │ │ │ │ │ │ │ └── shim.js │ │ │ │ │ │ ├── log1p │ │ │ │ │ │ │ ├── implement.js │ │ │ │ │ │ │ ├── index.js │ │ │ │ │ │ │ ├── is-implemented.js │ │ │ │ │ │ │ └── shim.js │ │ │ │ │ │ ├── log2 │ │ │ │ │ │ │ ├── implement.js │ │ │ │ │ │ │ ├── index.js │ │ │ │ │ │ │ ├── is-implemented.js │ │ │ │ │ │ │ └── shim.js │ │ │ │ │ │ ├── sign │ │ │ │ │ │ │ ├── implement.js │ │ │ │ │ │ │ ├── index.js │ │ │ │ │ │ │ ├── is-implemented.js │ │ │ │ │ │ │ └── shim.js │ │ │ │ │ │ ├── sinh │ │ │ │ │ │ │ ├── implement.js │ │ │ │ │ │ │ ├── index.js │ │ │ │ │ │ │ ├── is-implemented.js │ │ │ │ │ │ │ └── shim.js │ │ │ │ │ │ ├── tanh │ │ │ │ │ │ │ ├── implement.js │ │ │ │ │ │ │ ├── index.js │ │ │ │ │ │ │ ├── is-implemented.js │ │ │ │ │ │ │ └── shim.js │ │ │ │ │ │ └── trunc │ │ │ │ │ │ │ ├── implement.js │ │ │ │ │ │ │ ├── index.js │ │ │ │ │ │ │ ├── is-implemented.js │ │ │ │ │ │ │ └── shim.js │ │ │ │ │ ├── node_modules │ │ │ │ │ │ ├── es6-iterator │ │ │ │ │ │ │ ├── # │ │ │ │ │ │ │ │ └── chain.js │ │ │ │ │ │ │ ├── .lint │ │ │ │ │ │ │ ├── .npmignore │ │ │ │ │ │ │ ├── .travis.yml │ │ │ │ │ │ │ ├── CHANGES │ │ │ │ │ │ │ ├── LICENSE │ │ │ │ │ │ │ ├── README.md │ │ │ │ │ │ │ ├── array.js │ │ │ │ │ │ │ ├── for-of.js │ │ │ │ │ │ │ ├── get.js │ │ │ │ │ │ │ ├── index.js │ │ │ │ │ │ │ ├── is-iterable.js │ │ │ │ │ │ │ ├── package.json │ │ │ │ │ │ │ ├── string.js │ │ │ │ │ │ │ ├── test │ │ │ │ │ │ │ │ ├── # │ │ │ │ │ │ │ │ │ └── chain.js │ │ │ │ │ │ │ │ ├── array.js │ │ │ │ │ │ │ │ ├── for-of.js │ │ │ │ │ │ │ │ ├── get.js │ │ │ │ │ │ │ │ ├── index.js │ │ │ │ │ │ │ │ ├── is-iterable.js │ │ │ │ │ │ │ │ ├── string.js │ │ │ │ │ │ │ │ └── valid-iterable.js │ │ │ │ │ │ │ └── valid-iterable.js │ │ │ │ │ │ └── es6-symbol │ │ │ │ │ │ │ ├── .lint │ │ │ │ │ │ │ ├── .npmignore │ │ │ │ │ │ │ ├── .travis.yml │ │ │ │ │ │ │ ├── CHANGES │ │ │ │ │ │ │ ├── LICENSE │ │ │ │ │ │ │ ├── README.md │ │ │ │ │ │ │ ├── implement.js │ │ │ │ │ │ │ ├── index.js │ │ │ │ │ │ │ ├── is-implemented.js │ │ │ │ │ │ │ ├── is-native-implemented.js │ │ │ │ │ │ │ ├── is-symbol.js │ │ │ │ │ │ │ ├── package.json │ │ │ │ │ │ │ ├── polyfill.js │ │ │ │ │ │ │ ├── test │ │ │ │ │ │ │ ├── implement.js │ │ │ │ │ │ │ ├── index.js │ │ │ │ │ │ │ ├── is-implemented.js │ │ │ │ │ │ │ ├── is-native-implemented.js │ │ │ │ │ │ │ ├── is-symbol.js │ │ │ │ │ │ │ ├── polyfill.js │ │ │ │ │ │ │ └── validate-symbol.js │ │ │ │ │ │ │ └── validate-symbol.js │ │ │ │ │ ├── number │ │ │ │ │ │ ├── # │ │ │ │ │ │ │ ├── index.js │ │ │ │ │ │ │ └── pad.js │ │ │ │ │ │ ├── epsilon │ │ │ │ │ │ │ ├── implement.js │ │ │ │ │ │ │ ├── index.js │ │ │ │ │ │ │ └── is-implemented.js │ │ │ │ │ │ ├── index.js │ │ │ │ │ │ ├── is-finite │ │ │ │ │ │ │ ├── implement.js │ │ │ │ │ │ │ ├── index.js │ │ │ │ │ │ │ ├── is-implemented.js │ │ │ │ │ │ │ └── shim.js │ │ │ │ │ │ ├── is-integer │ │ │ │ │ │ │ ├── implement.js │ │ │ │ │ │ │ ├── index.js │ │ │ │ │ │ │ ├── is-implemented.js │ │ │ │ │ │ │ └── shim.js │ │ │ │ │ │ ├── is-nan │ │ │ │ │ │ │ ├── implement.js │ │ │ │ │ │ │ ├── index.js │ │ │ │ │ │ │ ├── is-implemented.js │ │ │ │ │ │ │ └── shim.js │ │ │ │ │ │ ├── is-natural.js │ │ │ │ │ │ ├── is-number.js │ │ │ │ │ │ ├── is-safe-integer │ │ │ │ │ │ │ ├── implement.js │ │ │ │ │ │ │ ├── index.js │ │ │ │ │ │ │ ├── is-implemented.js │ │ │ │ │ │ │ └── shim.js │ │ │ │ │ │ ├── max-safe-integer │ │ │ │ │ │ │ ├── implement.js │ │ │ │ │ │ │ ├── index.js │ │ │ │ │ │ │ └── is-implemented.js │ │ │ │ │ │ ├── min-safe-integer │ │ │ │ │ │ │ ├── implement.js │ │ │ │ │ │ │ ├── index.js │ │ │ │ │ │ │ └── is-implemented.js │ │ │ │ │ │ ├── to-integer.js │ │ │ │ │ │ ├── to-pos-integer.js │ │ │ │ │ │ └── to-uint32.js │ │ │ │ │ ├── object │ │ │ │ │ │ ├── _iterate.js │ │ │ │ │ │ ├── assign │ │ │ │ │ │ │ ├── implement.js │ │ │ │ │ │ │ ├── index.js │ │ │ │ │ │ │ ├── is-implemented.js │ │ │ │ │ │ │ └── shim.js │ │ │ │ │ │ ├── clear.js │ │ │ │ │ │ ├── compact.js │ │ │ │ │ │ ├── compare.js │ │ │ │ │ │ ├── copy-deep.js │ │ │ │ │ │ ├── copy.js │ │ │ │ │ │ ├── count.js │ │ │ │ │ │ ├── create.js │ │ │ │ │ │ ├── ensure-natural-number-value.js │ │ │ │ │ │ ├── ensure-natural-number.js │ │ │ │ │ │ ├── eq.js │ │ │ │ │ │ ├── every.js │ │ │ │ │ │ ├── filter.js │ │ │ │ │ │ ├── find-key.js │ │ │ │ │ │ ├── find.js │ │ │ │ │ │ ├── first-key.js │ │ │ │ │ │ ├── flatten.js │ │ │ │ │ │ ├── for-each.js │ │ │ │ │ │ ├── get-property-names.js │ │ │ │ │ │ ├── index.js │ │ │ │ │ │ ├── is-array-like.js │ │ │ │ │ │ ├── is-callable.js │ │ │ │ │ │ ├── is-copy-deep.js │ │ │ │ │ │ ├── is-copy.js │ │ │ │ │ │ ├── is-empty.js │ │ │ │ │ │ ├── is-number-value.js │ │ │ │ │ │ ├── is-object.js │ │ │ │ │ │ ├── is-plain-object.js │ │ │ │ │ │ ├── is.js │ │ │ │ │ │ ├── key-of.js │ │ │ │ │ │ ├── keys │ │ │ │ │ │ │ ├── implement.js │ │ │ │ │ │ │ ├── index.js │ │ │ │ │ │ │ ├── is-implemented.js │ │ │ │ │ │ │ └── shim.js │ │ │ │ │ │ ├── map-keys.js │ │ │ │ │ │ ├── map.js │ │ │ │ │ │ ├── mixin-prototypes.js │ │ │ │ │ │ ├── mixin.js │ │ │ │ │ │ ├── normalize-options.js │ │ │ │ │ │ ├── primitive-set.js │ │ │ │ │ │ ├── safe-traverse.js │ │ │ │ │ │ ├── serialize.js │ │ │ │ │ │ ├── set-prototype-of │ │ │ │ │ │ │ ├── implement.js │ │ │ │ │ │ │ ├── index.js │ │ │ │ │ │ │ ├── is-implemented.js │ │ │ │ │ │ │ └── shim.js │ │ │ │ │ │ ├── some.js │ │ │ │ │ │ ├── to-array.js │ │ │ │ │ │ ├── unserialize.js │ │ │ │ │ │ ├── valid-callable.js │ │ │ │ │ │ ├── valid-object.js │ │ │ │ │ │ ├── valid-value.js │ │ │ │ │ │ ├── validate-array-like-object.js │ │ │ │ │ │ ├── validate-array-like.js │ │ │ │ │ │ ├── validate-stringifiable-value.js │ │ │ │ │ │ └── validate-stringifiable.js │ │ │ │ │ ├── package.json │ │ │ │ │ ├── reg-exp │ │ │ │ │ │ ├── # │ │ │ │ │ │ │ ├── index.js │ │ │ │ │ │ │ ├── is-sticky.js │ │ │ │ │ │ │ ├── is-unicode.js │ │ │ │ │ │ │ ├── match │ │ │ │ │ │ │ │ ├── implement.js │ │ │ │ │ │ │ │ ├── index.js │ │ │ │ │ │ │ │ ├── is-implemented.js │ │ │ │ │ │ │ │ └── shim.js │ │ │ │ │ │ │ ├── replace │ │ │ │ │ │ │ │ ├── implement.js │ │ │ │ │ │ │ │ ├── index.js │ │ │ │ │ │ │ │ ├── is-implemented.js │ │ │ │ │ │ │ │ └── shim.js │ │ │ │ │ │ │ ├── search │ │ │ │ │ │ │ │ ├── implement.js │ │ │ │ │ │ │ │ ├── index.js │ │ │ │ │ │ │ │ ├── is-implemented.js │ │ │ │ │ │ │ │ └── shim.js │ │ │ │ │ │ │ ├── split │ │ │ │ │ │ │ │ ├── implement.js │ │ │ │ │ │ │ │ ├── index.js │ │ │ │ │ │ │ │ ├── is-implemented.js │ │ │ │ │ │ │ │ └── shim.js │ │ │ │ │ │ │ ├── sticky │ │ │ │ │ │ │ │ ├── implement.js │ │ │ │ │ │ │ │ └── is-implemented.js │ │ │ │ │ │ │ └── unicode │ │ │ │ │ │ │ │ ├── implement.js │ │ │ │ │ │ │ │ └── is-implemented.js │ │ │ │ │ │ ├── escape.js │ │ │ │ │ │ ├── index.js │ │ │ │ │ │ ├── is-reg-exp.js │ │ │ │ │ │ └── valid-reg-exp.js │ │ │ │ │ ├── string │ │ │ │ │ │ ├── # │ │ │ │ │ │ │ ├── @@iterator │ │ │ │ │ │ │ │ ├── implement.js │ │ │ │ │ │ │ │ ├── index.js │ │ │ │ │ │ │ │ ├── is-implemented.js │ │ │ │ │ │ │ │ └── shim.js │ │ │ │ │ │ │ ├── at.js │ │ │ │ │ │ │ ├── camel-to-hyphen.js │ │ │ │ │ │ │ ├── capitalize.js │ │ │ │ │ │ │ ├── case-insensitive-compare.js │ │ │ │ │ │ │ ├── code-point-at │ │ │ │ │ │ │ │ ├── implement.js │ │ │ │ │ │ │ │ ├── index.js │ │ │ │ │ │ │ │ ├── is-implemented.js │ │ │ │ │ │ │ │ └── shim.js │ │ │ │ │ │ │ ├── contains │ │ │ │ │ │ │ │ ├── implement.js │ │ │ │ │ │ │ │ ├── index.js │ │ │ │ │ │ │ │ ├── is-implemented.js │ │ │ │ │ │ │ │ └── shim.js │ │ │ │ │ │ │ ├── ends-with │ │ │ │ │ │ │ │ ├── implement.js │ │ │ │ │ │ │ │ ├── index.js │ │ │ │ │ │ │ │ ├── is-implemented.js │ │ │ │ │ │ │ │ └── shim.js │ │ │ │ │ │ │ ├── hyphen-to-camel.js │ │ │ │ │ │ │ ├── indent.js │ │ │ │ │ │ │ ├── index.js │ │ │ │ │ │ │ ├── last.js │ │ │ │ │ │ │ ├── normalize │ │ │ │ │ │ │ │ ├── _data.js │ │ │ │ │ │ │ │ ├── implement.js │ │ │ │ │ │ │ │ ├── index.js │ │ │ │ │ │ │ │ ├── is-implemented.js │ │ │ │ │ │ │ │ └── shim.js │ │ │ │ │ │ │ ├── pad.js │ │ │ │ │ │ │ ├── plain-replace-all.js │ │ │ │ │ │ │ ├── plain-replace.js │ │ │ │ │ │ │ ├── repeat │ │ │ │ │ │ │ │ ├── implement.js │ │ │ │ │ │ │ │ ├── index.js │ │ │ │ │ │ │ │ ├── is-implemented.js │ │ │ │ │ │ │ │ └── shim.js │ │ │ │ │ │ │ ├── starts-with │ │ │ │ │ │ │ │ ├── implement.js │ │ │ │ │ │ │ │ ├── index.js │ │ │ │ │ │ │ │ ├── is-implemented.js │ │ │ │ │ │ │ │ └── shim.js │ │ │ │ │ │ │ └── uncapitalize.js │ │ │ │ │ │ ├── format-method.js │ │ │ │ │ │ ├── from-code-point │ │ │ │ │ │ │ ├── implement.js │ │ │ │ │ │ │ ├── index.js │ │ │ │ │ │ │ ├── is-implemented.js │ │ │ │ │ │ │ └── shim.js │ │ │ │ │ │ ├── index.js │ │ │ │ │ │ ├── is-string.js │ │ │ │ │ │ ├── random-uniq.js │ │ │ │ │ │ └── raw │ │ │ │ │ │ │ ├── implement.js │ │ │ │ │ │ │ ├── index.js │ │ │ │ │ │ │ ├── is-implemented.js │ │ │ │ │ │ │ └── shim.js │ │ │ │ │ └── test │ │ │ │ │ │ ├── __tad.js │ │ │ │ │ │ ├── array │ │ │ │ │ │ ├── # │ │ │ │ │ │ │ ├── @@iterator │ │ │ │ │ │ │ │ ├── implement.js │ │ │ │ │ │ │ │ ├── index.js │ │ │ │ │ │ │ │ ├── is-implemented.js │ │ │ │ │ │ │ │ └── shim.js │ │ │ │ │ │ │ ├── _compare-by-length.js │ │ │ │ │ │ │ ├── binary-search.js │ │ │ │ │ │ │ ├── clear.js │ │ │ │ │ │ │ ├── compact.js │ │ │ │ │ │ │ ├── concat │ │ │ │ │ │ │ │ ├── implement.js │ │ │ │ │ │ │ │ ├── index.js │ │ │ │ │ │ │ │ ├── is-implemented.js │ │ │ │ │ │ │ │ └── shim.js │ │ │ │ │ │ │ ├── contains.js │ │ │ │ │ │ │ ├── copy-within │ │ │ │ │ │ │ │ ├── implement.js │ │ │ │ │ │ │ │ ├── index.js │ │ │ │ │ │ │ │ ├── is-implemented.js │ │ │ │ │ │ │ │ └── shim.js │ │ │ │ │ │ │ ├── diff.js │ │ │ │ │ │ │ ├── e-index-of.js │ │ │ │ │ │ │ ├── e-last-index-of.js │ │ │ │ │ │ │ ├── entries │ │ │ │ │ │ │ │ ├── implement.js │ │ │ │ │ │ │ │ ├── index.js │ │ │ │ │ │ │ │ ├── is-implemented.js │ │ │ │ │ │ │ │ └── shim.js │ │ │ │ │ │ │ ├── exclusion.js │ │ │ │ │ │ │ ├── fill │ │ │ │ │ │ │ │ ├── implement.js │ │ │ │ │ │ │ │ ├── index.js │ │ │ │ │ │ │ │ ├── is-implemented.js │ │ │ │ │ │ │ │ └── shim.js │ │ │ │ │ │ │ ├── filter │ │ │ │ │ │ │ │ ├── implement.js │ │ │ │ │ │ │ │ ├── index.js │ │ │ │ │ │ │ │ ├── is-implemented.js │ │ │ │ │ │ │ │ └── shim.js │ │ │ │ │ │ │ ├── find-index │ │ │ │ │ │ │ │ ├── implement.js │ │ │ │ │ │ │ │ ├── index.js │ │ │ │ │ │ │ │ ├── is-implemented.js │ │ │ │ │ │ │ │ └── shim.js │ │ │ │ │ │ │ ├── find │ │ │ │ │ │ │ │ ├── implement.js │ │ │ │ │ │ │ │ ├── index.js │ │ │ │ │ │ │ │ ├── is-implemented.js │ │ │ │ │ │ │ │ └── shim.js │ │ │ │ │ │ │ ├── first-index.js │ │ │ │ │ │ │ ├── first.js │ │ │ │ │ │ │ ├── flatten.js │ │ │ │ │ │ │ ├── for-each-right.js │ │ │ │ │ │ │ ├── group.js │ │ │ │ │ │ │ ├── indexes-of.js │ │ │ │ │ │ │ ├── intersection.js │ │ │ │ │ │ │ ├── is-copy.js │ │ │ │ │ │ │ ├── is-uniq.js │ │ │ │ │ │ │ ├── keys │ │ │ │ │ │ │ │ ├── implement.js │ │ │ │ │ │ │ │ ├── index.js │ │ │ │ │ │ │ │ ├── is-implemented.js │ │ │ │ │ │ │ │ └── shim.js │ │ │ │ │ │ │ ├── last-index.js │ │ │ │ │ │ │ ├── last.js │ │ │ │ │ │ │ ├── map │ │ │ │ │ │ │ │ ├── implement.js │ │ │ │ │ │ │ │ ├── index.js │ │ │ │ │ │ │ │ ├── is-implemented.js │ │ │ │ │ │ │ │ └── shim.js │ │ │ │ │ │ │ ├── remove.js │ │ │ │ │ │ │ ├── separate.js │ │ │ │ │ │ │ ├── slice │ │ │ │ │ │ │ │ ├── implement.js │ │ │ │ │ │ │ │ ├── index.js │ │ │ │ │ │ │ │ ├── is-implemented.js │ │ │ │ │ │ │ │ └── shim.js │ │ │ │ │ │ │ ├── some-right.js │ │ │ │ │ │ │ ├── splice │ │ │ │ │ │ │ │ ├── implement.js │ │ │ │ │ │ │ │ ├── index.js │ │ │ │ │ │ │ │ ├── is-implemented.js │ │ │ │ │ │ │ │ └── shim.js │ │ │ │ │ │ │ ├── uniq.js │ │ │ │ │ │ │ └── values │ │ │ │ │ │ │ │ ├── implement.js │ │ │ │ │ │ │ │ ├── index.js │ │ │ │ │ │ │ │ ├── is-implemented.js │ │ │ │ │ │ │ │ └── shim.js │ │ │ │ │ │ ├── __scopes.js │ │ │ │ │ │ ├── _is-extensible.js │ │ │ │ │ │ ├── _sub-array-dummy-safe.js │ │ │ │ │ │ ├── _sub-array-dummy.js │ │ │ │ │ │ ├── from │ │ │ │ │ │ │ ├── implement.js │ │ │ │ │ │ │ ├── index.js │ │ │ │ │ │ │ ├── is-implemented.js │ │ │ │ │ │ │ └── shim.js │ │ │ │ │ │ ├── generate.js │ │ │ │ │ │ ├── is-plain-array.js │ │ │ │ │ │ ├── of │ │ │ │ │ │ │ ├── implement.js │ │ │ │ │ │ │ ├── index.js │ │ │ │ │ │ │ ├── is-implemented.js │ │ │ │ │ │ │ └── shim.js │ │ │ │ │ │ ├── to-array.js │ │ │ │ │ │ └── valid-array.js │ │ │ │ │ │ ├── boolean │ │ │ │ │ │ └── is-boolean.js │ │ │ │ │ │ ├── date │ │ │ │ │ │ ├── # │ │ │ │ │ │ │ ├── copy.js │ │ │ │ │ │ │ ├── days-in-month.js │ │ │ │ │ │ │ ├── floor-day.js │ │ │ │ │ │ │ ├── floor-month.js │ │ │ │ │ │ │ ├── floor-year.js │ │ │ │ │ │ │ └── format.js │ │ │ │ │ │ ├── is-date.js │ │ │ │ │ │ └── valid-date.js │ │ │ │ │ │ ├── error │ │ │ │ │ │ ├── # │ │ │ │ │ │ │ └── throw.js │ │ │ │ │ │ ├── custom.js │ │ │ │ │ │ ├── is-error.js │ │ │ │ │ │ └── valid-error.js │ │ │ │ │ │ ├── function │ │ │ │ │ │ ├── # │ │ │ │ │ │ │ ├── compose.js │ │ │ │ │ │ │ ├── copy.js │ │ │ │ │ │ │ ├── curry.js │ │ │ │ │ │ │ ├── lock.js │ │ │ │ │ │ │ ├── not.js │ │ │ │ │ │ │ ├── partial.js │ │ │ │ │ │ │ ├── spread.js │ │ │ │ │ │ │ └── to-string-tokens.js │ │ │ │ │ │ ├── _define-length.js │ │ │ │ │ │ ├── constant.js │ │ │ │ │ │ ├── identity.js │ │ │ │ │ │ ├── invoke.js │ │ │ │ │ │ ├── is-arguments.js │ │ │ │ │ │ ├── is-function.js │ │ │ │ │ │ ├── noop.js │ │ │ │ │ │ ├── pluck.js │ │ │ │ │ │ └── valid-function.js │ │ │ │ │ │ ├── global.js │ │ │ │ │ │ ├── iterable │ │ │ │ │ │ ├── for-each.js │ │ │ │ │ │ ├── is.js │ │ │ │ │ │ ├── validate-object.js │ │ │ │ │ │ └── validate.js │ │ │ │ │ │ ├── math │ │ │ │ │ │ ├── _pack-ieee754.js │ │ │ │ │ │ ├── _unpack-ieee754.js │ │ │ │ │ │ ├── acosh │ │ │ │ │ │ │ ├── implement.js │ │ │ │ │ │ │ ├── index.js │ │ │ │ │ │ │ ├── is-implemented.js │ │ │ │ │ │ │ └── shim.js │ │ │ │ │ │ ├── asinh │ │ │ │ │ │ │ ├── implement.js │ │ │ │ │ │ │ ├── index.js │ │ │ │ │ │ │ ├── is-implemented.js │ │ │ │ │ │ │ └── shim.js │ │ │ │ │ │ ├── atanh │ │ │ │ │ │ │ ├── implement.js │ │ │ │ │ │ │ ├── index.js │ │ │ │ │ │ │ ├── is-implemented.js │ │ │ │ │ │ │ └── shim.js │ │ │ │ │ │ ├── cbrt │ │ │ │ │ │ │ ├── implement.js │ │ │ │ │ │ │ ├── index.js │ │ │ │ │ │ │ ├── is-implemented.js │ │ │ │ │ │ │ └── shim.js │ │ │ │ │ │ ├── clz32 │ │ │ │ │ │ │ ├── implement.js │ │ │ │ │ │ │ ├── index.js │ │ │ │ │ │ │ ├── is-implemented.js │ │ │ │ │ │ │ └── shim.js │ │ │ │ │ │ ├── cosh │ │ │ │ │ │ │ ├── implement.js │ │ │ │ │ │ │ ├── index.js │ │ │ │ │ │ │ ├── is-implemented.js │ │ │ │ │ │ │ └── shim.js │ │ │ │ │ │ ├── expm1 │ │ │ │ │ │ │ ├── implement.js │ │ │ │ │ │ │ ├── index.js │ │ │ │ │ │ │ ├── is-implemented.js │ │ │ │ │ │ │ └── shim.js │ │ │ │ │ │ ├── fround │ │ │ │ │ │ │ ├── implement.js │ │ │ │ │ │ │ ├── index.js │ │ │ │ │ │ │ ├── is-implemented.js │ │ │ │ │ │ │ └── shim.js │ │ │ │ │ │ ├── hypot │ │ │ │ │ │ │ ├── implement.js │ │ │ │ │ │ │ ├── index.js │ │ │ │ │ │ │ ├── is-implemented.js │ │ │ │ │ │ │ └── shim.js │ │ │ │ │ │ ├── imul │ │ │ │ │ │ │ ├── implement.js │ │ │ │ │ │ │ ├── index.js │ │ │ │ │ │ │ ├── is-implemented.js │ │ │ │ │ │ │ └── shim.js │ │ │ │ │ │ ├── log10 │ │ │ │ │ │ │ ├── implement.js │ │ │ │ │ │ │ ├── index.js │ │ │ │ │ │ │ ├── is-implemented.js │ │ │ │ │ │ │ └── shim.js │ │ │ │ │ │ ├── log1p │ │ │ │ │ │ │ ├── implement.js │ │ │ │ │ │ │ ├── index.js │ │ │ │ │ │ │ ├── is-implemented.js │ │ │ │ │ │ │ └── shim.js │ │ │ │ │ │ ├── log2 │ │ │ │ │ │ │ ├── implement.js │ │ │ │ │ │ │ ├── index.js │ │ │ │ │ │ │ ├── is-implemented.js │ │ │ │ │ │ │ └── shim.js │ │ │ │ │ │ ├── sign │ │ │ │ │ │ │ ├── implement.js │ │ │ │ │ │ │ ├── index.js │ │ │ │ │ │ │ ├── is-implemented.js │ │ │ │ │ │ │ └── shim.js │ │ │ │ │ │ ├── sinh │ │ │ │ │ │ │ ├── implement.js │ │ │ │ │ │ │ ├── index.js │ │ │ │ │ │ │ ├── is-implemented.js │ │ │ │ │ │ │ └── shim.js │ │ │ │ │ │ ├── tanh │ │ │ │ │ │ │ ├── implement.js │ │ │ │ │ │ │ ├── index.js │ │ │ │ │ │ │ ├── is-implemented.js │ │ │ │ │ │ │ └── shim.js │ │ │ │ │ │ └── trunc │ │ │ │ │ │ │ ├── implement.js │ │ │ │ │ │ │ ├── index.js │ │ │ │ │ │ │ ├── is-implemented.js │ │ │ │ │ │ │ └── shim.js │ │ │ │ │ │ ├── number │ │ │ │ │ │ ├── # │ │ │ │ │ │ │ └── pad.js │ │ │ │ │ │ ├── epsilon │ │ │ │ │ │ │ ├── implement.js │ │ │ │ │ │ │ ├── index.js │ │ │ │ │ │ │ └── is-implemented.js │ │ │ │ │ │ ├── is-finite │ │ │ │ │ │ │ ├── implement.js │ │ │ │ │ │ │ ├── index.js │ │ │ │ │ │ │ ├── is-implemented.js │ │ │ │ │ │ │ └── shim.js │ │ │ │ │ │ ├── is-integer │ │ │ │ │ │ │ ├── implement.js │ │ │ │ │ │ │ ├── index.js │ │ │ │ │ │ │ ├── is-implemented.js │ │ │ │ │ │ │ └── shim.js │ │ │ │ │ │ ├── is-nan │ │ │ │ │ │ │ ├── implement.js │ │ │ │ │ │ │ ├── index.js │ │ │ │ │ │ │ ├── is-implemented.js │ │ │ │ │ │ │ └── shim.js │ │ │ │ │ │ ├── is-natural.js │ │ │ │ │ │ ├── is-number.js │ │ │ │ │ │ ├── is-safe-integer │ │ │ │ │ │ │ ├── implement.js │ │ │ │ │ │ │ ├── index.js │ │ │ │ │ │ │ ├── is-implemented.js │ │ │ │ │ │ │ └── shim.js │ │ │ │ │ │ ├── max-safe-integer │ │ │ │ │ │ │ ├── implement.js │ │ │ │ │ │ │ ├── index.js │ │ │ │ │ │ │ └── is-implemented.js │ │ │ │ │ │ ├── min-safe-integer │ │ │ │ │ │ │ ├── implement.js │ │ │ │ │ │ │ ├── index.js │ │ │ │ │ │ │ └── is-implemented.js │ │ │ │ │ │ ├── to-integer.js │ │ │ │ │ │ ├── to-pos-integer.js │ │ │ │ │ │ └── to-uint32.js │ │ │ │ │ │ ├── object │ │ │ │ │ │ ├── _iterate.js │ │ │ │ │ │ ├── assign │ │ │ │ │ │ │ ├── implement.js │ │ │ │ │ │ │ ├── index.js │ │ │ │ │ │ │ ├── is-implemented.js │ │ │ │ │ │ │ └── shim.js │ │ │ │ │ │ ├── clear.js │ │ │ │ │ │ ├── compact.js │ │ │ │ │ │ ├── compare.js │ │ │ │ │ │ ├── copy-deep.js │ │ │ │ │ │ ├── copy.js │ │ │ │ │ │ ├── count.js │ │ │ │ │ │ ├── create.js │ │ │ │ │ │ ├── ensure-natural-number-value.js │ │ │ │ │ │ ├── ensure-natural-number.js │ │ │ │ │ │ ├── eq.js │ │ │ │ │ │ ├── every.js │ │ │ │ │ │ ├── filter.js │ │ │ │ │ │ ├── find-key.js │ │ │ │ │ │ ├── find.js │ │ │ │ │ │ ├── first-key.js │ │ │ │ │ │ ├── flatten.js │ │ │ │ │ │ ├── for-each.js │ │ │ │ │ │ ├── get-property-names.js │ │ │ │ │ │ ├── is-array-like.js │ │ │ │ │ │ ├── is-callable.js │ │ │ │ │ │ ├── is-copy-deep.js │ │ │ │ │ │ ├── is-copy.js │ │ │ │ │ │ ├── is-empty.js │ │ │ │ │ │ ├── is-number-value.js │ │ │ │ │ │ ├── is-object.js │ │ │ │ │ │ ├── is-plain-object.js │ │ │ │ │ │ ├── is.js │ │ │ │ │ │ ├── key-of.js │ │ │ │ │ │ ├── keys │ │ │ │ │ │ │ ├── implement.js │ │ │ │ │ │ │ ├── index.js │ │ │ │ │ │ │ ├── is-implemented.js │ │ │ │ │ │ │ └── shim.js │ │ │ │ │ │ ├── map-keys.js │ │ │ │ │ │ ├── map.js │ │ │ │ │ │ ├── mixin-prototypes.js │ │ │ │ │ │ ├── mixin.js │ │ │ │ │ │ ├── normalize-options.js │ │ │ │ │ │ ├── primitive-set.js │ │ │ │ │ │ ├── safe-traverse.js │ │ │ │ │ │ ├── serialize.js │ │ │ │ │ │ ├── set-prototype-of │ │ │ │ │ │ │ ├── implement.js │ │ │ │ │ │ │ ├── index.js │ │ │ │ │ │ │ ├── is-implemented.js │ │ │ │ │ │ │ └── shim.js │ │ │ │ │ │ ├── some.js │ │ │ │ │ │ ├── to-array.js │ │ │ │ │ │ ├── unserialize.js │ │ │ │ │ │ ├── valid-callable.js │ │ │ │ │ │ ├── valid-object.js │ │ │ │ │ │ ├── valid-value.js │ │ │ │ │ │ ├── validate-array-like-object.js │ │ │ │ │ │ ├── validate-array-like.js │ │ │ │ │ │ ├── validate-stringifiable-value.js │ │ │ │ │ │ └── validate-stringifiable.js │ │ │ │ │ │ ├── reg-exp │ │ │ │ │ │ ├── # │ │ │ │ │ │ │ ├── index.js │ │ │ │ │ │ │ ├── is-sticky.js │ │ │ │ │ │ │ ├── is-unicode.js │ │ │ │ │ │ │ ├── match │ │ │ │ │ │ │ │ ├── implement.js │ │ │ │ │ │ │ │ ├── index.js │ │ │ │ │ │ │ │ ├── is-implemented.js │ │ │ │ │ │ │ │ └── shim.js │ │ │ │ │ │ │ ├── replace │ │ │ │ │ │ │ │ ├── implement.js │ │ │ │ │ │ │ │ ├── index.js │ │ │ │ │ │ │ │ ├── is-implemented.js │ │ │ │ │ │ │ │ └── shim.js │ │ │ │ │ │ │ ├── search │ │ │ │ │ │ │ │ ├── implement.js │ │ │ │ │ │ │ │ ├── index.js │ │ │ │ │ │ │ │ ├── is-implemented.js │ │ │ │ │ │ │ │ └── shim.js │ │ │ │ │ │ │ ├── split │ │ │ │ │ │ │ │ ├── implement.js │ │ │ │ │ │ │ │ ├── index.js │ │ │ │ │ │ │ │ ├── is-implemented.js │ │ │ │ │ │ │ │ └── shim.js │ │ │ │ │ │ │ ├── sticky │ │ │ │ │ │ │ │ ├── implement.js │ │ │ │ │ │ │ │ └── is-implemented.js │ │ │ │ │ │ │ └── unicode │ │ │ │ │ │ │ │ ├── implement.js │ │ │ │ │ │ │ │ └── is-implemented.js │ │ │ │ │ │ ├── escape.js │ │ │ │ │ │ ├── is-reg-exp.js │ │ │ │ │ │ └── valid-reg-exp.js │ │ │ │ │ │ └── string │ │ │ │ │ │ ├── # │ │ │ │ │ │ ├── @@iterator │ │ │ │ │ │ │ ├── implement.js │ │ │ │ │ │ │ ├── index.js │ │ │ │ │ │ │ ├── is-implemented.js │ │ │ │ │ │ │ └── shim.js │ │ │ │ │ │ ├── at.js │ │ │ │ │ │ ├── camel-to-hyphen.js │ │ │ │ │ │ ├── capitalize.js │ │ │ │ │ │ ├── case-insensitive-compare.js │ │ │ │ │ │ ├── code-point-at │ │ │ │ │ │ │ ├── implement.js │ │ │ │ │ │ │ ├── index.js │ │ │ │ │ │ │ ├── is-implemented.js │ │ │ │ │ │ │ └── shim.js │ │ │ │ │ │ ├── contains │ │ │ │ │ │ │ ├── implement.js │ │ │ │ │ │ │ ├── index.js │ │ │ │ │ │ │ ├── is-implemented.js │ │ │ │ │ │ │ └── shim.js │ │ │ │ │ │ ├── ends-with │ │ │ │ │ │ │ ├── implement.js │ │ │ │ │ │ │ ├── index.js │ │ │ │ │ │ │ ├── is-implemented.js │ │ │ │ │ │ │ └── shim.js │ │ │ │ │ │ ├── hyphen-to-camel.js │ │ │ │ │ │ ├── indent.js │ │ │ │ │ │ ├── last.js │ │ │ │ │ │ ├── normalize │ │ │ │ │ │ │ ├── _data.js │ │ │ │ │ │ │ ├── implement.js │ │ │ │ │ │ │ ├── index.js │ │ │ │ │ │ │ ├── is-implemented.js │ │ │ │ │ │ │ └── shim.js │ │ │ │ │ │ ├── pad.js │ │ │ │ │ │ ├── plain-replace-all.js │ │ │ │ │ │ ├── plain-replace.js │ │ │ │ │ │ ├── repeat │ │ │ │ │ │ │ ├── implement.js │ │ │ │ │ │ │ ├── index.js │ │ │ │ │ │ │ ├── is-implemented.js │ │ │ │ │ │ │ └── shim.js │ │ │ │ │ │ ├── starts-with │ │ │ │ │ │ │ ├── implement.js │ │ │ │ │ │ │ ├── index.js │ │ │ │ │ │ │ ├── is-implemented.js │ │ │ │ │ │ │ └── shim.js │ │ │ │ │ │ └── uncapitalize.js │ │ │ │ │ │ ├── format-method.js │ │ │ │ │ │ ├── from-code-point │ │ │ │ │ │ ├── implement.js │ │ │ │ │ │ ├── index.js │ │ │ │ │ │ ├── is-implemented.js │ │ │ │ │ │ └── shim.js │ │ │ │ │ │ ├── is-string.js │ │ │ │ │ │ ├── random-uniq.js │ │ │ │ │ │ └── raw │ │ │ │ │ │ ├── implement.js │ │ │ │ │ │ ├── index.js │ │ │ │ │ │ ├── is-implemented.js │ │ │ │ │ │ └── shim.js │ │ │ │ ├── es6-iterator │ │ │ │ │ ├── # │ │ │ │ │ │ └── chain.js │ │ │ │ │ ├── .lint │ │ │ │ │ ├── .npmignore │ │ │ │ │ ├── .travis.yml │ │ │ │ │ ├── CHANGES │ │ │ │ │ ├── LICENSE │ │ │ │ │ ├── README.md │ │ │ │ │ ├── array.js │ │ │ │ │ ├── for-of.js │ │ │ │ │ ├── get.js │ │ │ │ │ ├── index.js │ │ │ │ │ ├── is-iterable.js │ │ │ │ │ ├── package.json │ │ │ │ │ ├── string.js │ │ │ │ │ ├── test │ │ │ │ │ │ ├── # │ │ │ │ │ │ │ └── chain.js │ │ │ │ │ │ ├── array.js │ │ │ │ │ │ ├── for-of.js │ │ │ │ │ │ ├── get.js │ │ │ │ │ │ ├── index.js │ │ │ │ │ │ ├── is-iterable.js │ │ │ │ │ │ ├── string.js │ │ │ │ │ │ └── valid-iterable.js │ │ │ │ │ └── valid-iterable.js │ │ │ │ └── es6-symbol │ │ │ │ │ ├── .lint │ │ │ │ │ ├── .npmignore │ │ │ │ │ ├── .travis.yml │ │ │ │ │ ├── CHANGES │ │ │ │ │ ├── LICENSE │ │ │ │ │ ├── README.md │ │ │ │ │ ├── implement.js │ │ │ │ │ ├── index.js │ │ │ │ │ ├── is-implemented.js │ │ │ │ │ ├── is-native-implemented.js │ │ │ │ │ ├── is-symbol.js │ │ │ │ │ ├── package.json │ │ │ │ │ ├── polyfill.js │ │ │ │ │ ├── test │ │ │ │ │ ├── implement.js │ │ │ │ │ ├── index.js │ │ │ │ │ ├── is-implemented.js │ │ │ │ │ ├── is-native-implemented.js │ │ │ │ │ ├── is-symbol.js │ │ │ │ │ ├── polyfill.js │ │ │ │ │ └── validate-symbol.js │ │ │ │ │ └── validate-symbol.js │ │ │ ├── package.json │ │ │ ├── polyfill.js │ │ │ ├── test │ │ │ │ ├── implement.js │ │ │ │ ├── index.js │ │ │ │ ├── is-implemented.js │ │ │ │ ├── is-native-implemented.js │ │ │ │ ├── is-weak-map.js │ │ │ │ ├── polyfill.js │ │ │ │ └── valid-weak-map.js │ │ │ └── valid-weak-map.js │ │ ├── mixto │ │ │ ├── LICENSE.md │ │ │ ├── README.md │ │ │ ├── lib │ │ │ │ └── mixin.js │ │ │ └── package.json │ │ └── property-accessors │ │ │ ├── LICENSE.md │ │ │ ├── README.md │ │ │ ├── lib │ │ │ └── property-accessors.js │ │ │ └── package.json │ └── package.json ├── underscore-plus │ ├── LICENSE.md │ ├── README.md │ ├── lib │ │ └── underscore-plus.js │ ├── node_modules │ │ └── underscore │ │ │ ├── LICENSE │ │ │ ├── README.md │ │ │ ├── package.json │ │ │ ├── underscore-min.js │ │ │ └── underscore.js │ └── package.json └── xregexp │ ├── .npmignore │ ├── MIT-LICENSE.txt │ ├── README.md │ ├── package.json │ ├── tests │ ├── node-qunit.js │ └── tests.js │ └── xregexp-all.js ├── package.json ├── styles └── atom-shell-commands.less └── vendor ├── launch.cmd └── terminal.py /images/command_compile.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/skywind3000/atom-shell-commands/06004208f1a20d1c92b7f6bd3746606270c53219/images/command_compile.png -------------------------------------------------------------------------------- /images/command_execute.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/skywind3000/atom-shell-commands/06004208f1a20d1c92b7f6bd3746606270c53219/images/command_execute.png -------------------------------------------------------------------------------- /images/command_redirect.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/skywind3000/atom-shell-commands/06004208f1a20d1c92b7f6bd3746606270c53219/images/command_redirect.png -------------------------------------------------------------------------------- /images/command_runinwindow.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/skywind3000/atom-shell-commands/06004208f1a20d1c92b7f6bd3746606270c53219/images/command_runinwindow.png -------------------------------------------------------------------------------- /node_modules/atom-message-panel/lib/index.js: -------------------------------------------------------------------------------- 1 | module.exports = { 2 | MessagePanelView: require('./MessagePanelView'), 3 | PlainMessageView: require('./PlainMessageView'), 4 | LineMessageView: require('./LineMessageView') 5 | }; 6 | -------------------------------------------------------------------------------- /node_modules/atom-message-panel/node_modules/atom-space-pen-views/spec/spec-helper.coffee: -------------------------------------------------------------------------------- 1 | require 'coffee-cache' 2 | -------------------------------------------------------------------------------- /node_modules/emissary/lib/emissary.js: -------------------------------------------------------------------------------- 1 | (function() { 2 | var combine; 3 | 4 | combine = require('./helpers').combine; 5 | 6 | module.exports = { 7 | Emitter: require('./emitter'), 8 | Subscriber: require('./subscriber'), 9 | Signal: require('./signal'), 10 | Behavior: require('./behavior'), 11 | combine: combine 12 | }; 13 | 14 | }).call(this); 15 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/.lint: -------------------------------------------------------------------------------- 1 | @root 2 | 3 | module 4 | 5 | tabs 6 | indent 2 7 | maxlen 100 8 | 9 | ass 10 | nomen 11 | plusplus 12 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/.npmignore: -------------------------------------------------------------------------------- 1 | .DS_Store 2 | /node_modules 3 | /npm-debug.log 4 | /.lintcache 5 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/.travis.yml: -------------------------------------------------------------------------------- 1 | sudo: false # use faster docker infrastructure 2 | language: node_js 3 | node_js: 4 | - 0.10 5 | - 0.12 6 | - iojs 7 | 8 | notifications: 9 | email: 10 | - medikoo+es6-weak-map@medikoo.com 11 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/implement.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | if (!require('./is-implemented')()) { 4 | Object.defineProperty(require('es5-ext/global'), 'WeakMap', 5 | { value: require('./polyfill'), configurable: true, enumerable: false, 6 | writable: true }); 7 | } 8 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/index.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | module.exports = require('./is-implemented')() ? 4 | WeakMap : require('./polyfill'); 5 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/is-native-implemented.js: -------------------------------------------------------------------------------- 1 | // Exports true if environment provides native `WeakMap` implementation, 2 | // whatever that is. 3 | 4 | 'use strict'; 5 | 6 | module.exports = (function () { 7 | if (typeof WeakMap === 'undefined') return false; 8 | return (Object.prototype.toString.call(WeakMap.prototype) === 9 | '[object WeakMap]'); 10 | }()); 11 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/d/.lint: -------------------------------------------------------------------------------- 1 | @root 2 | 3 | es5 4 | module 5 | 6 | tabs 7 | indent 2 8 | maxlen 80 9 | 10 | ass 11 | nomen 12 | plusplus 13 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/d/.npmignore: -------------------------------------------------------------------------------- 1 | .DS_Store 2 | /node_modules 3 | /npm-debug.log 4 | /.lintcache 5 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/d/.travis.yml: -------------------------------------------------------------------------------- 1 | language: node_js 2 | node_js: 3 | - 0.8 4 | - 0.10 5 | - 0.11 6 | 7 | notifications: 8 | email: 9 | - medikoo+d@medikoo.com 10 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/d/CHANGES: -------------------------------------------------------------------------------- 1 | v0.1.1 -- 2014.04.24 2 | - Add `autoBind` and `lazy` utilities 3 | - Allow to pass other options to be merged onto created descriptor. 4 | Useful when used with other custom utilties 5 | 6 | v0.1.0 -- 2013.06.20 7 | Initial (derived from es5-ext project) 8 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/d/test/auto-bind.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | var d = require('../'); 4 | 5 | module.exports = function (t, a) { 6 | var o = Object.defineProperties({}, t({ 7 | bar: d(function () { return this === o; }), 8 | bar2: d(function () { return this; }) 9 | })); 10 | 11 | a.deep([(o.bar)(), (o.bar2)()], [true, o]); 12 | }; 13 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/.lintignore: -------------------------------------------------------------------------------- 1 | /string/#/normalize/_data.js 2 | /test/boolean/is-boolean.js 3 | /test/date/is-date.js 4 | /test/number/is-number.js 5 | /test/object/is-copy.js 6 | /test/object/is-number-value.js 7 | /test/object/is-object.js 8 | /test/reg-exp/is-reg-exp.js 9 | /test/string/is-string.js 10 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/.npmignore: -------------------------------------------------------------------------------- 1 | .DS_Store 2 | /node_modules 3 | /.lintcache 4 | /npm-debug.log 5 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/array/#/@@iterator/implement.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | if (!require('./is-implemented')()) { 4 | Object.defineProperty(Array.prototype, require('es6-symbol').iterator, { value: require('./shim'), 5 | configurable: true, enumerable: false, writable: true }); 6 | } 7 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/array/#/@@iterator/index.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | module.exports = require('./is-implemented')() 4 | ? Array.prototype[require('es6-symbol').iterator] : require('./shim'); 5 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/array/#/@@iterator/shim.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | module.exports = require('../values/shim'); 4 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/array/#/_compare-by-length.js: -------------------------------------------------------------------------------- 1 | // Used internally to sort array of lists by length 2 | 3 | 'use strict'; 4 | 5 | var toPosInt = require('../../number/to-pos-integer'); 6 | 7 | module.exports = function (a, b) { 8 | return toPosInt(a.length) - toPosInt(b.length); 9 | }; 10 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/array/#/clear.js: -------------------------------------------------------------------------------- 1 | // Inspired by Google Closure: 2 | // http://closure-library.googlecode.com/svn/docs/ 3 | // closure_goog_array_array.js.html#goog.array.clear 4 | 5 | 'use strict'; 6 | 7 | var value = require('../../object/valid-value'); 8 | 9 | module.exports = function () { 10 | value(this).length = 0; 11 | return this; 12 | }; 13 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/array/#/compact.js: -------------------------------------------------------------------------------- 1 | // Inspired by: http://documentcloud.github.com/underscore/#compact 2 | 3 | 'use strict'; 4 | 5 | var filter = Array.prototype.filter; 6 | 7 | module.exports = function () { 8 | return filter.call(this, function (val) { return val != null; }); 9 | }; 10 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/array/#/concat/implement.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | if (!require('./is-implemented')()) { 4 | Object.defineProperty(Array.prototype, 'concat', { value: require('./shim'), 5 | configurable: true, enumerable: false, writable: true }); 6 | } 7 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/array/#/concat/index.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | module.exports = require('./is-implemented')() ? 4 | Array.prototype.concat : require('./shim'); 5 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/array/#/concat/is-implemented.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | var SubArray = require('../../_sub-array-dummy-safe'); 4 | 5 | module.exports = function () { 6 | return (new SubArray()).concat('foo') instanceof SubArray; 7 | }; 8 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/array/#/contains.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | var indexOf = require('./e-index-of'); 4 | 5 | module.exports = function (searchElement/*, position*/) { 6 | return indexOf.call(this, searchElement, arguments[1]) > -1; 7 | }; 8 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/array/#/copy-within/implement.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | if (!require('./is-implemented')()) { 4 | Object.defineProperty(Array.prototype, 'copyWithin', 5 | { value: require('./shim'), configurable: true, enumerable: false, 6 | writable: true }); 7 | } 8 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/array/#/copy-within/index.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | module.exports = require('./is-implemented')() ? 4 | Array.prototype.copyWithin : require('./shim'); 5 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/array/#/copy-within/is-implemented.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | module.exports = function () { 4 | var arr = [1, 2, 3, 4, 5]; 5 | if (typeof arr.copyWithin !== 'function') return false; 6 | return String(arr.copyWithin(1, 3)) === '1,4,5,4,5'; 7 | }; 8 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/array/#/entries/implement.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | if (!require('./is-implemented')()) { 4 | Object.defineProperty(Array.prototype, 'entries', { value: require('./shim'), 5 | configurable: true, enumerable: false, writable: true }); 6 | } 7 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/array/#/entries/index.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | module.exports = require('./is-implemented')() ? 4 | Array.prototype.entries : require('./shim'); 5 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/array/#/entries/shim.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | var ArrayIterator = require('es6-iterator/array'); 4 | module.exports = function () { return new ArrayIterator(this, 'key+value'); }; 5 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/array/#/fill/implement.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | if (!require('./is-implemented')()) { 4 | Object.defineProperty(Array.prototype, 'fill', { value: require('./shim'), 5 | configurable: true, enumerable: false, writable: true }); 6 | } 7 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/array/#/fill/index.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | module.exports = require('./is-implemented')() ? 4 | Array.prototype.fill : require('./shim'); 5 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/array/#/fill/is-implemented.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | module.exports = function () { 4 | var arr = [1, 2, 3, 4, 5, 6]; 5 | if (typeof arr.fill !== 'function') return false; 6 | return String(arr.fill(-1, -3)) === '1,2,3,-1,-1,-1'; 7 | }; 8 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/array/#/filter/implement.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | if (!require('./is-implemented')()) { 4 | Object.defineProperty(Array.prototype, 'filter', { value: require('./shim'), 5 | configurable: true, enumerable: false, writable: true }); 6 | } 7 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/array/#/filter/index.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | module.exports = require('./is-implemented')() ? 4 | Array.prototype.filter : require('./shim'); 5 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/array/#/filter/is-implemented.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | var SubArray = require('../../_sub-array-dummy-safe') 4 | 5 | , pass = function () { return true; }; 6 | 7 | module.exports = function () { 8 | return (new SubArray()).filter(pass) instanceof SubArray; 9 | }; 10 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/array/#/find-index/implement.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | if (!require('./is-implemented')()) { 4 | Object.defineProperty(Array.prototype, 'findIndex', 5 | { value: require('./shim'), 6 | configurable: true, enumerable: false, writable: true }); 7 | } 8 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/array/#/find-index/index.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | module.exports = require('./is-implemented')() ? 4 | Array.prototype.findIndex : require('./shim'); 5 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/array/#/find-index/is-implemented.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | var fn = function (x) { return x > 3; }; 4 | 5 | module.exports = function () { 6 | var arr = [1, 2, 3, 4, 5, 6]; 7 | if (typeof arr.findIndex !== 'function') return false; 8 | return arr.findIndex(fn) === 3; 9 | }; 10 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/array/#/find/implement.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | if (!require('./is-implemented')()) { 4 | Object.defineProperty(Array.prototype, 'find', { value: require('./shim'), 5 | configurable: true, enumerable: false, writable: true }); 6 | } 7 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/array/#/find/index.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | module.exports = require('./is-implemented')() ? 4 | Array.prototype.find : require('./shim'); 5 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/array/#/find/is-implemented.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | var fn = function (x) { return x > 3; }; 4 | 5 | module.exports = function () { 6 | var arr = [1, 2, 3, 4, 5, 6]; 7 | if (typeof arr.find !== 'function') return false; 8 | return arr.find(fn) === 4; 9 | }; 10 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/array/#/find/shim.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | var findIndex = require('../find-index/shim'); 4 | 5 | module.exports = function (predicate/*, thisArg*/) { 6 | var index = findIndex.apply(this, arguments); 7 | return (index === -1) ? undefined : this[index]; 8 | }; 9 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/array/#/first.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | var firstIndex = require('./first-index'); 4 | 5 | module.exports = function () { 6 | var i; 7 | if ((i = firstIndex.call(this)) !== null) return this[i]; 8 | return undefined; 9 | }; 10 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/array/#/flatten.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | var isArray = Array.isArray, forEach = Array.prototype.forEach 4 | , push = Array.prototype.push; 5 | 6 | module.exports = function flatten() { 7 | var r = []; 8 | forEach.call(this, function (x) { 9 | push.apply(r, isArray(x) ? flatten.call(x) : [x]); 10 | }); 11 | return r; 12 | }; 13 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/array/#/indexes-of.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | var indexOf = require('./e-index-of'); 4 | 5 | module.exports = function (value/*, fromIndex*/) { 6 | var r = [], i, fromIndex = arguments[1]; 7 | while ((i = indexOf.call(this, value, fromIndex)) !== -1) { 8 | r.push(i); 9 | fromIndex = i + 1; 10 | } 11 | return r; 12 | }; 13 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/array/#/is-uniq.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | var indexOf = require('./e-index-of') 4 | 5 | , every = Array.prototype.every 6 | , isFirst; 7 | 8 | isFirst = function (value, index) { 9 | return indexOf.call(this, value) === index; 10 | }; 11 | 12 | module.exports = function () { return every.call(this, isFirst, this); }; 13 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/array/#/keys/implement.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | if (!require('./is-implemented')()) { 4 | Object.defineProperty(Array.prototype, 'keys', { value: require('./shim'), 5 | configurable: true, enumerable: false, writable: true }); 6 | } 7 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/array/#/keys/index.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | module.exports = require('./is-implemented')() ? 4 | Array.prototype.keys : require('./shim'); 5 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/array/#/keys/shim.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | var ArrayIterator = require('es6-iterator/array'); 4 | module.exports = function () { return new ArrayIterator(this, 'key'); }; 5 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/array/#/last.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | var lastIndex = require('./last-index'); 4 | 5 | module.exports = function () { 6 | var i; 7 | if ((i = lastIndex.call(this)) !== null) return this[i]; 8 | return undefined; 9 | }; 10 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/array/#/map/implement.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | if (!require('./is-implemented')()) { 4 | Object.defineProperty(Array.prototype, 'map', { value: require('./shim'), 5 | configurable: true, enumerable: false, writable: true }); 6 | } 7 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/array/#/map/index.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | module.exports = require('./is-implemented')() ? 4 | Array.prototype.map : require('./shim'); 5 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/array/#/map/is-implemented.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | var identity = require('../../../function/identity') 4 | , SubArray = require('../../_sub-array-dummy-safe'); 5 | 6 | module.exports = function () { 7 | return (new SubArray()).map(identity) instanceof SubArray; 8 | }; 9 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/array/#/separate.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | var forEach = Array.prototype.forEach; 4 | 5 | module.exports = function (sep) { 6 | var result = []; 7 | forEach.call(this, function (val, i) { result.push(val, sep); }); 8 | result.pop(); 9 | return result; 10 | }; 11 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/array/#/slice/implement.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | if (!require('./is-implemented')()) { 4 | Object.defineProperty(Array.prototype, 'slice', { value: require('./shim'), 5 | configurable: true, enumerable: false, writable: true }); 6 | } 7 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/array/#/slice/index.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | module.exports = require('./is-implemented')() 4 | ? Array.prototype.slice : require('./shim'); 5 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/array/#/slice/is-implemented.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | var SubArray = require('../../_sub-array-dummy-safe'); 4 | 5 | module.exports = function () { 6 | return (new SubArray()).slice() instanceof SubArray; 7 | }; 8 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/array/#/splice/implement.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | if (!require('./is-implemented')()) { 4 | Object.defineProperty(Array.prototype, 'splice', { value: require('./shim'), 5 | configurable: true, enumerable: false, writable: true }); 6 | } 7 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/array/#/splice/index.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | module.exports = require('./is-implemented')() 4 | ? Array.prototype.splice : require('./shim'); 5 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/array/#/splice/is-implemented.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | var SubArray = require('../../_sub-array-dummy-safe'); 4 | 5 | module.exports = function () { 6 | return (new SubArray()).splice(0) instanceof SubArray; 7 | }; 8 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/array/#/uniq.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | var indexOf = require('./e-index-of') 4 | 5 | , filter = Array.prototype.filter 6 | 7 | , isFirst; 8 | 9 | isFirst = function (value, index) { 10 | return indexOf.call(this, value) === index; 11 | }; 12 | 13 | module.exports = function () { return filter.call(this, isFirst, this); }; 14 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/array/#/values/implement.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | if (!require('./is-implemented')()) { 4 | Object.defineProperty(Array.prototype, 'values', { value: require('./shim'), 5 | configurable: true, enumerable: false, writable: true }); 6 | } 7 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/array/#/values/index.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | module.exports = require('./is-implemented')() ? Array.prototype.values : require('./shim'); 4 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/array/#/values/shim.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | var ArrayIterator = require('es6-iterator/array'); 4 | module.exports = function () { return new ArrayIterator(this, 'value'); }; 5 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/array/from/implement.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | if (!require('./is-implemented')()) { 4 | Object.defineProperty(Array, 'from', { value: require('./shim'), 5 | configurable: true, enumerable: false, writable: true }); 6 | } 7 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/array/from/index.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | module.exports = require('./is-implemented')() 4 | ? Array.from 5 | : require('./shim'); 6 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/array/from/is-implemented.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | module.exports = function () { 4 | var from = Array.from, arr, result; 5 | if (typeof from !== 'function') return false; 6 | arr = ['raz', 'dwa']; 7 | result = from(arr); 8 | return Boolean(result && (result !== arr) && (result[1] === 'dwa')); 9 | }; 10 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/array/of/implement.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | if (!require('./is-implemented')()) { 4 | Object.defineProperty(Array, 'of', { value: require('./shim'), 5 | configurable: true, enumerable: false, writable: true }); 6 | } 7 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/array/of/index.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | module.exports = require('./is-implemented')() 4 | ? Array.of 5 | : require('./shim'); 6 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/array/of/is-implemented.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | module.exports = function () { 4 | var of = Array.of, result; 5 | if (typeof of !== 'function') return false; 6 | result = of('foo', 'bar'); 7 | return Boolean(result && (result[1] === 'bar')); 8 | }; 9 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/array/to-array.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | var from = require('./from') 4 | 5 | , isArray = Array.isArray; 6 | 7 | module.exports = function (arrayLike) { 8 | return isArray(arrayLike) ? arrayLike : from(arrayLike); 9 | }; 10 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/array/valid-array.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | var isArray = Array.isArray; 4 | 5 | module.exports = function (value) { 6 | if (isArray(value)) return value; 7 | throw new TypeError(value + " is not an array"); 8 | }; 9 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/boolean/index.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | module.exports = { 4 | isBoolean: require('./is-boolean') 5 | }; 6 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/boolean/is-boolean.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | var toString = Object.prototype.toString 4 | 5 | , id = toString.call(true); 6 | 7 | module.exports = function (x) { 8 | return (typeof x === 'boolean') || ((typeof x === 'object') && 9 | ((x instanceof Boolean) || (toString.call(x) === id))); 10 | }; 11 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/date/#/copy.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | var getTime = Date.prototype.getTime; 4 | 5 | module.exports = function () { return new Date(getTime.call(this)); }; 6 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/date/#/floor-day.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | var setHours = Date.prototype.setHours; 4 | 5 | module.exports = function () { 6 | setHours.call(this, 0, 0, 0, 0); 7 | return this; 8 | }; 9 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/date/#/floor-month.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | var floorDay = require('./floor-day'); 4 | 5 | module.exports = function () { 6 | floorDay.call(this).setDate(1); 7 | return this; 8 | }; 9 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/date/#/floor-year.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | var floorMonth = require('./floor-month'); 4 | 5 | module.exports = function () { 6 | floorMonth.call(this).setMonth(0); 7 | return this; 8 | }; 9 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/date/#/index.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | module.exports = { 4 | copy: require('./copy'), 5 | daysInMonth: require('./days-in-month'), 6 | floorDay: require('./floor-day'), 7 | floorMonth: require('./floor-month'), 8 | floorYear: require('./floor-year'), 9 | format: require('./format') 10 | }; 11 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/date/index.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | module.exports = { 4 | '#': require('./#'), 5 | isDate: require('./is-date'), 6 | validDate: require('./valid-date') 7 | }; 8 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/date/is-date.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | var toString = Object.prototype.toString 4 | 5 | , id = toString.call(new Date()); 6 | 7 | module.exports = function (x) { 8 | return (x && ((x instanceof Date) || (toString.call(x) === id))) || false; 9 | }; 10 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/date/valid-date.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | var isDate = require('./is-date'); 4 | 5 | module.exports = function (x) { 6 | if (!isDate(x)) throw new TypeError(x + " is not a Date object"); 7 | return x; 8 | }; 9 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/error/#/index.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | module.exports = { 4 | throw: require('./throw') 5 | }; 6 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/error/#/throw.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | var error = require('../valid-error'); 4 | 5 | module.exports = function () { throw error(this); }; 6 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/error/index.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | module.exports = { 4 | '#': require('./#'), 5 | custom: require('./custom'), 6 | isError: require('./is-error'), 7 | validError: require('./valid-error') 8 | }; 9 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/error/is-error.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | var toString = Object.prototype.toString 4 | 5 | , id = toString.call(new Error()); 6 | 7 | module.exports = function (x) { 8 | return (x && ((x instanceof Error) || (toString.call(x)) === id)) || false; 9 | }; 10 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/error/valid-error.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | var isError = require('./is-error'); 4 | 5 | module.exports = function (x) { 6 | if (!isError(x)) throw new TypeError(x + " is not an Error object"); 7 | return x; 8 | }; 9 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/function/#/lock.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | var callable = require('../../object/valid-callable') 4 | 5 | , apply = Function.prototype.apply; 6 | 7 | module.exports = function (/*…args*/) { 8 | var fn = callable(this) 9 | , args = arguments; 10 | 11 | return function () { return apply.call(fn, this, args); }; 12 | }; 13 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/function/#/spread.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | var callable = require('../../object/valid-callable') 4 | 5 | , apply = Function.prototype.apply; 6 | 7 | module.exports = function () { 8 | var fn = callable(this); 9 | return function (args) { return apply.call(fn, this, args); }; 10 | }; 11 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/function/constant.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | module.exports = function (x) { 4 | return function () { return x; }; 5 | }; 6 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/function/identity.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | module.exports = function (x) { return x; }; 4 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/function/is-arguments.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | var toString = Object.prototype.toString 4 | 5 | , id = toString.call((function () { return arguments; }())); 6 | 7 | module.exports = function (x) { return (toString.call(x) === id); }; 8 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/function/is-function.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | var toString = Object.prototype.toString 4 | 5 | , id = toString.call(require('./noop')); 6 | 7 | module.exports = function (f) { 8 | return (typeof f === "function") && (toString.call(f) === id); 9 | }; 10 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/function/noop.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | module.exports = function () {}; 4 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/function/pluck.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | var value = require('../object/valid-value'); 4 | 5 | module.exports = function (name) { 6 | return function (o) { return value(o)[name]; }; 7 | }; 8 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/function/valid-function.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | var isFunction = require('./is-function'); 4 | 5 | module.exports = function (x) { 6 | if (!isFunction(x)) throw new TypeError(x + " is not a function"); 7 | return x; 8 | }; 9 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/global.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | module.exports = new Function("return this")(); 4 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/iterable/index.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | module.exports = { 4 | forEach: require('./for-each'), 5 | is: require('./is'), 6 | validate: require('./validate'), 7 | validateObject: require('./validate-object') 8 | }; 9 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/iterable/is.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | var iteratorSymbol = require('es6-symbol').iterator 4 | , isArrayLike = require('../object/is-array-like'); 5 | 6 | module.exports = function (x) { 7 | if (x == null) return false; 8 | if (typeof x[iteratorSymbol] === 'function') return true; 9 | return isArrayLike(x); 10 | }; 11 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/iterable/validate-object.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | var isObject = require('../object/is-object') 4 | , is = require('./is'); 5 | 6 | module.exports = function (x) { 7 | if (is(x) && isObject(x)) return x; 8 | throw new TypeError(x + " is not an iterable or array-like object"); 9 | }; 10 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/iterable/validate.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | var is = require('./is'); 4 | 5 | module.exports = function (x) { 6 | if (is(x)) return x; 7 | throw new TypeError(x + " is not an iterable or array-like"); 8 | }; 9 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/math/acosh/implement.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | if (!require('./is-implemented')()) { 4 | Object.defineProperty(Math, 'acosh', { value: require('./shim'), 5 | configurable: true, enumerable: false, writable: true }); 6 | } 7 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/math/acosh/index.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | module.exports = require('./is-implemented')() 4 | ? Math.acosh 5 | : require('./shim'); 6 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/math/acosh/is-implemented.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | module.exports = function () { 4 | var acosh = Math.acosh; 5 | if (typeof acosh !== 'function') return false; 6 | return acosh(2) === 1.3169578969248166; 7 | }; 8 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/math/acosh/shim.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | var log = Math.log, sqrt = Math.sqrt; 4 | 5 | module.exports = function (x) { 6 | if (isNaN(x)) return NaN; 7 | x = Number(x); 8 | if (x < 1) return NaN; 9 | if (x === 1) return 0; 10 | if (x === Infinity) return x; 11 | return log(x + sqrt(x * x - 1)); 12 | }; 13 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/math/asinh/implement.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | if (!require('./is-implemented')()) { 4 | Object.defineProperty(Math, 'asinh', { value: require('./shim'), 5 | configurable: true, enumerable: false, writable: true }); 6 | } 7 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/math/asinh/index.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | module.exports = require('./is-implemented')() 4 | ? Math.asinh 5 | : require('./shim'); 6 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/math/asinh/is-implemented.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | module.exports = function () { 4 | var asinh = Math.asinh; 5 | if (typeof asinh !== 'function') return false; 6 | return asinh(2) === 1.4436354751788103; 7 | }; 8 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/math/atanh/implement.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | if (!require('./is-implemented')()) { 4 | Object.defineProperty(Math, 'atanh', { value: require('./shim'), 5 | configurable: true, enumerable: false, writable: true }); 6 | } 7 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/math/atanh/index.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | module.exports = require('./is-implemented')() 4 | ? Math.atanh 5 | : require('./shim'); 6 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/math/atanh/is-implemented.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | module.exports = function () { 4 | var atanh = Math.atanh; 5 | if (typeof atanh !== 'function') return false; 6 | return atanh(0.5) === 0.5493061443340549; 7 | }; 8 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/math/cbrt/implement.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | if (!require('./is-implemented')()) { 4 | Object.defineProperty(Math, 'cbrt', { value: require('./shim'), 5 | configurable: true, enumerable: false, writable: true }); 6 | } 7 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/math/cbrt/index.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | module.exports = require('./is-implemented')() 4 | ? Math.cbrt 5 | : require('./shim'); 6 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/math/cbrt/is-implemented.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | module.exports = function () { 4 | var cbrt = Math.cbrt; 5 | if (typeof cbrt !== 'function') return false; 6 | return cbrt(2) === 1.2599210498948732; 7 | }; 8 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/math/cbrt/shim.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | var pow = Math.pow; 4 | 5 | module.exports = function (x) { 6 | if (isNaN(x)) return NaN; 7 | x = Number(x); 8 | if (x === 0) return x; 9 | if (!isFinite(x)) return x; 10 | if (x < 0) return -pow(-x, 1 / 3); 11 | return pow(x, 1 / 3); 12 | }; 13 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/math/clz32/implement.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | if (!require('./is-implemented')()) { 4 | Object.defineProperty(Math, 'clz32', { value: require('./shim'), 5 | configurable: true, enumerable: false, writable: true }); 6 | } 7 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/math/clz32/index.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | module.exports = require('./is-implemented')() 4 | ? Math.clz32 5 | : require('./shim'); 6 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/math/clz32/is-implemented.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | module.exports = function () { 4 | var clz32 = Math.clz32; 5 | if (typeof clz32 !== 'function') return false; 6 | return clz32(1000) === 22; 7 | }; 8 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/math/clz32/shim.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | module.exports = function (value) { 4 | value = value >>> 0; 5 | return value ? 32 - value.toString(2).length : 32; 6 | }; 7 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/math/cosh/implement.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | if (!require('./is-implemented')()) { 4 | Object.defineProperty(Math, 'cosh', { value: require('./shim'), 5 | configurable: true, enumerable: false, writable: true }); 6 | } 7 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/math/cosh/index.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | module.exports = require('./is-implemented')() 4 | ? Math.cosh 5 | : require('./shim'); 6 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/math/cosh/is-implemented.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | module.exports = function () { 4 | var cosh = Math.cosh; 5 | if (typeof cosh !== 'function') return false; 6 | return cosh(1) === 1.5430806348152437; 7 | }; 8 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/math/cosh/shim.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | var exp = Math.exp; 4 | 5 | module.exports = function (x) { 6 | if (isNaN(x)) return NaN; 7 | x = Number(x); 8 | if (x === 0) return 1; 9 | if (!isFinite(x)) return Infinity; 10 | return (exp(x) + exp(-x)) / 2; 11 | }; 12 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/math/expm1/implement.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | if (!require('./is-implemented')()) { 4 | Object.defineProperty(Math, 'expm1', { value: require('./shim'), 5 | configurable: true, enumerable: false, writable: true }); 6 | } 7 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/math/expm1/index.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | module.exports = require('./is-implemented')() 4 | ? Math.expm1 5 | : require('./shim'); 6 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/math/expm1/is-implemented.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | module.exports = function () { 4 | var expm1 = Math.expm1; 5 | if (typeof expm1 !== 'function') return false; 6 | return expm1(1).toFixed(15) === '1.718281828459045'; 7 | }; 8 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/math/fround/implement.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | if (!require('./is-implemented')()) { 4 | Object.defineProperty(Math, 'fround', { value: require('./shim'), 5 | configurable: true, enumerable: false, writable: true }); 6 | } 7 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/math/fround/index.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | module.exports = require('./is-implemented')() 4 | ? Math.fround 5 | : require('./shim'); 6 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/math/fround/is-implemented.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | module.exports = function () { 4 | var fround = Math.fround; 5 | if (typeof fround !== 'function') return false; 6 | return fround(1.337) === 1.3370000123977661; 7 | }; 8 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/math/hypot/implement.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | if (!require('./is-implemented')()) { 4 | Object.defineProperty(Math, 'hypot', { value: require('./shim'), 5 | configurable: true, enumerable: false, writable: true }); 6 | } 7 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/math/hypot/index.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | module.exports = require('./is-implemented')() 4 | ? Math.hypot 5 | : require('./shim'); 6 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/math/hypot/is-implemented.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | module.exports = function () { 4 | var hypot = Math.hypot; 5 | if (typeof hypot !== 'function') return false; 6 | return hypot(3, 4) === 5; 7 | }; 8 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/math/imul/implement.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | if (!require('./is-implemented')()) { 4 | Object.defineProperty(Math, 'imul', { value: require('./shim'), 5 | configurable: true, enumerable: false, writable: true }); 6 | } 7 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/math/imul/index.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | module.exports = require('./is-implemented')() 4 | ? Math.imul 5 | : require('./shim'); 6 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/math/imul/is-implemented.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | module.exports = function () { 4 | var imul = Math.imul; 5 | if (typeof imul !== 'function') return false; 6 | return imul(-1, 8) === -8; 7 | }; 8 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/math/log10/implement.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | if (!require('./is-implemented')()) { 4 | Object.defineProperty(Math, 'log10', { value: require('./shim'), 5 | configurable: true, enumerable: false, writable: true }); 6 | } 7 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/math/log10/index.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | module.exports = require('./is-implemented')() 4 | ? Math.log10 5 | : require('./shim'); 6 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/math/log10/is-implemented.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | module.exports = function () { 4 | var log10 = Math.log10; 5 | if (typeof log10 !== 'function') return false; 6 | return log10(2) === 0.3010299956639812; 7 | }; 8 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/math/log1p/implement.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | if (!require('./is-implemented')()) { 4 | Object.defineProperty(Math, 'log1p', { value: require('./shim'), 5 | configurable: true, enumerable: false, writable: true }); 6 | } 7 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/math/log1p/index.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | module.exports = require('./is-implemented')() 4 | ? Math.log1p 5 | : require('./shim'); 6 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/math/log1p/is-implemented.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | module.exports = function () { 4 | var log1p = Math.log1p; 5 | if (typeof log1p !== 'function') return false; 6 | return log1p(1) === 0.6931471805599453; 7 | }; 8 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/math/log2/implement.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | if (!require('./is-implemented')()) { 4 | Object.defineProperty(Math, 'log2', { value: require('./shim'), 5 | configurable: true, enumerable: false, writable: true }); 6 | } 7 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/math/log2/index.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | module.exports = require('./is-implemented')() 4 | ? Math.log2 5 | : require('./shim'); 6 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/math/log2/is-implemented.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | module.exports = function () { 4 | var log2 = Math.log2; 5 | if (typeof log2 !== 'function') return false; 6 | return log2(3).toFixed(15) === '1.584962500721156'; 7 | }; 8 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/math/sign/implement.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | if (!require('./is-implemented')()) { 4 | Object.defineProperty(Math, 'sign', { value: require('./shim'), 5 | configurable: true, enumerable: false, writable: true }); 6 | } 7 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/math/sign/index.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | module.exports = require('./is-implemented')() 4 | ? Math.sign 5 | : require('./shim'); 6 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/math/sign/is-implemented.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | module.exports = function () { 4 | var sign = Math.sign; 5 | if (typeof sign !== 'function') return false; 6 | return ((sign(10) === 1) && (sign(-20) === -1)); 7 | }; 8 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/math/sign/shim.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | module.exports = function (value) { 4 | value = Number(value); 5 | if (isNaN(value) || (value === 0)) return value; 6 | return (value > 0) ? 1 : -1; 7 | }; 8 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/math/sinh/implement.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | if (!require('./is-implemented')()) { 4 | Object.defineProperty(Math, 'sinh', { value: require('./shim'), 5 | configurable: true, enumerable: false, writable: true }); 6 | } 7 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/math/sinh/index.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | module.exports = require('./is-implemented')() 4 | ? Math.sinh 5 | : require('./shim'); 6 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/math/sinh/is-implemented.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | module.exports = function () { 4 | var sinh = Math.sinh; 5 | if (typeof sinh !== 'function') return false; 6 | return ((sinh(1) === 1.1752011936438014) && (sinh(Number.MIN_VALUE) === 5e-324)); 7 | }; 8 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/math/tanh/implement.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | if (!require('./is-implemented')()) { 4 | Object.defineProperty(Math, 'tanh', { value: require('./shim'), 5 | configurable: true, enumerable: false, writable: true }); 6 | } 7 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/math/tanh/index.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | module.exports = require('./is-implemented')() 4 | ? Math.tanh 5 | : require('./shim'); 6 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/math/tanh/is-implemented.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | module.exports = function () { 4 | var tanh = Math.tanh; 5 | if (typeof tanh !== 'function') return false; 6 | return ((tanh(1) === 0.7615941559557649) && (tanh(Number.MAX_VALUE) === 1)); 7 | }; 8 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/math/trunc/implement.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | if (!require('./is-implemented')()) { 4 | Object.defineProperty(Math, 'trunc', { value: require('./shim'), 5 | configurable: true, enumerable: false, writable: true }); 6 | } 7 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/math/trunc/index.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | module.exports = require('./is-implemented')() 4 | ? Math.trunc 5 | : require('./shim'); 6 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/math/trunc/is-implemented.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | module.exports = function () { 4 | var trunc = Math.trunc; 5 | if (typeof trunc !== 'function') return false; 6 | return (trunc(13.67) === 13) && (trunc(-13.67) === -13); 7 | }; 8 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/math/trunc/shim.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | var floor = Math.floor; 4 | 5 | module.exports = function (x) { 6 | if (isNaN(x)) return NaN; 7 | x = Number(x); 8 | if (x === 0) return x; 9 | if (x === Infinity) return Infinity; 10 | if (x === -Infinity) return -Infinity; 11 | if (x > 0) return floor(x); 12 | return -floor(-x); 13 | }; 14 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/node_modules/es6-iterator/.lint: -------------------------------------------------------------------------------- 1 | @root 2 | 3 | module 4 | 5 | tabs 6 | indent 2 7 | maxlen 100 8 | 9 | ass 10 | nomen 11 | plusplus 12 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/node_modules/es6-iterator/.npmignore: -------------------------------------------------------------------------------- 1 | .DS_Store 2 | /node_modules 3 | /npm-debug.log 4 | /.lintcache 5 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/node_modules/es6-iterator/.travis.yml: -------------------------------------------------------------------------------- 1 | sudo: false # http://docs.travis-ci.com/user/workers/container-based-infrastructure/ 2 | language: node_js 3 | node_js: 4 | - 0.12 5 | - 4 6 | 7 | notifications: 8 | email: 9 | - medikoo+es6-iterator@medikoo.com 10 | 11 | script: "npm test && npm run lint" 12 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/node_modules/es6-iterator/valid-iterable.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | var isIterable = require('./is-iterable'); 4 | 5 | module.exports = function (value) { 6 | if (!isIterable(value)) throw new TypeError(value + " is not iterable"); 7 | return value; 8 | }; 9 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/node_modules/es6-symbol/.lint: -------------------------------------------------------------------------------- 1 | @root 2 | 3 | module 4 | 5 | tabs 6 | indent 2 7 | maxlen 100 8 | 9 | ass 10 | nomen 11 | plusplus 12 | newcap 13 | vars 14 | 15 | predef+ Symbol 16 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/node_modules/es6-symbol/.npmignore: -------------------------------------------------------------------------------- 1 | .DS_Store 2 | /node_modules 3 | /npm-debug.log 4 | /.lintcache 5 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/node_modules/es6-symbol/.travis.yml: -------------------------------------------------------------------------------- 1 | sudo: false # http://docs.travis-ci.com/user/workers/container-based-infrastructure/ 2 | language: node_js 3 | node_js: 4 | - 0.12 5 | - v4 6 | - v5 7 | 8 | notifications: 9 | email: 10 | - medikoo+es6-symbol@medikoo.com 11 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/node_modules/es6-symbol/implement.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | if (!require('./is-implemented')()) { 4 | Object.defineProperty(require('es5-ext/global'), 'Symbol', 5 | { value: require('./polyfill'), configurable: true, enumerable: false, 6 | writable: true }); 7 | } 8 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/node_modules/es6-symbol/index.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | module.exports = require('./is-implemented')() ? Symbol : require('./polyfill'); 4 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/node_modules/es6-symbol/is-native-implemented.js: -------------------------------------------------------------------------------- 1 | // Exports true if environment provides native `Symbol` implementation 2 | 3 | 'use strict'; 4 | 5 | module.exports = (function () { 6 | if (typeof Symbol !== 'function') return false; 7 | return (typeof Symbol.iterator === 'symbol'); 8 | }()); 9 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/node_modules/es6-symbol/is-symbol.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | module.exports = function (x) { 4 | return (x && ((typeof x === 'symbol') || (x['@@toStringTag'] === 'Symbol'))) || false; 5 | }; 6 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/node_modules/es6-symbol/test/implement.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | module.exports = function (t, a) { a(typeof Symbol, 'function'); }; 4 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/node_modules/es6-symbol/test/index.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | var d = require('d') 4 | 5 | , defineProperty = Object.defineProperty; 6 | 7 | module.exports = function (T, a) { 8 | var symbol = T('test'), x = {}; 9 | defineProperty(x, symbol, d('foo')); 10 | a(x.test, undefined, "Name"); 11 | a(x[symbol], 'foo', "Get"); 12 | }; 13 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/node_modules/es6-symbol/test/is-native-implemented.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | module.exports = function (t, a) { a(typeof t, 'boolean'); }; 4 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/node_modules/es6-symbol/validate-symbol.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | var isSymbol = require('./is-symbol'); 4 | 5 | module.exports = function (value) { 6 | if (!isSymbol(value)) throw new TypeError(value + " is not a symbol"); 7 | return value; 8 | }; 9 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/number/#/index.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | module.exports = { 4 | pad: require('./pad') 5 | }; 6 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/number/epsilon/implement.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | if (!require('./is-implemented')()) { 4 | Object.defineProperty(Number, 'EPSILON', { value: require('./'), 5 | configurable: false, enumerable: false, writable: false }); 6 | } 7 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/number/epsilon/index.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | module.exports = 2.220446049250313e-16; 4 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/number/epsilon/is-implemented.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | module.exports = function () { 4 | return (typeof Number.EPSILON === 'number'); 5 | }; 6 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/number/is-finite/implement.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | if (!require('./is-implemented')()) { 4 | Object.defineProperty(Number, 'isFinite', { value: require('./shim'), 5 | configurable: true, enumerable: false, writable: true }); 6 | } 7 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/number/is-finite/index.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | module.exports = require('./is-implemented')() 4 | ? Number.isFinite 5 | : require('./shim'); 6 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/number/is-finite/is-implemented.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | module.exports = function () { 4 | var isFinite = Number.isFinite; 5 | if (typeof isFinite !== 'function') return false; 6 | return !isFinite('23') && isFinite(34) && !isFinite(Infinity); 7 | }; 8 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/number/is-finite/shim.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | module.exports = function (value) { 4 | return (typeof value === 'number') && isFinite(value); 5 | }; 6 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/number/is-integer/implement.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | if (!require('./is-implemented')()) { 4 | Object.defineProperty(Number, 'isInteger', { value: require('./shim'), 5 | configurable: true, enumerable: false, writable: true }); 6 | } 7 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/number/is-integer/index.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | module.exports = require('./is-implemented')() 4 | ? Number.isInteger 5 | : require('./shim'); 6 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/number/is-integer/is-implemented.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | module.exports = function () { 4 | var isInteger = Number.isInteger; 5 | if (typeof isInteger !== 'function') return false; 6 | return !isInteger('23') && isInteger(34) && !isInteger(32.34); 7 | }; 8 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/number/is-integer/shim.js: -------------------------------------------------------------------------------- 1 | // Credit: http://www.2ality.com/2014/05/is-integer.html 2 | 3 | 'use strict'; 4 | 5 | module.exports = function (value) { 6 | if (typeof value !== 'number') return false; 7 | return (value % 1 === 0); 8 | }; 9 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/number/is-nan/implement.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | if (!require('./is-implemented')()) { 4 | Object.defineProperty(Number, 'isNaN', { value: require('./shim'), 5 | configurable: true, enumerable: false, writable: true }); 6 | } 7 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/number/is-nan/index.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | module.exports = require('./is-implemented')() 4 | ? Number.isNaN 5 | : require('./shim'); 6 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/number/is-nan/is-implemented.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | module.exports = function () { 4 | var isNaN = Number.isNaN; 5 | if (typeof isNaN !== 'function') return false; 6 | return !isNaN({}) && isNaN(NaN) && !isNaN(34); 7 | }; 8 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/number/is-nan/shim.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | module.exports = function (value) { return (value !== value); } //jslint: ignore 4 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/number/is-natural.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | var isInteger = require('./is-integer'); 4 | 5 | module.exports = function (num) { return isInteger(num) && (num >= 0); }; 6 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/number/is-number.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | var toString = Object.prototype.toString 4 | 5 | , id = toString.call(1); 6 | 7 | module.exports = function (x) { 8 | return ((typeof x === 'number') || 9 | ((x instanceof Number) || 10 | ((typeof x === 'object') && (toString.call(x) === id)))); 11 | }; 12 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/number/is-safe-integer/implement.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | if (!require('./is-implemented')()) { 4 | Object.defineProperty(Number, 'isSafeInteger', { value: require('./shim'), 5 | configurable: true, enumerable: false, writable: true }); 6 | } 7 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/number/is-safe-integer/index.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | module.exports = require('./is-implemented')() 4 | ? Number.isSafeInteger 5 | : require('./shim'); 6 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/number/is-safe-integer/is-implemented.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | module.exports = function () { 4 | var isSafeInteger = Number.isSafeInteger; 5 | if (typeof isSafeInteger !== 'function') return false; 6 | return !isSafeInteger('23') && isSafeInteger(34232322323) && 7 | !isSafeInteger(9007199254740992); 8 | }; 9 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/number/is-safe-integer/shim.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | var isInteger = require('../is-integer/shim') 4 | , maxValue = require('../max-safe-integer') 5 | 6 | , abs = Math.abs; 7 | 8 | module.exports = function (value) { 9 | if (!isInteger(value)) return false; 10 | return abs(value) <= maxValue; 11 | }; 12 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/number/max-safe-integer/implement.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | if (!require('./is-implemented')()) { 4 | Object.defineProperty(Number, 'MAX_SAFE_INTEGER', { value: require('./'), 5 | configurable: false, enumerable: false, writable: false }); 6 | } 7 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/number/max-safe-integer/index.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | module.exports = Math.pow(2, 53) - 1; 4 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/number/max-safe-integer/is-implemented.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | module.exports = function () { 4 | return (typeof Number.MAX_SAFE_INTEGER === 'number'); 5 | }; 6 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/number/min-safe-integer/implement.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | if (!require('./is-implemented')()) { 4 | Object.defineProperty(Number, 'MIN_SAFE_INTEGER', { value: require('./'), 5 | configurable: false, enumerable: false, writable: false }); 6 | } 7 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/number/min-safe-integer/index.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | module.exports = -(Math.pow(2, 53) - 1); 4 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/number/min-safe-integer/is-implemented.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | module.exports = function () { 4 | return (typeof Number.MIN_SAFE_INTEGER === 'number'); 5 | }; 6 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/number/to-pos-integer.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | var toInteger = require('./to-integer') 4 | 5 | , max = Math.max; 6 | 7 | module.exports = function (value) { return max(0, toInteger(value)); }; 8 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/number/to-uint32.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | module.exports = function (value) { return value >>> 0; }; 4 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/object/assign/implement.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | if (!require('./is-implemented')()) { 4 | Object.defineProperty(Object, 'assign', { value: require('./shim'), 5 | configurable: true, enumerable: false, writable: true }); 6 | } 7 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/object/assign/index.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | module.exports = require('./is-implemented')() 4 | ? Object.assign 5 | : require('./shim'); 6 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/object/assign/is-implemented.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | module.exports = function () { 4 | var assign = Object.assign, obj; 5 | if (typeof assign !== 'function') return false; 6 | obj = { foo: 'raz' }; 7 | assign(obj, { bar: 'dwa' }, { trzy: 'trzy' }); 8 | return (obj.foo + obj.bar + obj.trzy) === 'razdwatrzy'; 9 | }; 10 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/object/compact.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | var filter = require('./filter'); 4 | 5 | module.exports = function (obj) { 6 | return filter(obj, function (val) { return val != null; }); 7 | }; 8 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/object/copy.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | var assign = require('./assign') 4 | , value = require('./valid-value'); 5 | 6 | module.exports = function (obj) { 7 | var copy = Object(value(obj)); 8 | if (copy !== obj) return copy; 9 | return assign({}, obj); 10 | }; 11 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/object/count.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | var keys = require('./keys'); 4 | 5 | module.exports = function (obj) { return keys(obj).length; }; 6 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/object/ensure-natural-number-value.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | var ensure = require('./ensure-natural-number'); 4 | 5 | module.exports = function (arg) { 6 | if (arg == null) throw new TypeError(arg + " is not a natural number"); 7 | return ensure(arg); 8 | }; 9 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/object/ensure-natural-number.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | var isNatural = require('../number/is-natural'); 4 | 5 | module.exports = function (arg) { 6 | var num = Number(arg); 7 | if (!isNatural(num)) throw new TypeError(arg + " is not a natural number"); 8 | return num; 9 | }; 10 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/object/eq.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | module.exports = function (x, y) { 4 | return ((x === y) || ((x !== x) && (y !== y))); //jslint: ignore 5 | }; 6 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/object/every.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | module.exports = require('./_iterate')('every', true); 4 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/object/find-key.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | module.exports = require('./_iterate')(require('../array/#/find'), false); 4 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/object/find.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | var findKey = require('./find-key'); 4 | 5 | module.exports = function (obj, cb/*, thisArg, compareFn*/) { 6 | var key = findKey.apply(this, arguments); 7 | return (key == null) ? key : obj[key]; 8 | }; 9 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/object/first-key.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | var value = require('./valid-value') 4 | 5 | , propertyIsEnumerable = Object.prototype.propertyIsEnumerable; 6 | 7 | module.exports = function (obj) { 8 | var i; 9 | value(obj); 10 | for (i in obj) { 11 | if (propertyIsEnumerable.call(obj, i)) return i; 12 | } 13 | return null; 14 | }; 15 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/object/for-each.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | module.exports = require('./_iterate')('forEach'); 4 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/object/is-callable.js: -------------------------------------------------------------------------------- 1 | // Deprecated 2 | 3 | 'use strict'; 4 | 5 | module.exports = function (obj) { return typeof obj === 'function'; }; 6 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/object/is-number-value.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | module.exports = function (value) { return (value != null) && !isNaN(value); }; 4 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/object/is-object.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | var map = { function: true, object: true }; 4 | 5 | module.exports = function (x) { 6 | return ((x != null) && map[typeof x]) || false; 7 | }; 8 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/object/is.js: -------------------------------------------------------------------------------- 1 | // Implementation credits go to: 2 | // http://wiki.ecmascript.org/doku.php?id=harmony:egal 3 | 4 | 'use strict'; 5 | 6 | module.exports = function (x, y) { 7 | return (x === y) ? 8 | ((x !== 0) || ((1 / x) === (1 / y))) : 9 | ((x !== x) && (y !== y)); //jslint: ignore 10 | }; 11 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/object/keys/implement.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | if (!require('./is-implemented')()) { 4 | Object.defineProperty(Object, 'keys', { value: require('./shim'), 5 | configurable: true, enumerable: false, writable: true }); 6 | } 7 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/object/keys/index.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | module.exports = require('./is-implemented')() 4 | ? Object.keys 5 | : require('./shim'); 6 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/object/keys/is-implemented.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | module.exports = function () { 4 | try { 5 | Object.keys('primitive'); 6 | return true; 7 | } catch (e) { return false; } 8 | }; 9 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/object/keys/shim.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | var keys = Object.keys; 4 | 5 | module.exports = function (object) { 6 | return keys(object == null ? object : Object(object)); 7 | }; 8 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/object/primitive-set.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | var forEach = Array.prototype.forEach, create = Object.create; 4 | 5 | module.exports = function (arg/*, …args*/) { 6 | var set = create(null); 7 | forEach.call(arguments, function (name) { set[name] = true; }); 8 | return set; 9 | }; 10 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/object/set-prototype-of/implement.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | var shim; 4 | 5 | if (!require('./is-implemented')() && (shim = require('./shim'))) { 6 | Object.defineProperty(Object, 'setPrototypeOf', 7 | { value: shim, configurable: true, enumerable: false, writable: true }); 8 | } 9 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/object/set-prototype-of/index.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | module.exports = require('./is-implemented')() 4 | ? Object.setPrototypeOf 5 | : require('./shim'); 6 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/object/some.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | module.exports = require('./_iterate')('some', false); 4 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/object/unserialize.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | var value = require('./valid-value'); 4 | 5 | module.exports = exports = function (code) { 6 | return (new Function('return ' + value(code)))(); 7 | }; 8 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/object/valid-callable.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | module.exports = function (fn) { 4 | if (typeof fn !== 'function') throw new TypeError(fn + " is not a function"); 5 | return fn; 6 | }; 7 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/object/valid-object.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | var isObject = require('./is-object'); 4 | 5 | module.exports = function (value) { 6 | if (!isObject(value)) throw new TypeError(value + " is not an Object"); 7 | return value; 8 | }; 9 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/object/valid-value.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | module.exports = function (value) { 4 | if (value == null) throw new TypeError("Cannot use null or undefined"); 5 | return value; 6 | }; 7 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/object/validate-array-like-object.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | var isArrayLike = require('./is-array-like') 4 | , isObject = require('./is-object'); 5 | 6 | module.exports = function (obj) { 7 | if (isObject(obj) && isArrayLike(obj)) return obj; 8 | throw new TypeError(obj + " is not array-like object"); 9 | }; 10 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/object/validate-array-like.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | var isArrayLike = require('./is-array-like'); 4 | 5 | module.exports = function (obj) { 6 | if (isArrayLike(obj)) return obj; 7 | throw new TypeError(obj + " is not array-like value"); 8 | }; 9 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/object/validate-stringifiable-value.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | var value = require('./valid-value') 4 | , stringifiable = require('./validate-stringifiable'); 5 | 6 | module.exports = function (x) { return stringifiable(value(x)); }; 7 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/object/validate-stringifiable.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | module.exports = function (stringifiable) { 4 | try { 5 | return String(stringifiable); 6 | } catch (e) { 7 | throw new TypeError("Passed argument cannot be stringifed"); 8 | } 9 | }; 10 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/reg-exp/#/index.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | module.exports = { 4 | isSticky: require('./is-sticky'), 5 | isUnicode: require('./is-unicode'), 6 | match: require('./match'), 7 | replace: require('./replace'), 8 | search: require('./search'), 9 | split: require('./split') 10 | }; 11 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/reg-exp/#/is-sticky.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | var validRegExp = require('../valid-reg-exp') 4 | 5 | , re = /\/[a-xz]*y[a-xz]*$/; 6 | 7 | module.exports = function () { 8 | return Boolean(String(validRegExp(this)).match(re)); 9 | }; 10 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/reg-exp/#/is-unicode.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | var validRegExp = require('../valid-reg-exp') 4 | 5 | , re = /\/[a-xz]*u[a-xz]*$/; 6 | 7 | module.exports = function () { 8 | return Boolean(String(validRegExp(this)).match(re)); 9 | }; 10 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/reg-exp/#/match/implement.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | if (!require('./is-implemented')()) { 4 | Object.defineProperty(RegExp.prototype, 'match', { value: require('./shim'), 5 | configurable: true, enumerable: false, writable: true }); 6 | } 7 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/reg-exp/#/match/index.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | module.exports = require('./is-implemented')() 4 | ? RegExp.prototype.match 5 | : require('./shim'); 6 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/reg-exp/#/match/is-implemented.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | var re = /foo/; 4 | 5 | module.exports = function () { 6 | if (typeof re.match !== 'function') return false; 7 | return re.match('barfoobar') && !re.match('elo'); 8 | }; 9 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/reg-exp/#/match/shim.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | var validRegExp = require('../../valid-reg-exp'); 4 | 5 | module.exports = function (string) { 6 | validRegExp(this); 7 | return String(string).match(this); 8 | }; 9 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/reg-exp/#/replace/implement.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | if (!require('./is-implemented')()) { 4 | Object.defineProperty(RegExp.prototype, 'replace', { value: require('./shim'), 5 | configurable: true, enumerable: false, writable: true }); 6 | } 7 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/reg-exp/#/replace/index.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | module.exports = require('./is-implemented')() 4 | ? RegExp.prototype.replace 5 | : require('./shim'); 6 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/reg-exp/#/replace/is-implemented.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | var re = /foo/; 4 | 5 | module.exports = function () { 6 | if (typeof re.replace !== 'function') return false; 7 | return re.replace('foobar', 'mar') === 'marbar'; 8 | }; 9 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/reg-exp/#/replace/shim.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | var validRegExp = require('../../valid-reg-exp'); 4 | 5 | module.exports = function (string, replaceValue) { 6 | validRegExp(this); 7 | return String(string).replace(this, replaceValue); 8 | }; 9 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/reg-exp/#/search/implement.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | if (!require('./is-implemented')()) { 4 | Object.defineProperty(RegExp.prototype, 'search', { value: require('./shim'), 5 | configurable: true, enumerable: false, writable: true }); 6 | } 7 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/reg-exp/#/search/index.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | module.exports = require('./is-implemented')() 4 | ? RegExp.prototype.search 5 | : require('./shim'); 6 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/reg-exp/#/search/is-implemented.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | var re = /foo/; 4 | 5 | module.exports = function () { 6 | if (typeof re.search !== 'function') return false; 7 | return re.search('barfoo') === 3; 8 | }; 9 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/reg-exp/#/search/shim.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | var validRegExp = require('../../valid-reg-exp'); 4 | 5 | module.exports = function (string) { 6 | validRegExp(this); 7 | return String(string).search(this); 8 | }; 9 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/reg-exp/#/split/implement.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | if (!require('./is-implemented')()) { 4 | Object.defineProperty(RegExp.prototype, 'split', { value: require('./shim'), 5 | configurable: true, enumerable: false, writable: true }); 6 | } 7 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/reg-exp/#/split/index.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | module.exports = require('./is-implemented')() 4 | ? RegExp.prototype.split 5 | : require('./shim'); 6 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/reg-exp/#/split/is-implemented.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | var re = /\|/; 4 | 5 | module.exports = function () { 6 | if (typeof re.split !== 'function') return false; 7 | return re.split('bar|foo')[1] === 'foo'; 8 | }; 9 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/reg-exp/#/split/shim.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | var validRegExp = require('../../valid-reg-exp'); 4 | 5 | module.exports = function (string) { 6 | validRegExp(this); 7 | return String(string).split(this); 8 | }; 9 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/reg-exp/#/sticky/implement.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | var isSticky = require('../is-sticky'); 4 | 5 | if (!require('./is-implemented')()) { 6 | Object.defineProperty(RegExp.prototype, 'sticky', { configurable: true, 7 | enumerable: false, get: isSticky }); 8 | } 9 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/reg-exp/#/unicode/implement.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | var isUnicode = require('../is-unicode'); 4 | 5 | if (!require('./is-implemented')()) { 6 | Object.defineProperty(RegExp.prototype, 'unicode', { configurable: true, 7 | enumerable: false, get: isUnicode }); 8 | } 9 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/reg-exp/escape.js: -------------------------------------------------------------------------------- 1 | // Thanks to Andrew Clover: 2 | // http://stackoverflow.com/questions/3561493 3 | // /is-there-a-regexp-escape-function-in-javascript 4 | 5 | 'use strict'; 6 | 7 | var re = /[\-\/\\\^$*+?.()|\[\]{}]/g; 8 | 9 | module.exports = function (str) { return String(str).replace(re, '\\$&'); }; 10 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/reg-exp/index.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | module.exports = { 4 | '#': require('./#'), 5 | escape: require('./escape'), 6 | isRegExp: require('./is-reg-exp'), 7 | validRegExp: require('./valid-reg-exp') 8 | }; 9 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/reg-exp/is-reg-exp.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | var toString = Object.prototype.toString 4 | 5 | , id = toString.call(/a/); 6 | 7 | module.exports = function (x) { 8 | return (x && (x instanceof RegExp || (toString.call(x) === id))) || false; 9 | }; 10 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/reg-exp/valid-reg-exp.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | var isRegExp = require('./is-reg-exp'); 4 | 5 | module.exports = function (x) { 6 | if (!isRegExp(x)) throw new TypeError(x + " is not a RegExp object"); 7 | return x; 8 | }; 9 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/string/#/@@iterator/implement.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | if (!require('./is-implemented')()) { 4 | Object.defineProperty(String.prototype, require('es6-symbol').iterator, 5 | { value: require('./shim'), configurable: true, enumerable: false, writable: true }); 6 | } 7 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/string/#/@@iterator/index.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | module.exports = require('./is-implemented')() 4 | ? String.prototype[require('es6-symbol').iterator] : require('./shim'); 5 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/string/#/@@iterator/shim.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | var StringIterator = require('es6-iterator/string') 4 | , value = require('../../../object/valid-value'); 5 | 6 | module.exports = function () { return new StringIterator(value(this)); }; 7 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/string/#/camel-to-hyphen.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | var replace = String.prototype.replace 4 | , re = /([A-Z])/g; 5 | 6 | module.exports = function () { 7 | var str = replace.call(this, re, "-$1").toLowerCase(); 8 | if (str[0] === '-') str = str.slice(1); 9 | return str; 10 | }; 11 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/string/#/capitalize.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | var value = require('../../object/valid-value'); 4 | 5 | module.exports = function () { 6 | var str = String(value(this)); 7 | return str.charAt(0).toUpperCase() + str.slice(1); 8 | }; 9 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/string/#/case-insensitive-compare.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | var toLowerCase = String.prototype.toLowerCase; 4 | 5 | module.exports = function (other) { 6 | return toLowerCase.call(this).localeCompare(toLowerCase.call(String(other))); 7 | }; 8 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/string/#/code-point-at/implement.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | if (!require('./is-implemented')()) { 4 | Object.defineProperty(String.prototype, 'codePointAt', 5 | { value: require('./shim'), configurable: true, enumerable: false, 6 | writable: true }); 7 | } 8 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/string/#/code-point-at/index.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | module.exports = require('./is-implemented')() 4 | ? String.prototype.codePointAt 5 | : require('./shim'); 6 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/string/#/code-point-at/is-implemented.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | var str = 'abc\uD834\uDF06def'; 4 | 5 | module.exports = function () { 6 | if (typeof str.codePointAt !== 'function') return false; 7 | return str.codePointAt(3) === 0x1D306; 8 | }; 9 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/string/#/contains/implement.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | if (!require('./is-implemented')()) { 4 | Object.defineProperty(String.prototype, 'contains', 5 | { value: require('./shim'), configurable: true, enumerable: false, 6 | writable: true }); 7 | } 8 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/string/#/contains/index.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | module.exports = require('./is-implemented')() 4 | ? String.prototype.contains 5 | : require('./shim'); 6 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/string/#/contains/is-implemented.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | var str = 'razdwatrzy'; 4 | 5 | module.exports = function () { 6 | if (typeof str.contains !== 'function') return false; 7 | return ((str.contains('dwa') === true) && (str.contains('foo') === false)); 8 | }; 9 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/string/#/contains/shim.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | var indexOf = String.prototype.indexOf; 4 | 5 | module.exports = function (searchString/*, position*/) { 6 | return indexOf.call(this, searchString, arguments[1]) > -1; 7 | }; 8 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/string/#/ends-with/implement.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | if (!require('./is-implemented')()) { 4 | Object.defineProperty(String.prototype, 'endsWith', 5 | { value: require('./shim'), configurable: true, enumerable: false, 6 | writable: true }); 7 | } 8 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/string/#/ends-with/index.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | module.exports = require('./is-implemented')() 4 | ? String.prototype.endsWith 5 | : require('./shim'); 6 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/string/#/ends-with/is-implemented.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | var str = 'razdwatrzy'; 4 | 5 | module.exports = function () { 6 | if (typeof str.endsWith !== 'function') return false; 7 | return ((str.endsWith('trzy') === true) && (str.endsWith('raz') === false)); 8 | }; 9 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/string/#/hyphen-to-camel.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | var replace = String.prototype.replace 4 | 5 | , re = /-([a-z0-9])/g 6 | , toUpperCase = function (m, a) { return a.toUpperCase(); }; 7 | 8 | module.exports = function () { return replace.call(this, re, toUpperCase); }; 9 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/string/#/last.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | var value = require('../../object/valid-value'); 4 | 5 | module.exports = function () { 6 | var self = String(value(this)), l = self.length; 7 | return l ? self[l - 1] : null; 8 | }; 9 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/string/#/normalize/implement.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | if (!require('./is-implemented')()) { 4 | Object.defineProperty(String.prototype, 'normalize', 5 | { value: require('./shim'), configurable: true, enumerable: false, 6 | writable: true }); 7 | } 8 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/string/#/normalize/index.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | module.exports = require('./is-implemented')() 4 | ? String.prototype.normalize 5 | : require('./shim'); 6 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/string/#/normalize/is-implemented.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | var str = 'æøåäüö'; 4 | 5 | module.exports = function () { 6 | if (typeof str.normalize !== 'function') return false; 7 | return str.normalize('NFKD') === 'æøåäüö'; 8 | }; 9 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/string/#/repeat/implement.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | if (!require('./is-implemented')()) { 4 | Object.defineProperty(String.prototype, 'repeat', 5 | { value: require('./shim'), configurable: true, enumerable: false, 6 | writable: true }); 7 | } 8 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/string/#/repeat/index.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | module.exports = require('./is-implemented')() 4 | ? String.prototype.repeat 5 | : require('./shim'); 6 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/string/#/repeat/is-implemented.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | var str = 'foo'; 4 | 5 | module.exports = function () { 6 | if (typeof str.repeat !== 'function') return false; 7 | return (str.repeat(2) === 'foofoo'); 8 | }; 9 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/string/#/starts-with/implement.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | if (!require('./is-implemented')()) { 4 | Object.defineProperty(String.prototype, 'startsWith', 5 | { value: require('./shim'), configurable: true, enumerable: false, 6 | writable: true }); 7 | } 8 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/string/#/starts-with/index.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | module.exports = require('./is-implemented')() 4 | ? String.prototype.startsWith 5 | : require('./shim'); 6 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/string/#/starts-with/is-implemented.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | var str = 'razdwatrzy'; 4 | 5 | module.exports = function () { 6 | if (typeof str.startsWith !== 'function') return false; 7 | return ((str.startsWith('trzy') === false) && 8 | (str.startsWith('raz') === true)); 9 | }; 10 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/string/#/uncapitalize.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | var ensureStringifiable = require('../../object/validate-stringifiable-value'); 4 | 5 | module.exports = function () { 6 | var str = ensureStringifiable(this); 7 | return str.charAt(0).toLowerCase() + str.slice(1); 8 | }; 9 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/string/from-code-point/implement.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | if (!require('./is-implemented')()) { 4 | Object.defineProperty(String, 'fromCodePoint', { value: require('./shim'), 5 | configurable: true, enumerable: false, writable: true }); 6 | } 7 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/string/from-code-point/index.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | module.exports = require('./is-implemented')() 4 | ? String.fromCodePoint 5 | : require('./shim'); 6 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/string/from-code-point/is-implemented.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | module.exports = function () { 4 | var fromCodePoint = String.fromCodePoint; 5 | if (typeof fromCodePoint !== 'function') return false; 6 | return fromCodePoint(0x1D306, 0x61, 0x1D307) === '\ud834\udf06a\ud834\udf07'; 7 | }; 8 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/string/index.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | module.exports = { 4 | '#': require('./#'), 5 | formatMethod: require('./format-method'), 6 | fromCodePoint: require('./from-code-point'), 7 | isString: require('./is-string'), 8 | randomUniq: require('./random-uniq'), 9 | raw: require('./raw') 10 | }; 11 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/string/is-string.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | var toString = Object.prototype.toString 4 | 5 | , id = toString.call(''); 6 | 7 | module.exports = function (x) { 8 | return (typeof x === 'string') || (x && (typeof x === 'object') && 9 | ((x instanceof String) || (toString.call(x) === id))) || false; 10 | }; 11 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/string/random-uniq.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | var generated = Object.create(null) 4 | 5 | , random = Math.random; 6 | 7 | module.exports = function () { 8 | var str; 9 | do { str = random().toString(36).slice(2); } while (generated[str]); 10 | return str; 11 | }; 12 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/string/raw/implement.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | if (!require('./is-implemented')()) { 4 | Object.defineProperty(String, 'raw', { value: require('./shim'), 5 | configurable: true, enumerable: false, writable: true }); 6 | } 7 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/string/raw/index.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | module.exports = require('./is-implemented')() 4 | ? String.raw 5 | : require('./shim'); 6 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/string/raw/is-implemented.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | module.exports = function () { 4 | var raw = String.raw, test; 5 | if (typeof raw !== 'function') return false; 6 | test = ['foo\nbar', 'marko\n']; 7 | test.raw = ['foo\\nbar', 'marko\\n']; 8 | return raw(test, 'INSE\nRT') === 'foo\\nbarINSE\nRTmarko\\n'; 9 | }; 10 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/test/__tad.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | exports.context = null; 4 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/test/array/#/@@iterator/implement.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | var isImplemented = require('../../../../array/#/@@iterator/is-implemented'); 4 | 5 | module.exports = function (a) { a(isImplemented(), true); }; 6 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/test/array/#/@@iterator/index.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | module.exports = require('./shim'); 4 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/test/array/#/@@iterator/is-implemented.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | module.exports = function (t, a) { a(typeof t(), 'boolean'); }; 4 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/test/array/#/_compare-by-length.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | module.exports = function (t, a) { 4 | var x = [4, 5, 6], y = { length: 8 }, w = {}, z = { length: 1 }; 5 | 6 | a.deep([x, y, w, z].sort(t), [w, z, x, y]); 7 | }; 8 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/test/array/#/clear.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | module.exports = function (t, a) { 4 | var x = [1, 2, {}, 4]; 5 | a(t.call(x), x, "Returns same array"); 6 | a.deep(x, [], "Empties array"); 7 | }; 8 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/test/array/#/concat/implement.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | var isImplemented = require('../../../../array/#/concat/is-implemented'); 4 | 5 | module.exports = function (a) { a(isImplemented(), true); }; 6 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/test/array/#/concat/index.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | module.exports = require('./shim'); 4 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/test/array/#/concat/is-implemented.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | module.exports = function (t, a) { a(typeof t(), 'boolean'); }; 4 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/test/array/#/copy-within/implement.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | var isImplemented = require('../../../../array/#/copy-within/is-implemented'); 4 | 5 | module.exports = function (a) { a(isImplemented(), true); }; 6 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/test/array/#/copy-within/index.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | module.exports = require('./shim'); 4 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/test/array/#/copy-within/is-implemented.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | module.exports = function (t, a) { a(typeof t(), 'boolean'); }; 4 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/test/array/#/entries/implement.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | var isImplemented = require('../../../../array/#/entries/is-implemented'); 4 | 5 | module.exports = function (a) { a(isImplemented(), true); }; 6 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/test/array/#/entries/index.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | module.exports = require('./shim'); 4 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/test/array/#/entries/is-implemented.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | module.exports = function (t, a) { a(typeof t(), 'boolean'); }; 4 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/test/array/#/fill/implement.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | var isImplemented = require('../../../../array/#/fill/is-implemented'); 4 | 5 | module.exports = function (a) { a(isImplemented(), true); }; 6 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/test/array/#/fill/index.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | module.exports = require('./shim'); 4 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/test/array/#/fill/is-implemented.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | module.exports = function (t, a) { a(typeof t(), 'boolean'); }; 4 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/test/array/#/filter/implement.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | var isImplemented = require('../../../../array/#/filter/is-implemented'); 4 | 5 | module.exports = function (a) { a(isImplemented(), true); }; 6 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/test/array/#/filter/index.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | module.exports = require('./shim'); 4 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/test/array/#/filter/is-implemented.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | module.exports = function (t, a) { a(typeof t(), 'boolean'); }; 4 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/test/array/#/find-index/implement.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | var isImplemented = require('../../../../array/#/find-index/is-implemented'); 4 | 5 | module.exports = function (a) { a(isImplemented(), true); }; 6 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/test/array/#/find-index/index.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | module.exports = require('./shim'); 4 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/test/array/#/find-index/is-implemented.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | module.exports = function (t, a) { a(typeof t(), 'boolean'); }; 4 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/test/array/#/find/implement.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | var isImplemented = require('../../../../array/#/find/is-implemented'); 4 | 5 | module.exports = function (a) { a(isImplemented(), true); }; 6 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/test/array/#/find/index.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | module.exports = require('./shim'); 4 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/test/array/#/find/is-implemented.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | module.exports = function (t, a) { a(typeof t(), 'boolean'); }; 4 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/test/array/#/flatten.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | var o = [1, 2, [3, 4, [5, 6], 7, 8], 9, 10]; 4 | 5 | module.exports = { 6 | __generic: function (t, a) { 7 | a(t.call(this).length, 3); 8 | }, 9 | "Nested Arrays": function (t, a) { 10 | a(t.call(o).length, 10); 11 | } 12 | }; 13 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/test/array/#/keys/implement.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | var isImplemented = require('../../../../array/#/keys/is-implemented'); 4 | 5 | module.exports = function (a) { a(isImplemented(), true); }; 6 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/test/array/#/keys/index.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | module.exports = require('./shim'); 4 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/test/array/#/keys/is-implemented.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | module.exports = function (t, a) { a(typeof t(), 'boolean'); }; 4 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/test/array/#/map/implement.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | var isImplemented = require('../../../../array/#/map/is-implemented'); 4 | 5 | module.exports = function (a) { a(isImplemented(), true); }; 6 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/test/array/#/map/index.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | module.exports = require('./shim'); 4 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/test/array/#/map/is-implemented.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | module.exports = function (t, a) { a(typeof t(), 'boolean'); }; 4 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/test/array/#/slice/implement.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | var isImplemented = require('../../../../array/#/slice/is-implemented'); 4 | 5 | module.exports = function (a) { a(isImplemented(), true); }; 6 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/test/array/#/slice/index.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | module.exports = require('./shim'); 4 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/test/array/#/slice/is-implemented.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | module.exports = function (t, a) { a(typeof t(), 'boolean'); }; 4 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/test/array/#/splice/implement.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | var isImplemented = require('../../../../array/#/splice/is-implemented'); 4 | 5 | module.exports = function (a) { a(isImplemented(), true); }; 6 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/test/array/#/splice/index.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | module.exports = require('./shim'); 4 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/test/array/#/splice/is-implemented.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | module.exports = function (t, a) { a(typeof t(), 'boolean'); }; 4 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/test/array/#/values/implement.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | var isImplemented = require('../../../../array/#/values/is-implemented'); 4 | 5 | module.exports = function (a) { a(isImplemented(), true); }; 6 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/test/array/#/values/index.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | module.exports = require('./shim'); 4 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/test/array/#/values/is-implemented.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | module.exports = function (t, a) { a(typeof t(), 'boolean'); }; 4 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/test/array/__scopes.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | exports.Array = ['1', '2', '3']; 4 | 5 | exports.Arguments = (function () { 6 | return arguments; 7 | }('1', '2', '3')); 8 | 9 | exports.String = "123"; 10 | 11 | exports.Object = { 0: '1', 1: '2', 2: '3', 3: '4', length: 3 }; 12 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/test/array/_is-extensible.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | module.exports = function (t, a) { 4 | a(typeof t, 'boolean'); 5 | }; 6 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/test/array/_sub-array-dummy-safe.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | var isArray = Array.isArray; 4 | 5 | module.exports = function (t, a) { 6 | t((t === null) || isArray(t.prototype), true); 7 | }; 8 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/test/array/_sub-array-dummy.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | var isArray = Array.isArray; 4 | 5 | module.exports = function (t, a) { 6 | t((t === null) || isArray(t.prototype), true); 7 | }; 8 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/test/array/from/implement.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | var isImplemented = require('../../../array/from/is-implemented'); 4 | 5 | module.exports = function (a) { a(isImplemented(), true); }; 6 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/test/array/from/index.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | module.exports = require('./shim'); 4 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/test/array/from/is-implemented.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | module.exports = function (t, a) { a(typeof t(), 'boolean'); }; 4 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/test/array/of/implement.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | var isImplemented = require('../../../array/of/is-implemented'); 4 | 5 | module.exports = function (a) { a(isImplemented(), true); }; 6 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/test/array/of/index.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | module.exports = require('./shim'); 4 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/test/array/of/is-implemented.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | module.exports = function (t, a) { a(typeof t(), 'boolean'); }; 4 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/test/date/#/copy.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | module.exports = function (t, a) { 4 | var o = new Date(), o2; 5 | 6 | o2 = t.call(o); 7 | a.not(o, o2, "Different objects"); 8 | a.ok(o2 instanceof Date, "Instance of Date"); 9 | a(o.getTime(), o2.getTime(), "Same time"); 10 | }; 11 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/test/date/#/floor-day.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | module.exports = function (t, a) { 4 | a(t.call(new Date(2000, 0, 1, 13, 32, 34, 234)).valueOf(), 5 | new Date(2000, 0, 1).valueOf()); 6 | }; 7 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/test/date/#/floor-month.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | module.exports = function (t, a) { 4 | a(t.call(new Date(2000, 0, 15, 13, 32, 34, 234)).valueOf(), 5 | new Date(2000, 0, 1).valueOf()); 6 | }; 7 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/test/date/#/floor-year.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | module.exports = function (t, a) { 4 | a(t.call(new Date(2000, 5, 13, 13, 32, 34, 234)).valueOf(), 5 | new Date(2000, 0, 1).valueOf()); 6 | }; 7 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/test/date/#/format.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | module.exports = function (t, a) { 4 | var dt = new Date(2011, 2, 3, 3, 5, 5, 32); 5 | a(t.call(dt, ' %Y.%y.%m.%d.%H.%M.%S.%L '), ' 2011.11.03.03.03.05.05.032 '); 6 | }; 7 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/test/date/is-date.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | module.exports = function (t, a) { 4 | a(t('arar'), false, "String"); 5 | a(t(12), false, "Number"); 6 | a(t(true), false, "Boolean"); 7 | a(t(new Date()), true, "Date"); 8 | a(t(new String('raz')), false, "String object"); 9 | a(t({}), false, "Plain object"); 10 | }; 11 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/test/date/valid-date.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | module.exports = function (t, a) { 4 | var d = new Date(); 5 | a(t(d), d, "Date"); 6 | a.throws(function () { 7 | t({}); 8 | }, "Object"); 9 | a.throws(function () { 10 | t({ valueOf: function () { return 20; } }); 11 | }, "Number object"); 12 | }; 13 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/test/error/#/throw.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | module.exports = function (t, a) { 4 | var e = new Error(); 5 | try { 6 | t.call(e); 7 | } catch (e2) { 8 | a(e2, e); 9 | } 10 | }; 11 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/test/error/valid-error.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | module.exports = function (t, a) { 4 | var e = new Error(); 5 | a(t(e), e, "Error"); 6 | a.throws(function () { 7 | t({}); 8 | }, "Other"); 9 | }; 10 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/test/function/#/lock.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | module.exports = function (t, a) { 4 | a(t.call(function () { 5 | return arguments.length; 6 | })(1, 2, 3), 0); 7 | }; 8 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/test/function/#/partial.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | var toArray = require('../../../array/to-array') 4 | 5 | , f = function () { return toArray(arguments); }; 6 | 7 | module.exports = function (t, a) { 8 | a.deep(t.call(f, 1)(2, 3), [1, 2, 3]); 9 | }; 10 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/test/function/#/spread.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | var f = function (a, b) { return this[a] + this[b]; } 4 | , o = { a: 3, b: 4 }; 5 | 6 | module.exports = function (t, a) { 7 | a(t.call(f).call(o, ['a', 'b']), 7); 8 | }; 9 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/test/function/constant.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | var o = {}; 4 | 5 | module.exports = function (t, a) { 6 | a(t(o)(), o); 7 | }; 8 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/test/function/identity.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | var o = {}; 4 | 5 | module.exports = function (t, a) { 6 | a(t(o), o); 7 | }; 8 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/test/function/invoke.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | var constant = require('../../function/constant') 4 | 5 | , o = { b: constant('c') }; 6 | 7 | module.exports = function (t, a) { 8 | a(t('b')(o), 'c'); 9 | }; 10 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/test/function/is-function.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | var o = { call: Function.prototype.call, apply: Function.prototype.apply }; 4 | 5 | module.exports = function (t, a) { 6 | a(t(function () {}), true, "Function is function"); 7 | a(t(o), false, "Plain object is not function"); 8 | }; 9 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/test/function/noop.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | module.exports = function (t, a) { 4 | a(typeof t(1, 2, 3), 'undefined'); 5 | }; 6 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/test/function/pluck.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | var o = { foo: 'bar' }; 4 | 5 | module.exports = function (t, a) { 6 | a(t('foo')(o), o.foo); 7 | }; 8 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/test/global.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | module.exports = function (t, a) { 4 | a.ok(t && typeof t === 'object'); 5 | }; 6 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/test/math/_pack-ieee754.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | module.exports = function (t, a) { 4 | a.deep(t(1.337, 8, 23), [63, 171, 34, 209]); 5 | }; 6 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/test/math/_unpack-ieee754.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | module.exports = function (t, a) { 4 | a.deep(t([63, 171, 34, 209], 8, 23), 1.3370000123977661); 5 | }; 6 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/test/math/acosh/implement.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | var isImplemented = require('../../../math/acosh/is-implemented'); 4 | 5 | module.exports = function (a) { a(isImplemented(), true); }; 6 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/test/math/acosh/index.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | module.exports = require('./shim'); 4 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/test/math/acosh/is-implemented.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | module.exports = function (t, a) { a(typeof t(), 'boolean'); }; 4 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/test/math/acosh/shim.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | module.exports = function (t, a) { 4 | a(t({}), NaN, "NaN"); 5 | a(t(-1), NaN, "Negative"); 6 | a(t(0), NaN, "Zero"); 7 | a(t(0.5), NaN, "Below 1"); 8 | a(t(1), 0, "1"); 9 | a(t(2), 1.3169578969248166, "Other"); 10 | a(t(Infinity), Infinity, "Infinity"); 11 | }; 12 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/test/math/asinh/implement.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | var isImplemented = require('../../../math/asinh/is-implemented'); 4 | 5 | module.exports = function (a) { a(isImplemented(), true); }; 6 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/test/math/asinh/index.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | module.exports = require('./shim'); 4 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/test/math/asinh/is-implemented.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | module.exports = function (t, a) { a(typeof t(), 'boolean'); }; 4 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/test/math/asinh/shim.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | module.exports = function (t, a) { 4 | a(t({}), NaN, "NaN"); 5 | a(t(0), 0, "Zero"); 6 | a(t(Infinity), Infinity, "Infinity"); 7 | a(t(-Infinity), -Infinity, "-Infinity"); 8 | a(t(-2), -1.4436354751788103, "Negative"); 9 | a(t(2), 1.4436354751788103, "Positive"); 10 | }; 11 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/test/math/atanh/implement.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | var isImplemented = require('../../../math/atanh/is-implemented'); 4 | 5 | module.exports = function (a) { a(isImplemented(), true); }; 6 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/test/math/atanh/index.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | module.exports = require('./shim'); 4 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/test/math/atanh/is-implemented.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | module.exports = function (t, a) { a(typeof t(), 'boolean'); }; 4 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/test/math/atanh/shim.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | module.exports = function (t, a) { 4 | a(t({}), NaN, "NaN"); 5 | a(t(-2), NaN, "Less than -1"); 6 | a(t(2), NaN, "Greater than 1"); 7 | a(t(-1), -Infinity, "-1"); 8 | a(t(1), Infinity, "1"); 9 | a(t(0), 0, "Zero"); 10 | a(t(0.5), 0.5493061443340549, "Ohter"); 11 | }; 12 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/test/math/cbrt/implement.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | var isImplemented = require('../../../math/cbrt/is-implemented'); 4 | 5 | module.exports = function (a) { a(isImplemented(), true); }; 6 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/test/math/cbrt/index.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | module.exports = require('./shim'); 4 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/test/math/cbrt/is-implemented.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | module.exports = function (t, a) { a(typeof t(), 'boolean'); }; 4 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/test/math/cbrt/shim.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | module.exports = function (t, a) { 4 | a(t({}), NaN, "NaN"); 5 | a(t(0), 0, "Zero"); 6 | a(t(Infinity), Infinity, "Infinity"); 7 | a(t(-Infinity), -Infinity, "-Infinity"); 8 | a(t(-1), -1, "-1"); 9 | a(t(1), 1, "1"); 10 | a(t(2), 1.2599210498948732, "Ohter"); 11 | }; 12 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/test/math/clz32/implement.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | var isImplemented = require('../../../math/clz32/is-implemented'); 4 | 5 | module.exports = function (a) { a(isImplemented(), true); }; 6 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/test/math/clz32/index.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | module.exports = require('./shim'); 4 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/test/math/clz32/is-implemented.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | module.exports = function (t, a) { a(typeof t(), 'boolean'); }; 4 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/test/math/cosh/implement.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | var isImplemented = require('../../../math/cosh/is-implemented'); 4 | 5 | module.exports = function (a) { a(isImplemented(), true); }; 6 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/test/math/cosh/index.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | module.exports = require('./shim'); 4 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/test/math/cosh/is-implemented.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | module.exports = function (t, a) { a(typeof t(), 'boolean'); }; 4 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/test/math/expm1/implement.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | var isImplemented = require('../../../math/expm1/is-implemented'); 4 | 5 | module.exports = function (a) { a(isImplemented(), true); }; 6 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/test/math/expm1/index.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | module.exports = require('./shim'); 4 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/test/math/expm1/is-implemented.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | module.exports = function (t, a) { a(typeof t(), 'boolean'); }; 4 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/test/math/expm1/shim.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | module.exports = function (t, a) { 4 | a(t({}), NaN, "NaN"); 5 | a(t(0), 0, "Zero"); 6 | a(t(Infinity), Infinity, "Infinity"); 7 | a(t(-Infinity), -1, "-Infinity"); 8 | a(t(1).toFixed(15), '1.718281828459045', "1"); 9 | }; 10 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/test/math/fround/implement.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | var isImplemented = require('../../../math/fround/is-implemented'); 4 | 5 | module.exports = function (a) { a(isImplemented(), true); }; 6 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/test/math/fround/index.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | module.exports = require('./shim'); 4 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/test/math/fround/is-implemented.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | module.exports = function (t, a) { a(typeof t(), 'boolean'); }; 4 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/test/math/fround/shim.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | module.exports = function (t, a) { 4 | a(t({}), NaN, "NaN"); 5 | a(t(0), 0, "Zero"); 6 | a(t(Infinity), Infinity, "Infinity"); 7 | a(t(-Infinity), -Infinity, "-Infinity"); 8 | a(t(1.337), 1.3370000123977661, "1"); 9 | }; 10 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/test/math/hypot/implement.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | var isImplemented = require('../../../math/hypot/is-implemented'); 4 | 5 | module.exports = function (a) { a(isImplemented(), true); }; 6 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/test/math/hypot/index.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | module.exports = require('./shim'); 4 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/test/math/hypot/is-implemented.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | module.exports = function (t, a) { a(typeof t(), 'boolean'); }; 4 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/test/math/imul/implement.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | var isImplemented = require('../../../math/imul/is-implemented'); 4 | 5 | module.exports = function (a) { a(isImplemented(), true); }; 6 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/test/math/imul/index.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | module.exports = require('./shim'); 4 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/test/math/imul/is-implemented.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | module.exports = function (t, a) { a(typeof t(), 'boolean'); }; 4 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/test/math/imul/shim.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | module.exports = function (t, a) { 4 | a(t(), 0, "No arguments"); 5 | a(t(0, 0), 0, "Zeros"); 6 | a(t(2, 4), 8, "#1"); 7 | a(t(-1, 8), -8, "#2"); 8 | a(t(0xfffffffe, 5), -10, "#3"); 9 | }; 10 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/test/math/log10/implement.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | var isImplemented = require('../../../math/log10/is-implemented'); 4 | 5 | module.exports = function (a) { a(isImplemented(), true); }; 6 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/test/math/log10/index.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | module.exports = require('./shim'); 4 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/test/math/log10/is-implemented.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | module.exports = function (t, a) { a(typeof t(), 'boolean'); }; 4 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/test/math/log10/shim.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | module.exports = function (t, a) { 4 | a(t({}), NaN, "NaN"); 5 | a(t(-0.5), NaN, "Less than 0"); 6 | a(t(0), -Infinity, "0"); 7 | a(t(1), 0, "1"); 8 | a(t(Infinity), Infinity, "Infinity"); 9 | a(t(2), 0.3010299956639812, "Other"); 10 | }; 11 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/test/math/log1p/implement.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | var isImplemented = require('../../../math/log1p/is-implemented'); 4 | 5 | module.exports = function (a) { a(isImplemented(), true); }; 6 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/test/math/log1p/index.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | module.exports = require('./shim'); 4 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/test/math/log1p/is-implemented.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | module.exports = function (t, a) { a(typeof t(), 'boolean'); }; 4 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/test/math/log1p/shim.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | module.exports = function (t, a) { 4 | a(t({}), NaN, "NaN"); 5 | a(t(-1.5), NaN, "Less than -1"); 6 | a(t(-1), -Infinity, "-1"); 7 | a(t(0), 0, "0"); 8 | a(t(Infinity), Infinity, "Infinity"); 9 | a(t(1), 0.6931471805599453, "Other"); 10 | }; 11 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/test/math/log2/implement.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | var isImplemented = require('../../../math/log2/is-implemented'); 4 | 5 | module.exports = function (a) { a(isImplemented(), true); }; 6 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/test/math/log2/index.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | module.exports = require('./shim'); 4 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/test/math/log2/is-implemented.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | module.exports = function (t, a) { a(typeof t(), 'boolean'); }; 4 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/test/math/log2/shim.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | module.exports = function (t, a) { 4 | a(t({}), NaN, "NaN"); 5 | a(t(-0.5), NaN, "Less than 0"); 6 | a(t(0), -Infinity, "0"); 7 | a(t(1), 0, "1"); 8 | a(t(Infinity), Infinity, "Infinity"); 9 | a(t(3).toFixed(15), '1.584962500721156', "Other"); 10 | }; 11 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/test/math/sign/implement.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | var isImplemented = require('../../../math/sign/is-implemented'); 4 | 5 | module.exports = function (a) { a(isImplemented(), true); }; 6 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/test/math/sign/index.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | module.exports = require('./shim'); 4 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/test/math/sign/is-implemented.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | module.exports = function (t, a) { a(typeof t(), 'boolean'); }; 4 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/test/math/sign/shim.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | var is = require('../../../object/is'); 4 | 5 | module.exports = function (t, a) { 6 | a(is(t(0), +0), true, "+0"); 7 | a(is(t(-0), -0), true, "-0"); 8 | a(t({}), NaN, true, "NaN"); 9 | a(t(-234234234), -1, "Negative"); 10 | a(t(234234234), 1, "Positive"); 11 | }; 12 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/test/math/sinh/implement.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | var isImplemented = require('../../../math/sinh/is-implemented'); 4 | 5 | module.exports = function (a) { a(isImplemented(), true); }; 6 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/test/math/sinh/index.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | module.exports = require('./shim'); 4 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/test/math/sinh/is-implemented.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | module.exports = function (t, a) { a(typeof t(), 'boolean'); }; 4 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/test/math/tanh/implement.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | var isImplemented = require('../../../math/tanh/is-implemented'); 4 | 5 | module.exports = function (a) { a(isImplemented(), true); }; 6 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/test/math/tanh/index.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | module.exports = require('./shim'); 4 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/test/math/tanh/is-implemented.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | module.exports = function (t, a) { a(typeof t(), 'boolean'); }; 4 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/test/math/tanh/shim.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | module.exports = function (t, a) { 4 | a(t({}), NaN, "NaN"); 5 | a(t(0), 0, "Zero"); 6 | a(t(Infinity), 1, "Infinity"); 7 | a(t(-Infinity), -1, "-Infinity"); 8 | a(t(1), 0.7615941559557649, "1"); 9 | a(t(Number.MAX_VALUE), 1); 10 | a(t(-Number.MAX_VALUE), -1); 11 | }; 12 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/test/math/trunc/implement.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | var isImplemented = require('../../../math/trunc/is-implemented'); 4 | 5 | module.exports = function (a) { a(isImplemented(), true); }; 6 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/test/math/trunc/index.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | module.exports = require('./shim'); 4 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/test/math/trunc/is-implemented.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | module.exports = function (t, a) { a(typeof t(), 'boolean'); }; 4 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/test/number/#/pad.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | module.exports = function (t, a) { 4 | a(t.call(78, 4), '0078'); 5 | a(t.call(65.12323, 4, 3), '0065.123', "Precision"); 6 | a(t.call(65, 4, 3), '0065.000', "Precision integer"); 7 | }; 8 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/test/number/epsilon/implement.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | var isImplemented = require('../../../number/epsilon/is-implemented'); 4 | 5 | module.exports = function (a) { a(isImplemented(), true); }; 6 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/test/number/epsilon/index.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | module.exports = function (t, a) { 4 | a(typeof t, 'number'); 5 | }; 6 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/test/number/epsilon/is-implemented.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | module.exports = function (t, a) { a(typeof t(), 'boolean'); }; 4 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/test/number/is-finite/implement.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | var isImplemented = require('../../../number/is-finite/is-implemented'); 4 | 5 | module.exports = function (a) { a(isImplemented(), true); }; 6 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/test/number/is-finite/index.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | module.exports = require('./shim'); 4 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/test/number/is-finite/is-implemented.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | module.exports = function (t, a) { a(typeof t(), 'boolean'); }; 4 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/test/number/is-finite/shim.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | module.exports = function (t, a) { 4 | a(t(2), true, "Number"); 5 | a(t('23'), false, "Not numeric"); 6 | a(t(NaN), false, "NaN"); 7 | a(t(Infinity), false, "Infinity"); 8 | }; 9 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/test/number/is-integer/implement.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | var isImplemented = require('../../../number/is-integer/is-implemented'); 4 | 5 | module.exports = function (a) { a(isImplemented(), true); }; 6 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/test/number/is-integer/index.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | module.exports = require('./shim'); 4 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/test/number/is-integer/is-implemented.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | module.exports = function (t, a) { a(typeof t(), 'boolean'); }; 4 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/test/number/is-integer/shim.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | module.exports = function (t, a) { 4 | a(t(2), true, "Number"); 5 | a(t(2.34), false, "Float"); 6 | a(t('23'), false, "Not numeric"); 7 | a(t(NaN), false, "NaN"); 8 | a(t(Infinity), false, "Infinity"); 9 | }; 10 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/test/number/is-nan/implement.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | var isImplemented = require('../../../number/is-nan/is-implemented'); 4 | 5 | module.exports = function (a) { a(isImplemented(), true); }; 6 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/test/number/is-nan/index.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | module.exports = require('./shim'); 4 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/test/number/is-nan/is-implemented.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | module.exports = function (t, a) { a(typeof t(), 'boolean'); }; 4 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/test/number/is-nan/shim.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | module.exports = function (t, a) { 4 | a(t(2), false, "Number"); 5 | a(t({}), false, "Not numeric"); 6 | a(t(NaN), true, "NaN"); 7 | }; 8 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/test/number/is-natural.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | module.exports = function (t, a) { 4 | a(t(2), true, "Number"); 5 | a(t(-2), false, "Negative"); 6 | a(t(2.34), false, "Float"); 7 | a(t('23'), false, "Not numeric"); 8 | a(t(NaN), false, "NaN"); 9 | a(t(Infinity), false, "Infinity"); 10 | }; 11 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/test/number/is-safe-integer/implement.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | var isImplemented = require('../../../number/is-safe-integer/is-implemented'); 4 | 5 | module.exports = function (a) { a(isImplemented(), true); }; 6 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/test/number/is-safe-integer/index.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | module.exports = require('./shim'); 4 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/test/number/is-safe-integer/is-implemented.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | module.exports = function (t, a) { a(typeof t(), 'boolean'); }; 4 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/test/number/max-safe-integer/implement.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | var isImplemented = require('../../../number/max-safe-integer/is-implemented'); 4 | 5 | module.exports = function (a) { a(isImplemented(), true); }; 6 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/test/number/max-safe-integer/index.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | module.exports = function (t, a) { 4 | a(typeof t, 'number'); 5 | }; 6 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/test/number/max-safe-integer/is-implemented.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | module.exports = function (t, a) { a(typeof t(), 'boolean'); }; 4 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/test/number/min-safe-integer/implement.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | var isImplemented = require('../../../number/min-safe-integer/is-implemented'); 4 | 5 | module.exports = function (a) { a(isImplemented(), true); }; 6 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/test/number/min-safe-integer/index.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | module.exports = function (t, a) { 4 | a(typeof t, 'number'); 5 | }; 6 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/test/number/min-safe-integer/is-implemented.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | module.exports = function (t, a) { a(typeof t(), 'boolean'); }; 4 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/test/number/to-integer.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | module.exports = function (t, a) { 4 | a(t({}), 0, "NaN"); 5 | a(t(20), 20, "Positive integer"); 6 | a(t('-20'), -20, "String negative integer"); 7 | a(t(Infinity), Infinity, "Infinity"); 8 | a(t(15.343), 15, "Float"); 9 | a(t(-15.343), -15, "Negative float"); 10 | }; 11 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/test/number/to-pos-integer.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | module.exports = function (t, a) { 4 | a(t({}), 0, "NaN"); 5 | a(t(20), 20, "Positive integer"); 6 | a(t(-20), 0, "Negative integer"); 7 | a(t(Infinity), Infinity, "Infinity"); 8 | a(t(15.343), 15, "Float"); 9 | a(t(-15.343), 0, "Negative float"); 10 | }; 11 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/test/number/to-uint32.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | module.exports = function (t, a) { 4 | a(t({}), 0, "Not numeric"); 5 | a(t(-4), 4294967292, "Negative"); 6 | a(t(133432), 133432, "Positive"); 7 | a(t(8589934592), 0, "Greater than maximum"); 8 | }; 9 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/test/object/assign/implement.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | var isImplemented = require('../../../object/assign/is-implemented'); 4 | 5 | module.exports = function (a) { a(isImplemented(), true); }; 6 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/test/object/assign/index.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | module.exports = require('./shim'); 4 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/test/object/assign/is-implemented.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | module.exports = function (t, a) { a(typeof t(), 'boolean'); }; 4 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/test/object/assign/shim.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | module.exports = function (t, a) { 4 | var o1 = { a: 1, b: 2 } 5 | , o2 = { b: 3, c: 4 }; 6 | 7 | a(t(o1, o2), o1, "Returns self"); 8 | a.deep(o1, { a: 1, b: 3, c: 4 }, "Single: content"); 9 | 10 | a.deep(t({}, o1, o2), { a: 1, b: 3, c: 4 }, "Multi argument"); 11 | }; 12 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/test/object/filter.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | module.exports = function (t, a) { 4 | a.deep(t({ 1: 1, 2: 2, 3: 3, 4: 4 }, 5 | function (value) { return Boolean(value % 2); }), { 1: 1, 3: 3 }); 6 | }; 7 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/test/object/flatten.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | module.exports = function (t, a) { 4 | a.deep(t({ a: { aa: 1, ab: 2 }, b: { ba: 3, bb: 4 } }), 5 | { aa: 1, ab: 2, ba: 3, bb: 4 }); 6 | }; 7 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/test/object/for-each.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | module.exports = function (t, a) { 4 | var o = { raz: 1, dwa: 2, trzy: 3 } 5 | , o2 = {}; 6 | a(t(o, function (value, name) { 7 | o2[name] = value; 8 | }), undefined, "Return"); 9 | a.deep(o2, o); 10 | }; 11 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/test/object/is-callable.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | module.exports = function (t, a) { 4 | a(t(function () {}), true, "Function"); 5 | a(t({}), false, "Object"); 6 | a(t(), false, "Undefined"); 7 | a(t(null), false, "Null"); 8 | }; 9 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/test/object/is-empty.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | module.exports = function (t, a) { 4 | a(t({}), true, "Empty"); 5 | a(t({ 1: 1 }), false, "Not empty"); 6 | }; 7 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/test/object/keys/implement.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | var isImplemented = require('../../../object/keys/is-implemented'); 4 | 5 | module.exports = function (a) { a(isImplemented(), true); }; 6 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/test/object/keys/index.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | module.exports = require('./shim'); 4 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/test/object/keys/is-implemented.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | module.exports = function (t, a) { a(typeof t(), 'boolean'); }; 4 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/test/object/keys/shim.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | module.exports = function (t, a) { 4 | a.deep(t({ foo: 'bar' }), ['foo'], "Object"); 5 | a.deep(t('raz'), ['0', '1', '2'], "Primitive"); 6 | a.throws(function () { t(); }, TypeError, "Undefined"); 7 | a.throws(function () { t(null); }, TypeError, "Undefined"); 8 | }; 9 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/test/object/map-keys.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | module.exports = function (t, a) { 4 | a.deep(t({ 1: 1, 2: 2, 3: 3 }, function (key, value) { 5 | return 'x' + (key + value); 6 | }), { x11: 1, x22: 2, x33: 3 }); 7 | }; 8 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/test/object/map.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | module.exports = function (t, a) { 4 | var obj = { 1: 1, 2: 2, 3: 3 }; 5 | a.deep(t(obj, function (value, key, context) { 6 | a(context, obj, "Context argument"); 7 | return (value + 1) + key; 8 | }), { 1: '21', 2: '32', 3: '43' }); 9 | }; 10 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/test/object/set-prototype-of/implement.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | var create = require('../../../object/create') 4 | , isImplemented = require('../../../object/set-prototype-of/is-implemented'); 5 | 6 | module.exports = function (a) { a(isImplemented(create), true); }; 7 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/test/object/set-prototype-of/is-implemented.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | module.exports = function (t, a) { a(typeof t(), 'boolean'); }; 4 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/test/object/valid-callable.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | module.exports = function (t, a) { 4 | var f = function () {}; 5 | a(t(f), f, "Function"); 6 | a.throws(function () { 7 | t({}); 8 | }, "Not Function"); 9 | }; 10 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/test/reg-exp/#/is-sticky.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | module.exports = function (t, a) { 4 | var re; 5 | a(t.call(/raz/), false, "Normal"); 6 | a(t.call(/raz/g), false, "Global"); 7 | try { re = new RegExp('raz', 'y'); } catch (ignore) {} 8 | if (!re) return; 9 | a(t.call(re), true, "Sticky"); 10 | }; 11 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/test/reg-exp/#/is-unicode.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | module.exports = function (t, a) { 4 | var re; 5 | a(t.call(/raz/), false, "Normal"); 6 | a(t.call(/raz/g), false, "Global"); 7 | try { re = new RegExp('raz', 'u'); } catch (ignore) {} 8 | if (!re) return; 9 | a(t.call(re), true, "Unicode"); 10 | }; 11 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/test/reg-exp/#/match/implement.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | var isImplemented = require('../../../../reg-exp/#/match/is-implemented'); 4 | 5 | module.exports = function (a) { a(isImplemented(), true); }; 6 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/test/reg-exp/#/match/index.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | module.exports = require('./shim'); 4 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/test/reg-exp/#/match/is-implemented.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | module.exports = function (t, a) { a(typeof t(), 'boolean'); }; 4 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/test/reg-exp/#/match/shim.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | module.exports = function (t, a) { 4 | var result = ['foo']; 5 | result.index = 0; 6 | result.input = 'foobar'; 7 | a.deep(t.call(/foo/, 'foobar'), result); 8 | }; 9 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/test/reg-exp/#/replace/implement.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | var isImplemented = require('../../../../reg-exp/#/replace/is-implemented'); 4 | 5 | module.exports = function (a) { a(isImplemented(), true); }; 6 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/test/reg-exp/#/replace/index.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | module.exports = require('./shim'); 4 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/test/reg-exp/#/replace/is-implemented.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | module.exports = function (t, a) { a(typeof t(), 'boolean'); }; 4 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/test/reg-exp/#/replace/shim.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | module.exports = function (t, a) { 4 | a(t.call(/foo/, 'foobar', 'mar'), 'marbar'); 5 | }; 6 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/test/reg-exp/#/search/implement.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | var isImplemented = require('../../../../reg-exp/#/search/is-implemented'); 4 | 5 | module.exports = function (a) { a(isImplemented(), true); }; 6 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/test/reg-exp/#/search/index.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | module.exports = require('./shim'); 4 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/test/reg-exp/#/search/is-implemented.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | module.exports = function (t, a) { a(typeof t(), 'boolean'); }; 4 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/test/reg-exp/#/search/shim.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | module.exports = function (t, a) { 4 | a(t.call(/foo/, 'barfoo'), 3); 5 | }; 6 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/test/reg-exp/#/split/implement.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | var isImplemented = require('../../../../reg-exp/#/split/is-implemented'); 4 | 5 | module.exports = function (a) { a(isImplemented(), true); }; 6 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/test/reg-exp/#/split/index.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | module.exports = require('./shim'); 4 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/test/reg-exp/#/split/is-implemented.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | module.exports = function (t, a) { a(typeof t(), 'boolean'); }; 4 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/test/reg-exp/#/split/shim.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | module.exports = function (t, a) { 4 | a.deep(t.call(/\|/, 'bar|foo'), ['bar', 'foo']); 5 | }; 6 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/test/reg-exp/#/sticky/implement.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | var isImplemented = require('../../../../reg-exp/#/sticky/is-implemented'); 4 | 5 | module.exports = function (a) { a(isImplemented(), true); }; 6 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/test/reg-exp/#/sticky/is-implemented.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | module.exports = function (t, a) { a(typeof t(), 'boolean'); }; 4 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/test/reg-exp/#/unicode/implement.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | var isImplemented = require('../../../../reg-exp/#/unicode/is-implemented'); 4 | 5 | module.exports = function (a) { a(isImplemented(), true); }; 6 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/test/reg-exp/#/unicode/is-implemented.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | module.exports = function (t, a) { a(typeof t(), 'boolean'); }; 4 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/test/reg-exp/escape.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | module.exports = function (t, a) { 4 | var str = "(?:^te|er)s{2}t\\[raz]+$"; 5 | a(RegExp('^' + t(str) + '$').test(str), true); 6 | }; 7 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/test/string/#/@@iterator/implement.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | var isImplemented = require('../../../../string/#/@@iterator/is-implemented'); 4 | 5 | module.exports = function (a) { a(isImplemented(), true); }; 6 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/test/string/#/@@iterator/index.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | module.exports = require('./shim'); 4 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/test/string/#/@@iterator/is-implemented.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | module.exports = function (t, a) { a(typeof t(), 'boolean'); }; 4 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/test/string/#/camel-to-hyphen.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | module.exports = function (t, a) { 4 | a(t.call('razDwaTRzy4yFoo45My'), 'raz-dwa-t-rzy4y-foo45-my'); 5 | }; 6 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/test/string/#/capitalize.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | module.exports = function (t, a) { 4 | a(t.call('raz'), 'Raz', "Word"); 5 | a(t.call('BLA'), 'BLA', "Uppercase"); 6 | a(t.call(''), '', "Empty"); 7 | a(t.call('a'), 'A', "One letter"); 8 | a(t.call('this is a test'), 'This is a test', "Sentence"); 9 | }; 10 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/test/string/#/case-insensitive-compare.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | module.exports = function (t, a) { 4 | a(t.call("AA", "aa"), 0, "Same"); 5 | a.ok(t.call("Amber", "zebra") < 0, "Less"); 6 | a.ok(t.call("Zebra", "amber") > 0, "Greater"); 7 | }; 8 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/test/string/#/code-point-at/implement.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | var isImplemented = 4 | require('../../../../string/#/code-point-at/is-implemented'); 5 | 6 | module.exports = function (a) { a(isImplemented(), true); }; 7 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/test/string/#/code-point-at/index.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | module.exports = require('./shim'); 4 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/test/string/#/code-point-at/is-implemented.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | module.exports = function (t, a) { a(typeof t(), 'boolean'); }; 4 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/test/string/#/contains/implement.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | var isImplemented = require('../../../../string/#/contains/is-implemented'); 4 | 5 | module.exports = function (a) { a(isImplemented(), true); }; 6 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/test/string/#/contains/index.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | module.exports = require('./shim'); 4 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/test/string/#/contains/is-implemented.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | module.exports = function (t, a) { a(typeof t(), 'boolean'); }; 4 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/test/string/#/ends-with/implement.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | var isImplemented = require('../../../../string/#/ends-with/is-implemented'); 4 | 5 | module.exports = function (a) { a(isImplemented(), true); }; 6 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/test/string/#/ends-with/index.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | module.exports = require('./shim'); 4 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/test/string/#/ends-with/is-implemented.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | module.exports = function (t, a) { a(typeof t(), 'boolean'); }; 4 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/test/string/#/hyphen-to-camel.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | module.exports = function (t, a) { 4 | a(t.call('raz-dwa-t-rzy-4y-rtr4-tiu-45-pa'), 'razDwaTRzy4yRtr4Tiu45Pa'); 5 | }; 6 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/test/string/#/last.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | module.exports = function (t, a) { 4 | a(t.call(''), null, "Null"); 5 | a(t.call('abcdef'), 'f', "String"); 6 | }; 7 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/test/string/#/normalize/_data.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | module.exports = function (t, a) { a(typeof t[0], 'object'); }; 4 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/test/string/#/normalize/implement.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | var isImplemented = require('../../../../string/#/normalize/is-implemented'); 4 | 5 | module.exports = function (a) { a(isImplemented(), true); }; 6 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/test/string/#/normalize/index.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | module.exports = require('./shim'); 4 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/test/string/#/normalize/is-implemented.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | module.exports = function (t, a) { a(typeof t(), 'boolean'); }; 4 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/test/string/#/plain-replace.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | module.exports = function (t, a) { 4 | a(t.call('razdwatrzy', 'dwa', 'olera'), 'razoleratrzy', "Basic"); 5 | a(t.call('razdwatrzy', 'dwa', 'ole$&a'), 'razole$&atrzy', "Inserts"); 6 | a(t.call('razdwa', 'ola', 'sdfs'), 'razdwa', "No replace"); 7 | }; 8 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/test/string/#/repeat/implement.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | var isImplemented = require('../../../../string/#/repeat/is-implemented'); 4 | 5 | module.exports = function (a) { a(isImplemented(), true); }; 6 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/test/string/#/repeat/index.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | module.exports = require('./shim'); 4 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/test/string/#/repeat/is-implemented.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | module.exports = function (t, a) { a(typeof t(), 'boolean'); }; 4 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/test/string/#/repeat/shim.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | module.exports = function (t, a) { 4 | a(t.call('a', 0), '', "Empty"); 5 | a(t.call('a', 1), 'a', "1"); 6 | a(t.call('\t', 5), '\t\t\t\t\t', "Whitespace"); 7 | a(t.call('raz', 3), 'razrazraz', "Many chars"); 8 | }; 9 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/test/string/#/starts-with/implement.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | var isImplemented = require('../../../../string/#/starts-with/is-implemented'); 4 | 5 | module.exports = function (a) { a(isImplemented(), true); }; 6 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/test/string/#/starts-with/index.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | module.exports = require('./shim'); 4 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/test/string/#/starts-with/is-implemented.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | module.exports = function (t, a) { a(typeof t(), 'boolean'); }; 4 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/test/string/format-method.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | module.exports = function (t, a) { 4 | t = t({ a: 'A', aa: 'B', ab: 'C', b: 'D', 5 | c: function () { return ++this.a; } }); 6 | a(t.call({ a: 0 }, ' %a%aab%abb%b\\%aa%ab%c%c '), ' ABbCbD%aaC12 '); 7 | }; 8 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/test/string/from-code-point/implement.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | var isImplemented = require('../../../string/from-code-point/is-implemented'); 4 | 5 | module.exports = function (a) { a(isImplemented(), true); }; 6 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/test/string/from-code-point/index.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | module.exports = require('./shim'); 4 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/test/string/from-code-point/is-implemented.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | module.exports = function (t, a) { a(typeof t(), 'boolean'); }; 4 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/test/string/raw/implement.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | var isImplemented = require('../../../string/raw/is-implemented'); 4 | 5 | module.exports = function (a) { a(isImplemented(), true); }; 6 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/test/string/raw/index.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | module.exports = require('./shim'); 4 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es5-ext/test/string/raw/is-implemented.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | module.exports = function (t, a) { a(typeof t(), 'boolean'); }; 4 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es6-iterator/.lint: -------------------------------------------------------------------------------- 1 | @root 2 | 3 | module 4 | 5 | tabs 6 | indent 2 7 | maxlen 100 8 | 9 | ass 10 | nomen 11 | plusplus 12 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es6-iterator/.npmignore: -------------------------------------------------------------------------------- 1 | .DS_Store 2 | /node_modules 3 | /npm-debug.log 4 | /.lintcache 5 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es6-iterator/.travis.yml: -------------------------------------------------------------------------------- 1 | language: node_js 2 | node_js: 3 | - 0.8 4 | - 0.10 5 | - 0.11 6 | 7 | notifications: 8 | email: 9 | - medikoo+es6-iterator@medikoo.com 10 | 11 | script: "npm test && npm run lint" 12 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es6-iterator/valid-iterable.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | var isIterable = require('./is-iterable'); 4 | 5 | module.exports = function (value) { 6 | if (!isIterable(value)) throw new TypeError(value + " is not iterable"); 7 | return value; 8 | }; 9 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es6-symbol/.lint: -------------------------------------------------------------------------------- 1 | @root 2 | 3 | module 4 | 5 | tabs 6 | indent 2 7 | maxlen 100 8 | 9 | ass 10 | nomen 11 | plusplus 12 | newcap 13 | vars 14 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es6-symbol/.npmignore: -------------------------------------------------------------------------------- 1 | .DS_Store 2 | /node_modules 3 | /npm-debug.log 4 | /.lintcache 5 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es6-symbol/.travis.yml: -------------------------------------------------------------------------------- 1 | language: node_js 2 | node_js: 3 | - 0.8 4 | - 0.10 5 | - 0.11 6 | 7 | notifications: 8 | email: 9 | - medikoo+es6-symbol@medikoo.com 10 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es6-symbol/implement.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | if (!require('./is-implemented')()) { 4 | Object.defineProperty(require('es5-ext/global'), 'Symbol', 5 | { value: require('./polyfill'), configurable: true, enumerable: false, 6 | writable: true }); 7 | } 8 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es6-symbol/index.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | module.exports = require('./is-implemented')() ? Symbol : require('./polyfill'); 4 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es6-symbol/is-native-implemented.js: -------------------------------------------------------------------------------- 1 | // Exports true if environment provides native `Symbol` implementation 2 | 3 | 'use strict'; 4 | 5 | module.exports = (function () { 6 | if (typeof Symbol !== 'function') return false; 7 | return (typeof Symbol.iterator === 'symbol'); 8 | }()); 9 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es6-symbol/is-symbol.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | module.exports = function (x) { 4 | return (x && ((typeof x === 'symbol') || (x['@@toStringTag'] === 'Symbol'))) || false; 5 | }; 6 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es6-symbol/test/implement.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | module.exports = function (t, a) { a(typeof Symbol, 'function'); }; 4 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es6-symbol/test/index.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | var d = require('d') 4 | 5 | , defineProperty = Object.defineProperty; 6 | 7 | module.exports = function (T, a) { 8 | var symbol = T('test'), x = {}; 9 | defineProperty(x, symbol, d('foo')); 10 | a(x.test, undefined, "Name"); 11 | a(x[symbol], 'foo', "Get"); 12 | }; 13 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es6-symbol/test/is-native-implemented.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | module.exports = function (t, a) { a(typeof t, 'boolean'); }; 4 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/node_modules/es6-symbol/validate-symbol.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | var isSymbol = require('./is-symbol'); 4 | 5 | module.exports = function (value) { 6 | if (!isSymbol(value)) throw new TypeError(value + " is not a symbol"); 7 | return value; 8 | }; 9 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/test/implement.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | module.exports = function (t, a) { a(typeof WeakMap, 'function'); }; 4 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/test/index.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | module.exports = function (T, a) { 4 | var x = {}; 5 | a((new T([[x, 'foo']])).get(x), 'foo'); 6 | }; 7 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/test/is-implemented.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | module.exports = function (t, a) { a(typeof t(), 'boolean'); }; 4 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/test/is-native-implemented.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | module.exports = function (t, a) { a(typeof t, 'boolean'); }; 4 | -------------------------------------------------------------------------------- /node_modules/emissary/node_modules/es6-weak-map/valid-weak-map.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | 3 | var isWeakMap = require('./is-weak-map'); 4 | 5 | module.exports = function (x) { 6 | if (!isWeakMap(x)) throw new TypeError(x + " is not a WeakMap"); 7 | return x; 8 | }; 9 | -------------------------------------------------------------------------------- /node_modules/xregexp/.npmignore: -------------------------------------------------------------------------------- 1 | min/ 2 | src/ 3 | tests/index.html 4 | tests/qunit/ 5 | tools/ 6 | -------------------------------------------------------------------------------- /node_modules/xregexp/tests/node-qunit.js: -------------------------------------------------------------------------------- 1 | // Use node-qunit to run the tests. 2 | 3 | var qunit = require("qunit"); 4 | 5 | qunit.run({ 6 | code: { 7 | namespace: "xregexp", 8 | path: __dirname + "/../xregexp-all.js" 9 | }, 10 | tests: __dirname + "/tests.js" 11 | }); 12 | -------------------------------------------------------------------------------- /vendor/launch.cmd: -------------------------------------------------------------------------------- 1 | @echo off 2 | %* 3 | pause 4 | 5 | --------------------------------------------------------------------------------