pax_global_header00006660000000000000000000000064131630533050014511gustar00rootroot0000000000000052 comment=1b41fafdcacbae2919f9f682f1a8293a9b4d03d1 elixirscript-0.31.1/000077500000000000000000000000001316305330500143145ustar00rootroot00000000000000elixirscript-0.31.1/.babelrc000066400000000000000000000001731316305330500157100ustar00rootroot00000000000000{ "presets": [ [ "env", { "targets": { "node": "current" } } ] ] } elixirscript-0.31.1/.credo.exs000066400000000000000000000111061316305330500162060ustar00rootroot00000000000000# This file contains the configuration for Credo and you are probably reading # this after creating it with `mix credo.gen.config`. # # If you find anything wrong or unclear in this file, please report an # issue on GitHub: https://github.com/rrrene/credo/issues # %{ # # You can have as many configs as you like in the `configs:` field. configs: [ %{ # # Run any config using `mix credo -C `. If no config name is given # "default" is used. name: "default", # # These are the files included in the analysis: files: %{ # # You can give explicit globs or simply directories. # In the latter case `**/*.{ex,exs}` will be used. included: ["lib/", "src/", "web/", "apps/"], excluded: [~r"/_build/", ~r"/deps/"] }, # # If you create your own checks, you must specify the source files for # them here, so they can be loaded by Credo before running the analysis. requires: [], # # Credo automatically checks for updates, like e.g. Hex does. # You can disable this behaviour below: check_for_updates: true, # # If you want to enforce a style guide and need a more traditional linting # experience, you can change `strict` to `true` below: strict: false, # # If you want to use uncolored output by default, you can change `color` # to `false` below: color: true, # # You can customize the parameters of any check by adding a second element # to the tuple. # # To disable a check put `false` as second element: # # {Credo.Check.Design.DuplicatedCode, false} # checks: [ {Credo.Check.Consistency.ExceptionNames}, {Credo.Check.Consistency.LineEndings}, {Credo.Check.Consistency.MultiAliasImportRequireUse}, {Credo.Check.Consistency.ParameterPatternMatching}, {Credo.Check.Consistency.SpaceAroundOperators}, {Credo.Check.Consistency.SpaceInParentheses, false}, {Credo.Check.Consistency.TabsOrSpaces}, {Credo.Check.Design.DuplicatedCode, excluded_macros: []}, {Credo.Check.Design.TagTODO, exit_status: 2}, {Credo.Check.Design.TagFIXME}, {Credo.Check.Design.AliasUsage, false}, {Credo.Check.Readability.FunctionNames}, {Credo.Check.Readability.LargeNumbers}, {Credo.Check.Readability.MaxLineLength, priority: :low, max_length: 80}, {Credo.Check.Readability.ModuleAttributeNames}, {Credo.Check.Readability.ModuleDoc}, {Credo.Check.Readability.ModuleNames}, {Credo.Check.Readability.ParenthesesOnZeroArityDefs}, {Credo.Check.Readability.ParenthesesInCondition}, {Credo.Check.Readability.PredicateFunctionNames}, {Credo.Check.Readability.PreferImplicitTry}, {Credo.Check.Readability.RedundantBlankLines}, {Credo.Check.Readability.Specs}, {Credo.Check.Readability.StringSigils}, {Credo.Check.Readability.TrailingBlankLine}, {Credo.Check.Readability.TrailingWhiteSpace}, {Credo.Check.Readability.VariableNames}, {Credo.Check.Refactor.DoubleBooleanNegation}, {Credo.Check.Refactor.ABCSize}, {Credo.Check.Refactor.CondStatements}, {Credo.Check.Refactor.CyclomaticComplexity}, {Credo.Check.Refactor.FunctionArity}, {Credo.Check.Refactor.MatchInCondition}, {Credo.Check.Refactor.NegatedConditionsInUnless}, {Credo.Check.Refactor.NegatedConditionsWithElse}, {Credo.Check.Refactor.Nesting}, {Credo.Check.Refactor.PipeChainStart, false}, {Credo.Check.Refactor.UnlessWithElse}, {Credo.Check.Refactor.VariableRebinding, false}, {Credo.Check.Warning.BoolOperationOnSameValues}, {Credo.Check.Warning.IExPry}, {Credo.Check.Warning.IoInspect}, {Credo.Check.Warning.NameRedeclarationByAssignment}, {Credo.Check.Warning.NameRedeclarationByCase}, {Credo.Check.Warning.NameRedeclarationByDef}, {Credo.Check.Warning.NameRedeclarationByFn}, {Credo.Check.Warning.OperationOnSameValues}, {Credo.Check.Warning.OperationWithConstantResult}, {Credo.Check.Warning.UnusedEnumOperation}, {Credo.Check.Warning.UnusedFileOperation}, {Credo.Check.Warning.UnusedKeywordOperation}, {Credo.Check.Warning.UnusedListOperation}, {Credo.Check.Warning.UnusedPathOperation}, {Credo.Check.Warning.UnusedRegexOperation}, {Credo.Check.Warning.UnusedStringOperation}, {Credo.Check.Warning.UnusedTupleOperation}, ] } ] } elixirscript-0.31.1/.ebert.yml000066400000000000000000000003011316305330500162100ustar00rootroot00000000000000styleguide: elixirscript/elixirscript engines: credo: enabled: true fixme: enabled: true eslint: enabled: true remark-lint: enabled: true exclude_paths: - config - test elixirscript-0.31.1/.eslintrc.js000066400000000000000000000006271316305330500165600ustar00rootroot00000000000000module.exports = { rules: { camelcase: 'off', 'no-bitwise': 'off', 'no-plusplus': 'off', 'no-restricted-syntax': 'off', 'no-underscore-dangle': 'off', 'import/extensions': 'off', 'import/no-extraneous-dependencies': ['error', { devDependencies: true }], }, extends: 'airbnb-base', plugins: ['import'], env: { browser: true, node: true, mocha: true, }, }; elixirscript-0.31.1/.gitignore000066400000000000000000000004431316305330500163050ustar00rootroot00000000000000/_build /deps erl_crash.dump *.ez ex2js elixirscript node_modules /dist deploy.sh .DS_Store sample/dest fprof.trace index.js /doc /bench/snapshots .tern-port test/std_lib_compile_test.exs src/elixirscript stdlib_state.bin *.log .nyc_output test/app/build .vscode cover /priv /tmp .esm-cache elixirscript-0.31.1/.tool-versions000066400000000000000000000000551316305330500171400ustar00rootroot00000000000000erlang 20.0 elixir 1.5.0-otp-20 nodejs 8.3.0 elixirscript-0.31.1/.travis.yml000066400000000000000000000016021316305330500164240ustar00rootroot00000000000000sudo: false language: erlang otp_release: - 20.0 env: - TRAVIS_NODE_VERSION="8" install: - rm -rf ~/.nvm && git clone https://github.com/creationix/nvm.git ~/.nvm && (cd ~/.nvm && git checkout `git describe --abbrev=0 --tags`) && source ~/.nvm/nvm.sh && nvm install $TRAVIS_NODE_VERSION - npm install -g yarn - yarn before_script: - wget https://repo.hex.pm/builds/elixir/v1.5.1-otp-20.zip - unzip -d elixir v1.5.1-otp-20.zip - export PATH=$(pwd)/elixir/bin:${PATH} - mix local.rebar --force - mix local.hex --force - mix deps.get script: - make - make test notifications: webhooks: urls: - https://webhooks.gitter.im/e/fbd8944d285c0696dc41 on_success: always # options: [always|never|change] default: always on_failure: always # options: [always|never|change] default: always on_start: never # options: [always|never|change] default: always elixirscript-0.31.1/CHANGELOG.md000066400000000000000000000533071316305330500161350ustar00rootroot00000000000000# Change Log All notable changes to this project will be documented in this file. The format is based on [Keep a Changelog](http://keepachangelog.com/) and this project adheres to [Semantic Versioning](http://semver.org/). ## [0.31.0] - 2017-09-24 ### Added - [Compiler will now accept a path to Elixir Files to compile](https://github.com/elixirscript/elixirscript/issues/420) - [Added `ElixirScript.JS.map_to_object/2` with options [keys: :string, symbols: false]](https://github.com/elixirscript/elixirscript/issues/362) - [Added `ElixirScript.JS.object_to_map/1|2` with options [keys: :atom, recurse_array: true]](https://github.com/elixirscript/elixirscript/issues/381) - [Fully implement `__info__` on modules](https://github.com/elixirscript/elixirscript/pull/378) - [Concurrent Compilation](https://github.com/elixirscript/elixirscript/issues/376) - [The following erlang functions have been implemented](https://github.com/elixirscript/elixirscript/issues/306): * :erlang.nodes/0 * :erlang.nodes/1 * :math.log2/1 * :binary.copy/1 * :binary.copy/2 * :binary.part/2 * :binary.part/3 * :binary.replace/3 * :binary.replace/4 (some options still missing) ### Fixed - Make sure not to add underscores to erlang functions - [Make sure any variable names that are javascript keywords are handled properly](https://github.com/elixirscript/elixirscript/issues/355) - [Make sure variables that begin with `_` are available](https://github.com/elixirscript/elixirscript/issues/356) - [Finding the use of functions within anonymous functions](https://github.com/elixirscript/elixirscript/issues/358) - [Reimplement `String.split_at/2` to make sure Unicode library isn't compiled](https://github.com/elixirscript/elixirscript/issues/353) - [byte_size does not work on binaries that started via "" elixir string syntax](https://github.com/elixirscript/elixirscript/issues/384) - [using . (dot) reference syntax on a map fails when value is a function](https://github.com/elixirscript/elixirscript/issues/380) - [Make sure that remote ast works correctly with variables](https://github.com/elixirscript/elixirscript/issues/390) - [Make sure == works as expected](https://github.com/elixirscript/elixirscript/issues/382) - [Make sure that erlang function names that are also JavaScript keywords are not filters](https://github.com/elixirscript/elixirscript/issues/359) - [erlang.error now throws errors resembling those in Elixir](https://github.com/elixirscript/elixirscript/pull/397) - [Map.get fails if key is tuple or list](https://github.com/elixirscript/elixirscript/issues/406) ## [0.30.0] - 2017-08-15 ### Added - ElixirScript now has a Foreign Function Interface (FFI) for interoperability with JavaScript. For more details, see documentation at `ElixirScript.FFI` - `ElixirScript.JS.mutate/3` - `ElixirScript.JS.map_to_object/1` - `root` option for specifying the root import path for FFI JavaScript modules. Defaults to `"."` ### Changed - Compiler has been completely rewritten. ElixirScript now requires Erlang 20+ and Elixir 1.5+ - `JS` module renamed to `ElixirScript.JS` - Default output path is now `priv/elixir_script/build` ### Removed - Support for CommonJS and UMD output formats has been removed. Output will be in ES module format - The `js_modules` option has been removed in favor of the new FFI - ElixirScript.Watcher has been removed ## [0.28.0] - 2017-06-11 ### Added - `remove-unused` option that will remove all unused modules from output - reimplemented structs to avoid creating JavaScript classes ## [0.27.0] - 2017-03-17 ### Added - `super` - `defoverridable` - `IO.inspect\1`, `IO.puts\1`, `IO.puts\2`, `IO.warn\1` - `Elixir.load` for loading generated JavaScript modules in bundled output. Unlike `Elixir.start`, this will only call `__load` on the module and return the functions on it ```javascript const exports = Elixir.load(Elixir.MyApp); exports.hello(); ``` ### Changed - `-ex` alias is now `-e` - A filename can be specified for output - To access global JavaScript functions, modules, and properties, use the `JS` module ```elixir JS.length # translates to 'length' JS.alert() # translates to 'alert()' JS.String.raw("hi") # translate to String.raw('hi') JS.console.log("hi") # translates to console.log('hi') ``` ### Fixed - Make sure mix compiler works in umbrella apps ## [0.26.1] - 2017-02-27 ### Fixed - Fixed `for` translation - Updated documentation ## [0.26.0] - 2017-02-27 ### Added - Multiple `when` clauses in guards - Kernel.defdelegate/2 - `js_modules` configuration option has been added. This is a list of JavaScript modules that will be used. ``` js_modules: [ {React, "react"}, {ReactDOM, "react-dom"} ] ``` - `js-module` flag has been added to the CLI in order to pass js modules. ``` elixirscript "app/elixirscript" -o dist --js-module React:react --js-module ReactDOM:react-dom ``` ### Removed - `@on_js_load` has been removed in favor of having a `start/2` function defined. More info below - `JS.import` has been removed in favor of defining JavaScript modules used in configuration ### Changed - Now bundles all output, including the boostrap code. The exported object has Elixir modules in JavaScript namespaces that are lazily loaded when called. To start your application import the bundle according to whichever module format was selected and then call start giving it the module and the initial args ```javascript //ES module example import Elixir from './Elixir.App' Elixir.start(Elixir.App, []) ``` The `start` function will look for a `start/2` function there. This is analogous to a [Application module callback](https://hexdocs.pm/elixir/Application.html#module-application-module-callback) ## [0.25.0] - 2017-02-19 ### Added - Updated elixir_script mix compiler to support compiling elixir_script paths in dependencies if dependency has mix compiler defined as well - Add `Collectable` protocol implementations - Updated `for` implementation to use `Collectable` - `format` option. Can now specify the module format of output. Choices are: * `:es` (default) for ES Modules * `:umd` for UMD * `:common` for CommonJS - Default input, output and format for elixirscript mix compiler. In a mix project by default the elixirscript compiler will look in `lib/elixirscript` and input and place output in `priv/elixirscript`. The default format is `:es` ### Removed - `receive` - `Process` module ### Fixed - JS module functions not translated properly when imported - Update fs dependency to 2.12 - Incorrect handling of function heads with guards ## [0.24.0] - 2017-01-15 ### Added - Support for `sigil_r` - `Regex` module - Better JavaScript formatting ### Fixed - CLI now allows a comma-separated or space-separated list of paths - Struct not properly referenced - Tail call optimization ## [0.23.3] - 2016-11-18 ### Added - `@load_only`: lets the compiler know to load in the module, but not to compile it ## [0.23.2] - 2016-11-17 ### Fixed - Agent not functioning properly. Now uses internal store instead of making a process and using that to put data in store - Protocol incorrectly handling strings - `defgen` and `defgenp` functions not being recognized by Elixir compiler. ## [0.23.1] - 2016-11-16 ### Fixed - Incorrectly sending standard lib when using compile or compile_path by default ## [0.23.0] - 2016-11-15 ### Added - [`with` now supports `else`](https://github.com/bryanjos/elixirscript/pull/207) - [Implement `context` option on `quote`](https://github.com/bryanjos/elixirscript/pull/208) - New compiler pipeline - `@on_js_load`. Expects a 0 arity function. This function will be called when the compiled module is loaded in JavaScript - `JS.import\3`. Just like `JS.import\2` but expects options to decide if the import should be a default one or a namespace on. Only option allowed is `default`. Set to `true` by default ```elixir # translates to "import A from 'a'" JS.import A, "a" #translates to "import * as A from 'a'" JS.import A, "a", default: false ``` ### Removed - The form of `JS.import` that accepted a list of atoms as the first arg. Used `JS.import\3` with `default: false` instead to create a namespace import - `env` and `root` are no longer options for `ElixirScript`'s compile functions and cli - Syntax once supported by Elixirscript `JQuery.("#element")`, is no longer supported ### Changed - [Changed CHANGELOG.md to adhere the format from Keep a Changelog](https://github.com/bryanjos/elixirscript/pull/205) - `defmacro` now supported. No longer have to separate macros from functions in separate files. `defmacrop` still unsupported - To use anything in the `JS` module, you must `require` the `JS` module first - Elixirscript files must now contain valid Elixir syntax. - Now compiles `exjs` and `ex` files within the path can be compiled all the same. Dependencies from hex are still unsupported so these files must not rely on any code outside of the path. What this does mean is that it is now possible to share code between Elixir and Elixirscript as long as the Elixir files functionality fall within what Elixirscript currently supports. - `defgen`, `defgenp`, `yield`, `yield_to`, and `object` are now in the `JS` module - To access functions in the global JavaScript scope, either use `JS.global\0` or use the erlang module call syntax ```elixir #calling alert JS.global().alert("hi") #calling alert :window.alert("hi") ``` Calling JavaScript modules in the global scope works without using the above methods ```elixir #calls window.Date.now() Date.now() ``` ## [0.22.0] - 2016-10-16 ### Added - `defgen` and `defgenp` for defining public and private generators - `yield/0`, `yield/1`, and `yield_to\1` to `Kernel` ### Changed - Updated output folder structure. stdlib code will now go in an `elxiir` folder under the output paths while generated app code will go into an `app` folder under the output path - All process macros and functions now expect to receive and/or work using generators as entry points. Using functions defined with `def` or `defp` will not work correctly with them ### Fixed - Correctly returning list if list is only item in body ## [0.21.0] - 2016-06-28 ### Added - This is the first release with early support for processes in elixirscript. Creating a process only works currently using `spawn/1`, `spawn_link/1`, and `spawn_monitor/1`. Inside of a process, you can use functions such as `send` and `receive`, along with some defined in the `Process` module. From outside of a process, you can send messages to a process, but you cannot receive a message from a process. Eventually all code will run inside processes and this restriction will naturally lift. - The `Process` module has been implemented with the following functions: * `alive?/1` * `delete/1` * `demonitor/1` * `exit/2` * `flag/2` * `flag/3` * `get/0` * `get_keys/0` * `get_keys/1` * `link/1` * `list/0` * `monitor/1` * `put/2` * `register/2` * `registered/0` * `send/3` * `sleep/1` * `unlink/1` * `unregister/1` * `whereis/1` - The `receive` special form has been implemented with the above caveat - The following have been implemented on `Kernel`: * `spawn/1` * `spawn_link/1` * `spawn_monitor/1` * `send/2` * `make_ref/0` ## Fixed - Scoping on `fn` and `def` ## [0.20.0] - 2016-05-14 ### Added - `ElixirScript.Watcher` module and `elixirscript.watch` mix task - logging MatchError exceptions to better show terms that don't match ## [0.19.0] - 2016-04-30 ### Added - elixir_script mix compiler ### Removed - `Html`, `View`, and `VDom` modules have been removed ## [0.18.0] - 2016-04-08 ### Changed - Better support for macros. Macros should be defined in .ex or .exs files. ElixirScript code should be in .exjs files **NOTE**: The above functionality will cause either compiler errors or no output. Please change extensions of ElixirScript code to .exjs ### Deprecated - `Html`, `View`, and `VDom` modules will be removed in the next version as they can now be replicated using macros ## [0.17.0] - 2016-03-31 ### Added - `output` as an option for compiler functions. This controls whether output is returned as a list of tuples, send to stdout, or saved to a file path - `:full_build` as an option for compiler functions and `--full-build` option to CLI. These force the compiler to perform a full build - `--version` option to CLI. Outputs current version of elixirscript - `--std-lib` option to CLI. Takes a path and adds the stdlib to that path ### Changed - Renamed `copy_core_to_destination` to `copy_stdlib_to_destination` - Incremental Compilation: ElixirScript will now only build files and modules that have changed since the last build ### Removed - `--core` option from CLI and `:core` compiler option. ## [0.16.0] 2016-02-27 ### Added - Bitstring pattern matching - Bitstrings in for comprehensions - Functions with catch, after, else clauses - `with` special form - Pin operator in map keys and function clauses - Added `Kernel.object/1` function to make it more natural to create a JavaScript object with string keys. Elixirscript, by default turns the following, `%{a:"b"}` into `{[Symbol.for("a")]: "b"}` in JavaScript. In order to get string keys, one would have to do `%{"a" => "b"}` which turns into `{a: "b"}` in JavaScript. With `Kernel.object`, you can create string keyed maps conveniently, `object(a: "b")` which turns into `{a: "b"}`. **NOTE**: when updating the created by, you still have to use the string form `%{ my_map | "a" => "c" }` ### Removed - `JS.update(object, property, value)` has been removed and replaced with `JS.update(object, map)`. This allows you to update multiple values on a javascript object at once. ### Fixed - Optional parameters should now work as expected ## [0.15.2] - 2016-02-21 ### Addded - Support for variables as map keys ### Fixed - Protocol implementations for Integer and Float which where not recognized - Calling properties on non-objects ## [0.15.1] - 2016-02-19 ### Removed - Removed `catch` as a javascript keyword to filter ### Fixed - Fixed View module so that an element can have multiple elements within - struct implementation so that lists of atoms for fields are compiled correctly - head-tail pattern match to allow for more complicated scenarios - ModuleCollector to properly alias inner modules - Raise translation to properly translate when string messages are given ## [0.15.0] - 2016-01-26 ### Added - `__ENV__` and `__CALLER__` are now supported - `JS.import/1`, `JS.typeof/1`,`JS.instanceof/1`, and `JS.global/1` - Support for multi alias/require/imports statements ### Changed - `alias`, `require`, and `import` now work inside lexical scopes - Some of the standard library originally written in JavaScript has been rewritten in Elixir. - Generated JavaScript export statements are now default exports - When output is sent to standard out, there are now markers to specify where each module begins as well as what the file name would be. For the end of a file, `//:ENDFILE` is used. For the file name, `//:ENDFILENAME` is used where `` is the name of the file - `compile`, `compile_path`, and `compile_quoted` opts parameter now expects a map - The `stdlib` compiler option is now `core`. The `stdlib_path` compiler options is now `core_path` ## [0.14.1] - 2015-12-07 ### Removed - .DS_Store and LICENSE from output ## [0.14.0] - 2015-12-06 ### Added - Can now implement protocols using JavaScript types ```elixir defimpl MyProtocol, for: HTMLElement ``` - virtual-dom JavaScript library - ElixirScript.Html module for defining a virtual-dom tree - ElixirScript.VDom module for manipulating the virtual-dom tree created using the ElixirScript.Html module - Added ElixirScript.View module for handling view state and rendering virtual-dom - Added `stdlib_path` compiler option to specify the es6 path to the standard library. If used, elixir.js will not be exported with the compiled modules ### Changed - Renamed `ex2js` to `elixirscript`. This effects the escript as well as the mix task - Structs are now translated into classes - Structs and Tuples now match on their types - Can now match on JavaScript classes. Works just like matching on structs: ```elixir def my_func(%HTMLElement{id: "myId"}) ``` - Moved non-elixir JavaScript code into `core` es6 module. This will hopefully make it so ElixirScript Standard Library modules can be defined in Elixir soon. ## [0.13.0] - 2015-10-26 ### Added - `Base` module with function: encode64, decode64, and decode64! - `String` module - `Bitwise` module - `Map` module - `MapSet` module - `Set` module - Protocol support - Added `Collectable`, `Enumerable`, `Inspect`, `List.Chars`, and `String.Chars` protocols. The only one currently being used in the Standard Library, however, is String.Chars ## [0.12.0] - 2015-09-23 ### Added - Added PostOffice. Only thing that current uses it is Agent ### Changed - Updated tuple implementation. It's now a class. - Replaced pattern matching library with custom one - Moved data types to Kernel.SpecialForms - `else` now works for try expressions - for now works with `into` for lists ### Removed - Removed erlang.js. ## [0.11.0] - 2015-09-17 ### Added - Added `JS` module with `new`, `mutate`, `import` macros - Added `Keyword` module with functions, `has_key?` and `get` - Added `Agent` module with functions, `start`, `get`, `update`, and `get_and_update` ### Changed - Map keys are now correctly turned into their atom counterparts if atom keys are used - `import` works with all options - `Mutable.update` has been replaced by `JS.update` - `transpile`, `transpile_quoted`, and `transpile_path` are now `compile`, `compile_quoted`, and `compile_path` - All Standard libraries are rolled up into one elixir.js file and imported from that - Modules no longer export a default object - `alias` now translates to a namespace import unless `default` option is given ## [0.10.0] - 2015-09-02 ### Added - Added `env` option for `ElixirScript.transpile` adding macros for compilation - Added `Logger` that translates Logger functions to console ### Changed - Updated `Kernel` module to translate some functions to it's JavaScript equivalent ### Fixed - Fixed `case` implementation to add `this` to call ## [0.9.0] - 2015-08-30 ### Added - an implementation for quote. Currently ignores `:location` and `:context` options - an implementation for unquote and unquote_splicing ## [0.8.0] - 2015-08-15 ### Added - Can now support catch blocks in try expressions - Added receive ### Changed - Updated pattern matching implementation - Wrapped try's in function closure to make sure they return a value; ## [0.7.0] - 2015-08-01 ### Added - Can now support rescue and after blocks in try expressions ## [0.6.5] - 2015-07-13 ### Changed - Now using the JS code generator from elixir-estree for code generation, improving speed of transpilation - the parse functions in the ElixirScript module have been renamed to transpile ## [0.6.0] - 2015-07-02 ### Added - Added iterators for Range and BitString - Now replacing characters that can't be used in variable and function names in JavaScript with something that it (i.e. `match?` -> `match__qmark__`) - Implemented Integer module ### Changed - Made the Tuple, Range and BitString data structures more immutable - Atom now translates to an ES6 Symbol - List now translates to a frozen JS Array - Updated the pattern match binding to use ES6 destructuring for lists and tuples - Inner modules are now split out into their own files * Standard lib is now exported with file output from cli * Standard lib modules are now automatically imported * No longer have to define modules via aliases ahead of time. They will be automatically be resolved and made into JavaScript import statements ## [0.5.0] - 2015-05-31 ### Added - added `from` clause to `import`, `alias`, and `require` so that the import path can be overridden ### Changed - For statements now work with pattern matching tuples - Improved function chaining - `alias` now acts like `require` in that it is translated into an import default statement - modules now export a default object with def functions added as properties on it. - for function closures, now calling by using `.call(this)` so that `this` is available inside of it ## [0.4.0] - 2015-05-05 ### Added - bitstrings - Better Pattern Matching (Does not support bitstrings yet) - Capture Operator - Added more functions from the list standard library ### Changed - Updated variable implementation to match Elixir's (i.e. Reusing the same variable name creates a new one in the background) ### Fixed - Fixed multi arity implementation ## [0.3.0] - 2015-04-23 ### Added - function and case guards - function and case pattern matching ### Changed - Can now use ^ on a variable during assignment ## [0.2.1] - 2015-04-14 ### Changed - Renamed project to ElixirScript - Reduced escript file size ## [0.2.0] - 2015-04-12 ### Added - Pipe operator - String interpolation - Adding more functions to the Kernel module - Fully implemented Tuple module - Fully implemented Atom module - Fully implemented Range module ### Changed - Now checking to see if a function is a Kernel function and prepending Kernel to it - Now turning Atoms into an Atom javascript object instead of a Symbol - Now turning tuples into a Tuple javascript object - Can now call properties and zero parameter functions correctly - case, cond, and if are now turned into if statements wrapped in function closures - Anonymous functions are now turned into anonymous functions in javascript insteed of arrow functions ## [0.1.0] - 2015-04-04 ### Added - From standard library implemented: * Enum.map * Kernel.tl * Kernel.hd * Logger - Implemented language features: * All primitives except bitstrings * defmodule * import, alias, and require * case, cond, if * def, defp * defstruct, defexception * raise * multiple arity functions * basic binary operations * for without into elixirscript-0.31.1/CONTRIBUTING.md000066400000000000000000000133531316305330500165520ustar00rootroot00000000000000# Contributing to ElixirScript This contributing guide is based on the contributing for Elixir with changes suitable for this project. ## Using the issue tracker Use the issues tracker for: * [bug reports](#bug-reports) * [submitting pull requests](#pull-requests) * [feature requests](#feature-requests) ## Bug reports A bug is a _demonstrable problem_ that is caused by the code in the repository. Good bug reports are extremely helpful - thank you! Guidelines for bug reports: 1. **Use the GitHub issue search** — [check if the issue has already been reported](https://github.com/elixirscript/elixirscript/search?type=Issues). 2. **Check if the issue has been fixed** — try to reproduce it using the `master` branch in the repository. 3. **Isolate and report the problem** — ideally create a reduced test case. Please try to be as detailed as possible in your report. Please provide steps to reproduce the issue as well as the outcome you were expecting! All these details will help developers to fix any potential bugs. Example: > Short and descriptive example bug report title > > A summary of the issue and the environment in which it occurs. If suitable, > include the steps required to reproduce the bug. > > 1. This is the first step > 2. This is the second step > 3. Further steps, etc. > > `` - a link to the reduced test case (e.g. a GitHub Gist) > > Any other information you want to share that is relevant to the issue being > reported. This might include the lines of code that you have identified as > causing the bug, and potential solutions (and your opinions on their > merits). ## Feature requests Feature requests are welcome. But take a moment to find out whether your idea fits with the scope and aims of the project. It's up to *you* to make a strong case to convince the community of the merits of this feature. Please provide as much detail and context as possible. ## Contributing Contributions to ElixirScript are welcomed! These contributions can be in the form or code changes, documentation, or ideas of how to implement features found in Elixir in ElixirScript. ElixirScript is broken up into the following parts: * The compiler, written in Elixir * The JavaScript core The ElixirScript compiler is in the `lib` folder of the project. Here is where Elixir code is converted into JavaScript. The JavaScript code is in the `src/javascript`. This is where the special forms and the Erlang Compatibility Layer are defined The ElixirScript tests can be run using `mix test` The JavaScript tests can be run using `yarn test` Please make sure all tests pass after making changes. Also make sure to include tests for the changes you made. ## Pull requests Good pull requests - patches, improvements, new features - are a fantastic help. They should remain focused in scope and avoid containing unrelated commits. **NOTE**: Do not send code style changes as pull requests like changing the indentation of some particular code snippet or how a function is called. Those will not be accepted as they pollute the repository history with non functional changes and are often based on personal preferences. **IMPORTANT**: By submitting a patch, you agree that your work will be licensed under the license used by the project. If you have any large pull request in mind (e.g. implementing features, refactoring code, etc), **please ask first** otherwise you risk spending a lot of time working on something that the project's developers might not want to merge into the project. Please adhere to the coding conventions in the project (indentation, accurate comments, etc.) and don't forget to add your own tests and documentation. When working with Git, we recommend the following process in order to craft an excellent pull request: 1. [Fork](https://help.github.com/fork-a-repo/) the project, clone your fork, and configure the remotes: ```sh # Clone your fork of the repo into the current directory git clone https://github.com//elixirscript # Navigate to the newly cloned directory cd elixirscript # Assign the original repo to a remote called "upstream" git remote add upstream https://github.com/elixirscript/elixirscript ``` 2. If you cloned a while ago, get the latest changes from upstream: ```sh git checkout master git pull upstream master ``` 3. Create a new topic branch (off of `master`) to contain your feature, change, or fix. **IMPORTANT**: Making changes in `master` is discouraged. You should always keep your local `master` in sync with upstream `master` and make your changes in topic branches. ```sh git checkout -b ``` 4. Commit your changes in logical chunks. Keep your commit messages organized, with a short description in the first line and more detailed information on the following lines. Feel free to use Git's [interactive rebase](https://help.github.com/articles/interactive-rebase) feature to tidy up your commits before making them public. 5. Make sure all the tests are still passing. ```sh mix test yarn test ``` This is needed to ensure your changes can pass all the tests. 6. Push your topic branch up to your fork: ```sh git push origin ``` 7. [Open a Pull Request](https://help.github.com/articles/using-pull-requests/) with a clear title and description. 8. If you haven't updated your pull request for a while, you should consider rebasing on master and resolving any conflicts. **IMPORTANT**: _Never ever_ merge upstream `master` into your branches. You should always `git rebase` on `master` to bring your changes up to date when necessary. ```sh git checkout master git pull upstream master git checkout git rebase master ``` Thank you for your contributions! elixirscript-0.31.1/JavascriptInterop.md000066400000000000000000000054431316305330500203130ustar00rootroot00000000000000# JavaScript Interoperability ## Data Type Conversions ElixirScript translates Elixir primitive types to the following: | Elixir | JavaScript | |--------|------------| | Integer | Number | | Float | Number | | Binary | String | | Atom | Symbol | | List | Array | | Map | Map | | Tuple | ErlangTypes.Tuple | | Bitstring | ErlangTypes.Bitstring | | PID | ErlangTypes.PID | | Reference | ErlangTypes.Reference | The ErlangTypes library can be found [here](https://github.com/elixirscript/erlang-types) ## ElixirScript Calling JavaScript ### ElixirScript.JS module The `ElixirScript.JS` module has functions and macros that help with interacting with JavaScript. Most of them correspond to JavaScript keywords that may be useful. ```elixir # Calling the JavaScript Debugger ElixirScript.JS.debugger() # Getting the type of a value ElixirScript.JS.typeof(my_value) ``` ### Foreign Function Interface ElixirScript calls JavaScript modules through a Foreign Function Interface (FFI). A foreign module is defined by creating a new Elixir module and adding `use ElixirScript.FFI` to it. Here is an example of a foreign module for a JSON module ```elixir defmodule MyApp.JSON do use ElixirScript.FFI defexternal stringify(map) defexternal parse(string) end ``` Foreign modules map to JavaScript files that export functions defined with the `defexternal` macro. ElixirScript expects JavaScript modules to be in the `priv/elixir_script` directory. These modules are copied to the output directory upon compilation. For our example, a JavaScript file must be placed at `priv/elixir_script/my_app/json.js`. It looks like this ```javascript export default { stringify: JSON.stringify, parse: JSON.parse } ``` For more information and options. Check the documentation for `ElixirScript.FFI` ## JavaScript Calling ElixirScript In order to start an ElixirScript application, you must first import it using whichever JavaScript module system you are using and then call `Elixir.start` ```Elixir # Our ElixirScript module defmodule Main do def start(:normal, args) do args end end ``` ```javascript import Elixir from './elixirscript.build.js' Elixir.start(Elixir.Main, [1, 2, 3]) ``` In the above example, we have an ElixirScript module, `Main` with a `start/2` function. This function is the entry point into your ElixirScript application. when we call `Elixir.start`, we give it this module's name (All modules when compiled begin with `Elixir.`) and a list of the initial args. If you want to use an ElixirScript module inside of your JavaScript code, you can do so using `Elixir.load`. ```Elixir # Our ElixirScript module defmodule MyModule do def hi() do "hello" end end ``` ```javascript const MyModule = Elixir.load(Elixir.MyModule); MyModule.hi() ``` elixirscript-0.31.1/LICENSE000066400000000000000000000020661316305330500153250ustar00rootroot00000000000000The MIT License (MIT) Copyright (c) 2015 Bryan Joseph Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.elixirscript-0.31.1/Makefile000066400000000000000000000006341316305330500157570ustar00rootroot00000000000000.PHONY: compile test clean js_compile elixir_compile elixir_test js_test deps elixir_deps js_deps default: deps compile compile: js_compile elixir_compile js_compile: yarn build elixir_compile: mix compile test: js_compile elixir_test js_test js_test: yarn test elixir_test: mix test --cover clean: rm -rf priv/build mix clean deps: elixir_deps js_deps elixir_deps: mix deps.get js_deps: yarn elixirscript-0.31.1/README.md000066400000000000000000000045551316305330500156040ustar00rootroot00000000000000## ElixirScript [![Documentation](https://img.shields.io/badge/docs-hexpm-blue.svg)](http://hexdocs.pm/elixir_script/) [![Build](https://travis-ci.org/elixirscript/elixirscript.svg?branch=master)](https://travis-ci.org/elixirscript/elixirscript) [![Deps Status](https://beta.hexfaktor.org/badge/all/github/bryanjos/elixirscript.svg)](https://beta.hexfaktor.org/github/bryanjos/elixirscript) [![Join the chat at https://gitter.im/elixirscript/elixirscript](https://badges.gitter.im/elixirscript/elixirscript.svg)](https://gitter.im/elixirscript/elixirscript?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge) The goal is to convert a subset (or full set) of Elixir code to JavaScript, providing the ability to write JavaScript in Elixir. This is done by taking the Elixir AST and converting it into JavaScript AST and then to JavaScript code. This is done using the [Elixir-ESTree](https://github.com/elixirscript/elixir-estree) library. Requirements =========== * Erlang 20 or greater * Elixir 1.5 or greater (must be compiled with Erlang 20 or greater) * Node 8.2.1 or greater (only for development) Usage ======== Add dependency to your deps in mix.exs: ``` elixir {:elixir_script, "~> x.x"} ``` Add `elixir_script` to list of mix compilers in mix.exs Also add `elixir_script` configuration ```elixir def project do [ app: :my_app, # ... # Add elixir_script as a compilter compilers: Mix.compilers ++ [:elixir_script], # Our elixir_script configuration elixir_script: [ # Entry module. Can also be a list of modules input: MyEntryModule, # Output path. Either a path to a js file or a directory output: "priv/elixir_script/build/elixirscript.build.js" ] ] end ``` Run `mix compile` Examples ========== ### Application [ElixirScript Todo Example](https://github.com/elixirscript/todo-elixirscript) ### Library [ElixirScript React](https://github.com/elixirscript/elixirscript_react) Development =========== ```bash # Clone the repo git clone git@github.com:bryanjos/elixirscript.git #Get dependencies make deps # Compile make # Test make test ``` Communication ======== [gitter room](https://gitter.im/elixirscript/elixirscript) [#elixirscript](https://elixir-lang.slack.com/messages/elixirscript/) on the elixir-lang Slack Contributing ======== Please check the [CONTRIBUTING.md](CONTRIBUTING.md) elixirscript-0.31.1/config/000077500000000000000000000000001316305330500155615ustar00rootroot00000000000000elixirscript-0.31.1/config/config.exs000066400000000000000000000022001316305330500175410ustar00rootroot00000000000000# This file is responsible for configuring your application # and its dependencies with the aid of the Mix.Config module. use Mix.Config # This configuration is loaded before any dependency and is restricted # to this project. If another project depends on this project, this # file won't be loaded nor affect the parent project. For this reason, # if you want to provide default values for your application for third- # party users, it should be done in your mix.exs file. # Sample configuration: # config :logger, :console, level: :debug, format: "$date $time [$level] $metadata$message\n", metadata: [:user_id] config :elixir_script, lib_path: nil #The path to the elixirscript core and standard library JavaScript files # It is also possible to import configuration files, relative to this # directory. For example, you can emulate configuration per environment # by uncommenting the line below and defining dev.exs, test.exs and such. # Configuration from the imported file will override the ones defined # here (which is why it is important to import them last). # import_config "#{Mix.env}.exs" elixirscript-0.31.1/config/dev.exs000066400000000000000000000000171316305330500170560ustar00rootroot00000000000000use Mix.Config elixirscript-0.31.1/config/prod.exs000066400000000000000000000000171316305330500172440ustar00rootroot00000000000000use Mix.Config elixirscript-0.31.1/config/test.exs000066400000000000000000000000171316305330500172570ustar00rootroot00000000000000use Mix.Config elixirscript-0.31.1/lib/000077500000000000000000000000001316305330500150625ustar00rootroot00000000000000elixirscript-0.31.1/lib/elixir_script.ex000066400000000000000000000065521316305330500203100ustar00rootroot00000000000000defmodule ElixirScript do @moduledoc """ ElixirScript acts as a mix compiler. This means that when you execute `mix compile`, ElixirScript's compiler will run as well. Make sure to add ElixirScript to your list of compilers in mix.exs. ElixirScript must be told which modules to use as the entry to your ElixirScript application. This is done by adding an `elixir_script` key to your project configuration whose value is a keyword list of options. Add an `input` key and make the value either the name of a module or a list of modules that are the entry modules you wish to compile to JavaScript. ElixirScript will use those modules to find what other modules and functions it needs to convert to JavaScript. ElixirScript by default places output in `priv/elixir_script/build`. If you wish to change this, add an `output` key to your ElixirScript configuration. An example configuration for a project is shown below ``` elixir def project do [ app: :my_app, version: "0.1.0", elixir: "~> 1.0", deps: deps, # Add elixir_script as a compilter compilers: Mix.compilers ++ [:elixir_script], # Our elixir_script configuration elixir_script: [ # Entry module. Can also be a list of modules input: MyEntryModule, # Output path. Either a path to a js file or a directory output: "priv/elixir_script/build/elixirscript.build.js" ] ] end ``` Available options are: * `input` (required): The entry module(s) for your application or library * `output`: The path of the generated JavaScript file. (defaults to `priv/elixir_script/build`) If path ends in `.js` then that will be the name of the file. If a directory is given, file will be named `elixirscript.build.js` * `root`: Optional root for imports of FFI JavaScript modules. Defaults to `.`. If using output directly in a browser, you may want to make it something like `/js` or some uri. Now run `mix compile` and you should see a JavaScript file named `elixirscript.build.js` in the `priv/elixir_script/build/` directory. ElixirScript outputs JavaScript in the ES Module format. If your browser supports it, you can include the output in a script tag with the type "module" ```html ``` If your browser does not yet support ES modules directly, use a tool such as [webpack](https://webpack.js.org/) or [brunch](http://brunch.io/) to convert it into something that can be used in the browser ### JavaScript Interop Check out the [JavaScript Interoperability](JavascriptInterop.html) documentation ### Dependencies ElixirScript can use many of the same Hex packages and dependencies that currently exist. It is also possible to make packages that are specific to ElixirScript. If you decide to make such a package, please prepend `elixir_script` to the app name. For instance is making a package for ElixirScript with FFI modules for interacting with React, the name would be `elixir_script_react`. This is to make sure that other developers know that a package in Hex is specifically for use with ElixirScript. ### Limitations ElixirScript does not support `receive` or any of OTP at this time. """ end elixirscript-0.31.1/lib/elixir_script/000077500000000000000000000000001316305330500177425ustar00rootroot00000000000000elixirscript-0.31.1/lib/elixir_script/beam.ex000066400000000000000000000073151316305330500212120ustar00rootroot00000000000000defmodule ElixirScript.Beam do @moduledoc false @doc """ Takes a module and finds the expanded AST from the debug info inside the beam file. For protocols, this will return a list of all the protocol implementations """ @spec debug_info(atom | bitstring) :: {:ok | :error, map | binary} def debug_info(module) # We get debug info from String and then replace # functions in it with equivalents in ElixirScript.String. # This is so that we don't include the unicode database # in our output def debug_info(String) do {:ok, info} = do_debug_info(String) {:ok, ex_string_info} = do_debug_info(ElixirScript.String) definitions = replace_definitions(info.definitions, ex_string_info.definitions) info = %{info | definitions: definitions} {:ok, info} end # Replace some modules with ElixirScript versions def debug_info(module) when module in [Agent] do case do_debug_info(Module.concat(ElixirScript, module)) do {:ok, info} -> {:ok, Map.put(info, :module, module)} e -> e end end def debug_info(module) when is_atom(module) do do_debug_info(module) end def debug_info(beam) when is_bitstring(beam) do do_debug_info(beam) end defp do_debug_info(module, path \\ nil) defp do_debug_info(module, _) when is_atom(module) do case :code.get_object_code(module) do {_, beam, beam_path} -> do_debug_info(beam, beam_path) :error -> {:error, "Unknown module"} end end defp do_debug_info(beam, beam_path) do with {:ok, {module, [debug_info: {:debug_info_v1, backend, data}]}} <- :beam_lib.chunks(beam, [:debug_info]), {:ok, {^module, attribute_info}} = :beam_lib.chunks(beam, [:attributes]) do if Keyword.get(attribute_info[:attributes], :protocol) do get_protocol_implementations(module) else backend.debug_info(:elixir_v1, module, data, []) |> process_debug_info(beam_path) end else :error -> {:error, "Unknown module"} {:error, :beam_lib, {:unknown_chunk, "non_existing.beam", :debug_info}} -> {:error, "Unsupported version of Erlang"} {:error, :beam_lib, {:missing_chunk, _ , _}} -> {:error, "Debug info not available"} {:error, :beam_lib, {:file_error, "non_existing.beam", :enoent}} -> {:error, "Debug info not available"} end end defp process_debug_info({:ok, info}, nil) do info = Map.put(info, :last_modified, nil) {:ok, info} end defp process_debug_info({:ok, info}, beam_path) do info = case File.stat(beam_path, time: :posix) do {:ok, file_info} -> Map.put(info, :last_modified, file_info.mtime) _ -> Map.put(info, :last_modified, nil) end {:ok, info} end defp process_debug_info(error, _) do error end defp get_protocol_implementations(module) do implementations = module |> Protocol.extract_impls(:code.get_path()) |> Enum.map(fn(x) -> Module.concat([module, x]) end) |> Enum.map(fn(x) -> case debug_info(x) do {:ok, info} -> {x, info} _ -> raise "Unable to compile protocol implementation #{inspect x}" end end) {:ok, module, implementations} end defp replace_definitions(original_definitions, replacement_definitions) do Enum.map(original_definitions, fn {{function, arity}, type, _, _} = ast -> ex_ast = Enum.find(replacement_definitions, fn {{ex_function, ex_arity}, ex_type, _, _} -> ex_function == function and ex_arity == arity and ex_type == type end) case ex_ast do nil -> ast _ -> ex_ast end end) end end elixirscript-0.31.1/lib/elixir_script/cli.ex000066400000000000000000000040111316305330500210430ustar00rootroot00000000000000defmodule ElixirScript.CLI do @moduledoc false @app_version Mix.Project.config()[:version] @switches [ output: :string, help: :boolean, version: :boolean, root: :string ] @aliases [ o: :output, h: :help, v: :version ] def parse_args(args) do { options, input, errors } = OptionParser.parse(args, switches: @switches, aliases: @aliases) cond do length(errors) > 0 -> :help Keyword.get(options, :help, false) -> :help Keyword.get(options, :version, false) -> :version length(input) == 0 -> :help true -> { input, options } end end defp help_message do """ usage: elixirscript [options] the entry module of your application the path to .ex(s) files to compile options: -o --output [path] places output at the given path. Can be a directory or filename. -v --version the current version number -h --help this message --root The root import path for FFI imports """ end def process(:help) do IO.write help_message() end def process(:version) do IO.write @app_version end def process({ input, options }) do if options_contains_unknown_values(options) do process(:help) else do_process(input, options) end end defp do_process(input, options) do compile_opts = [ output: Keyword.get(options, :output, :stdout), root: Keyword.get(options, :root, ".") ] input = handle_input(input) ElixirScript.Compiler.compile(input, compile_opts) end defp options_contains_unknown_values(options) do Enum.any?(options, fn({key, _value}) -> if key in Keyword.keys(@switches) do false else true end end) end defp handle_input(input) do input |> Enum.map(fn(x) -> String.split(x, [" ", ","], trim: true) end) |> List.flatten |> Enum.map(fn(x) -> Module.concat([x]) end) end end elixirscript-0.31.1/lib/elixir_script/compile_error.ex000066400000000000000000000001051316305330500231350ustar00rootroot00000000000000defmodule ElixirScript.CompileError do defexception [:message] end elixirscript-0.31.1/lib/elixir_script/compiler.ex000066400000000000000000000051421316305330500221140ustar00rootroot00000000000000defmodule ElixirScript.Compiler do @moduledoc """ The entry point for the ElixirScript compilation process. Takes the given module(s) and compiles them and all modules and functions they use into JavaScript. Will also take a path to Elixir files """ @doc """ Takes either a module name, list of module names, or a path as the entry point(s) of an application/library. From there it will determine which modules and functions are needed to be compiled. Available options are: * `output`: The path of the generated JavaScript file. If output is `nil`, then generated code is sent to standard out If output is a path, the generated code placed in that path. If path ends in `.js` then that will be the name of the file. If a directory is given, file will be named `elixirscript.build.js` * `root`: Optional root for imports of FFI JavaScript modules. Defaults to `.`. """ alias ElixirScript.{ State, Translate, FindUsedModules, FindUsedFunctions, Output } alias ElixirScript.ModuleSystems.ES alias Kernel.ParallelCompiler @spec compile(atom | [atom] | binary, []) :: nil def compile(path, opts \\ []) def compile(path, opts) when is_binary(path) do opts = build_compiler_options(opts) {:ok, pid} = State.start_link() path = if String.ends_with?(path, [".ex", ".exs"]) do path else Path.join([path, "**", "*.{ex,exs}"]) end files = Path.wildcard(path) ParallelCompiler.files(files, [ each_module: &on_module_compile(pid, &1, &2, &3) ]) entry_modules = pid |> State.get_in_memory_modules |> Keyword.keys do_compile(entry_modules, pid, opts) end def compile(entry_modules, opts) do opts = build_compiler_options(opts) {:ok, pid} = State.start_link() entry_modules = List.wrap(entry_modules) do_compile(entry_modules, pid, opts) end defp do_compile(entry_modules, pid, opts) do FindUsedModules.execute(entry_modules, pid) FindUsedFunctions.execute(entry_modules, pid) modules = State.list_modules(pid) Translate.execute(modules, pid) modules = State.list_modules(pid) result = Output.execute(modules, pid, opts) State.stop(pid) result end defp build_compiler_options(opts) do default_options = Map.new |> Map.put(:output, Keyword.get(opts, :output)) |> Map.put(:format, :es) |> Map.put(:root, Keyword.get(opts, :root, ".")) options = default_options Map.put(options, :module_formatter, ES) end defp on_module_compile(pid, _file, module, beam) do State.put_in_memory_module(pid, module, beam) end end elixirscript-0.31.1/lib/elixir_script/ffi.ex000066400000000000000000000061721316305330500210520ustar00rootroot00000000000000defmodule ElixirScript.FFI do @moduledoc """ The Foreign Function Interface (FFI) for interacting with JavaScript To define a foreign module, make a new module and add `use ElixirScript.FFI`. to it To define external functions, use the `defexternal` macro. Here is an example of a foreign module for a JSON module ```elixir defmodule MyApp.JSON do use ElixirScript.FFI defexternal stringify(map) defexternal parse(string) end ``` Foreign modules map to JavaScript files that export functions defined with the `defexternal` macro. ElixirScript expects JavaScript modules to be in the `priv/elixir_script` directory. These modules are copied to the output directory upon compilation. For our example, a JavaScript file must be placed in the `priv/elixir_script` folder. In our example, it could either be `priv/elixir_script/my_app/json.js` or `priv/elixir_script/my_app.json.js`. ElixirScript will look for either path It looks like this ```javascript export default { stringify: JSON.stringify, parse: JSON.parse } ``` `ElixirScript.FFI` takes the following options * `global`: If the module is defined in the global state or not. If this is set to `true`, nothing is imported and instead ElixirScript will use the name of the module to call a module and function in the global scope. * `name`: Only applicable with `global` is set to `true`. This will use the name defined here instead of the module name for calling modules and functions in the global scope An example using the global option to reference the JSON module in browsers ```elixir defmodule JSON do use ElixirScript.FFI, global: true defexternal stringify(map) defexternal parse(string) end ``` The calls above are translated to calls to the `JSON` module in the global scope An example using global and name options ```elixir defmodule Console do use ElixirScript.FFI, global: true, name: :console defexternal log(term) end ``` With the above, calls in ElixirScript to `Console.log` will translate to `console.log` in JavaScript """ defmacro __using__(opts) do quote do import ElixirScript.FFI Module.register_attribute __MODULE__, :__foreign_info__, persist: true @__foreign_info__ %{ path: Macro.underscore(__MODULE__), name: unquote(Keyword.get(opts, :name, nil)), global: unquote(Keyword.get(opts, :global, false)) } end end @doc """ Defines a JavaScript function to be called from Elixir modules To define an external function, pass the name and arguments to `defexternal` ```elixir defexternal my_js_function(arg1, arg2, arg3) ``` """ defmacro defexternal({name, _, args}) do args = Enum.map(args, fn {:\\, meta0, [{name, meta, atom}, value]} -> name = String.to_atom("_" <> Atom.to_string(name)) {:\\, meta0, [{name, meta, atom}, value]} {name, meta, atom} -> name = String.to_atom("_" <> Atom.to_string(name)) {name, meta, atom} other -> other end) quote do def unquote(name)(unquote_splicing(args)), do: nil end end end elixirscript-0.31.1/lib/elixir_script/lib/000077500000000000000000000000001316305330500205105ustar00rootroot00000000000000elixirscript-0.31.1/lib/elixir_script/lib/agent.ex000066400000000000000000000020541316305330500221450ustar00rootroot00000000000000defmodule ElixirScript.Agent do @moduledoc false def start(fun, options \\ []) do name = if Keyword.has_key?(options, :name) do Keyword.get(options, :name) else nil end pid = ElixirScript.Core.Store.create(fun.(), name) { :ok, pid } end def start_link(fun, options \\ []) do name = if Keyword.has_key?(options, :name) do Keyword.get(options, :name) else nil end pid = ElixirScript.Core.Store.create(fun.(), name) { :ok, pid } end def stop(agent) do ElixirScript.Core.Store.remove(agent) :ok end def update(agent, fun) do current_state = ElixirScript.Core.Store.read(agent) ElixirScript.Core.Store.update(agent, fun.(current_state)) :ok end def get(agent, fun) do current_state = ElixirScript.Core.Store.read(agent) fun.(current_state) end def get_and_update(agent, fun) do current_state = ElixirScript.Core.Store.read(agent) {val, new_state} = fun.(current_state) ElixirScript.Core.Store.update(agent, new_state) val end end elixirscript-0.31.1/lib/elixir_script/lib/functions.ex000066400000000000000000000002541316305330500230570ustar00rootroot00000000000000defmodule ElixirScript.Core.Functions do @moduledoc false use ElixirScript.FFI, global: true defexternal split_at(value, position) defexternal graphemes(str) end elixirscript-0.31.1/lib/elixir_script/lib/js.ex000066400000000000000000000036441316305330500214710ustar00rootroot00000000000000defmodule ElixirScript.JS do @moduledoc """ This module defines macros and functions which implement JavaScript functionality that may not translate easily to Elixir. For instance, creating a new object """ use ElixirScript.FFI, global: true @doc """ Creates new JavaScript objects. ```elixir ElixirScript.JS.new User, ["first_name", "last_name"] ``` """ defexternal new(module, params) @doc """ Returns the type of the given value """ defexternal typeof(value) @doc """ Determines if value is an instance of type. """ defexternal instanceof(value, type) @doc """ Throws the term given """ defexternal throw(term) @doc """ Creates a breakpoint for JavaScript debuggers to stop at """ defexternal debugger() @doc """ The current JavaScript context """ defexternal this() @doc """ Mutates an existing JavaScript object. ```elixir ElixirScript.JS.mutate elem, "width", 100 ``` """ defexternal mutate(object, key, value) @doc """ Takes the given map and returns an object Throws an error if any key is not a number, binary, or atom ```elixir ElixirScript.JS.map_to_object(%{my: "map"}) ``` """ defexternal map_to_object(map) @doc """ Takes the given map and returns an object Throws an error if any key is not a number, binary, or atom ```elixir ElixirScript.JS.map_to_object(%{my: "map"}, keys: :string) ``` """ defexternal map_to_object(map, options) @doc """ Takes the given object and returns a map Options include [{:keys, :atom}, {:recurse_array, true}] ```elixir ElixirScript.JS.object_to_object({my: "object"}) ``` """ defexternal object_to_map(object) @doc """ Takes the given object and returns a map Options include [{:keys, :atom}, {:recurse_array, true}] ```elixir ElixirScript.JS.object_to_object({my: "map"}, keys: :atom) ``` """ defexternal object_to_map(object, options) end elixirscript-0.31.1/lib/elixir_script/lib/store.ex000066400000000000000000000003411316305330500222000ustar00rootroot00000000000000defmodule ElixirScript.Core.Store do @moduledoc false use ElixirScript.FFI, global: true defexternal create(value, name \\ nil) defexternal update(key, value) defexternal read(key) defexternal remove(key) end elixirscript-0.31.1/lib/elixir_script/lib/string.ex000066400000000000000000000071111316305330500223540ustar00rootroot00000000000000defmodule ElixirScript.String do @moduledoc false import Kernel, except: [length: 1] def to_atom(str) do :erlang.binary_to_atom(str, :utf8) end def to_existing_atom(str) do :erlang.binary_to_existing_atom(str, :utf8) end def to_char_list(str) do str.split("") end def to_float(str) do :erlang.binary_to_float(str) end def to_integer(str) do :erlang.binary_to_integer(str) end def to_integer(str, base) do :erlang.binary_to_integer(str, base) end def upcase(str) do str.toUpperCase() end def downcase(str) do str.toLowerCase() end def at(str, pos) do case pos > length(str) do true -> nil _ -> str[pos] end end def capitalize(str) do first = str[0].toUpperCase() rest = str.substr(1).toLowerCase() first <> rest end def split(str) do str.split() end def split(str, replace, options \\ []) do limit = Keyword.get(options, :parts, -1) trim = Keyword.get(options, :trim, false) split = str.split(replace, limit) Enum.map(split, fn(x) -> if trim do x.trim() else x end end) end def next_grapheme(nil), do: nil def next_grapheme(""), do: nil def next_grapheme(str) do { str[0], str.substr(1) } end def first(nil), do: nil def first(str) do str[0] end def last(nil), do: nil def last(str) do str[length(str) - 1] end def graphemes(str) do ElixirScript.Core.Functions.graphemes(str) end def length(str) do graphemes(str).length() end def match?(str, regex) do str.match(regex) != nil end def next_codepoint(nil), do: nil def next_codepoint(""), do: nil def next_codepoint(str) do { str[0].codePointAt(0), str.substr(1) } end def reverse(str) do do_reverse(str, "") end defp do_reverse("", str) do str end defp do_reverse(str, reverse_str) do do_reverse(str.substr(1), reverse_str <> last(str)) end def starts_with?(str, prefix) when is_binary(prefix) do str.startsWith(prefix) end def starts_with?(str, prefixes) when is_list(prefixes) do do_starts_with?(str, prefixes) end def do_starts_with?(_, []) do false end def do_starts_with?(str, prefixes) do case starts_with?(str, hd(prefixes)) do true -> true _ -> do_starts_with?(str, tl(prefixes)) end end def ends_with?(str, suffix) when is_binary(suffix) do str.endsWith(suffix) end def ends_with?(str, suffixes) when is_list(suffixes) do do_ends_with?(str, suffixes) end def do_ends_with?(_, []) do false end def do_ends_with?(str, suffixes) do case ends_with?(str, hd(suffixes)) do true -> true _ -> do_ends_with?(str, tl(suffixes)) end end def duplicate(str, n) do str.repeat(n) end def contains?(str, s) when is_binary(s) do str.indexOf(s) > -1 end def contains?(str, s) when is_list(s) do do_contains?(str, s) end def do_contains?(_, []) do false end def do_contains?(str, prefixes) do case contains?(str, hd(prefixes)) do true -> true _ -> do_contains?(str, tl(prefixes)) end end def codepoints(str) do do_codepoints(str, []) end def do_codepoints("", codepoint_list) do codepoint_list end def do_codepoints(str, codepoint_list) do do_codepoints(str.substr(1), codepoint_list ++ [first(str).codePointAt(0)]) end def valid?(str) do is_binary(str) end def split_at(value, position) do ElixirScript.Core.Functions.split_at(value, position) end end elixirscript-0.31.1/lib/elixir_script/module_systems/000077500000000000000000000000001316305330500230165ustar00rootroot00000000000000elixirscript-0.31.1/lib/elixir_script/module_systems/es.ex000066400000000000000000000021461316305330500237660ustar00rootroot00000000000000defmodule ElixirScript.ModuleSystems.ES do @moduledoc false alias ESTree.Tools.Builder, as: JS def build(js_imports, body, exports) do imports = js_imports |> Enum.map(fn {_module, name, _path, import_path} -> import_module(name, import_path) end) export = if is_nil(exports), do: [], else: [export_module(exports)] imports ++ body ++ export end def build_imports(js_imports) do js_imports |> Enum.map(fn {_module, name, _path, import_path} -> import_module(name, import_path) end) end def build_export(exports) do if is_nil(exports), do: [], else: [export_module(exports)] end defp import_module(import_name, from) do js_module_name = JS.identifier(import_name) import_specifier = JS.import_default_specifier( js_module_name ) do_import_module([import_specifier], from) end defp do_import_module(import_specifiers, file_path) do JS.import_declaration( import_specifiers, JS.literal(file_path) ) end defp export_module(exported_object) do JS.export_default_declaration(exported_object) end end elixirscript-0.31.1/lib/elixir_script/module_systems/namespace.ex000066400000000000000000000033001316305330500253040ustar00rootroot00000000000000defmodule ElixirScript.ModuleSystems.Namespace do @moduledoc false alias ESTree.Tools.Builder, as: JS alias ElixirScript.Translate.Helpers alias ElixirScript.Translate.Identifier def build(module_name, body, exports) do List.wrap(make_namespace_body(module_name, body, exports)) end defp module_name_function_call(module_name, function) do members = ["Elixir"] ++ Module.split(module_name) ++ [function] Identifier.make_namespace_members(members) end defp build_namespace() do JS.member_expression( JS.identifier("ElixirScript"), JS.member_expression( JS.identifier(:Core), JS.member_expression( JS.identifier(:Functions), JS.identifier(:build_namespace) ) ) ) end defp make_namespace_body(module_name, body, exports) do values = module_name_function_call(module_name, "__exports") js_if = JS.if_statement( values, JS.return_statement(values) ) exports = if is_nil(exports) do JS.object_expression([]) else exports end declaration = Helpers.declare("__exports", exports) assign = Helpers.assign(values, JS.identifier("__exports")) exports = [JS.return_statement(JS.identifier("__exports"))] make = JS.member_expression( Helpers.call( build_namespace(), [JS.identifier("Elixir"), JS.literal(Enum.join(["Elixir"] ++ Module.split(module_name), "."))] ), JS.identifier("__load") ) func_body = JS.block_statement([js_if] ++ body ++ [declaration, assign] ++ exports) func = Helpers.function([JS.identifier("Elixir")], func_body) Helpers.assign( make, func ) end end elixirscript-0.31.1/lib/elixir_script/passes/000077500000000000000000000000001316305330500212405ustar00rootroot00000000000000elixirscript-0.31.1/lib/elixir_script/passes/find_used_functions.ex000066400000000000000000000167441316305330500256420ustar00rootroot00000000000000defmodule ElixirScript.FindUsedFunctions do @moduledoc false alias ElixirScript.State, as: ModuleState @doc """ Takes a list of entry modules and finds modules they use along with documenting the functions used. The data collected about used functions is used to filter only the used functions for compilation """ @spec execute([atom], pid) :: nil def execute(entry_modules, pid) do entry_modules |> List.wrap |> Enum.each(fn module -> walk_module(module, pid) end) pid |> ElixirScript.State.list_modules |> Enum.each(fn {module, info} -> if get_in(info, [:attributes, :protocol_impl]) do walk_module(module, pid) end end) end defp walk_module(module, pid) do %{ attributes: _attrs, compile_opts: _compile_opts, definitions: defs, file: _file, line: _line, module: ^module, unreachable: unreachable } = ModuleState.get_module(pid, module) reachable_defs = Enum.filter(defs, fn { _, type, _, _} when type in [:defmacro, :defmacrop] -> false { name, _, _, _} -> not(name in unreachable) _ -> true end) state = %{ pid: pid, module: module } Enum.each(reachable_defs, fn({name, _type, _, _clauses}) -> ModuleState.add_used(state.pid, module, name) end) Enum.each(reachable_defs, &walk(&1, state)) end defp walk_module(module, function, arity, pid) do function = {function, arity} unless ModuleState.has_used?(pid, module, function) do info = ModuleState.get_module(pid, module) state = %{ pid: pid, module: module } reachable_def = Enum.find(Map.get(info, :definitions, []), fn { name, _, _, _} -> name == function end) case reachable_def do nil -> nil {name, _type, _, _clauses} = func -> ModuleState.add_used(state.pid, module, name) walk(func, state) end end end defp walk({{_name, _arity}, _type, _, clauses}, state) do Enum.each(clauses, &walk(&1, state)) end defp walk({ _, _args, _guards, body}, state) do walk_block(body, state) end defp walk({:->, _, [[{:when, _, params}], body ]}, state) do guards = List.last(params) params = params |> Enum.reverse |> tl |> Enum.reverse walk({[], params, guards, body}, state) end defp walk({:->, _, [params, body]}, state) do walk({[], params, [], body}, state) end defp walk({:|, _, [head, tail]}, state) do walk(head, state) walk(tail, state) end defp walk({:::, _, [target, _type]}, state) do walk(target, state) end defp walk(form, state) when is_list(form) do Enum.each(form, &walk(&1, state)) end defp walk({a, b}, state) do walk({:{}, [], [a, b]}, state) end defp walk({:{}, _, elements}, state) do walk(elements, state) end defp walk({:%{}, _, properties}, state) do Enum.each(properties, fn (val) -> walk(val, state) end) end defp walk({:<<>>, _, elements}, state) do Enum.each(elements, fn (val) -> walk(val, state) end) end defp walk({:=, _, [left, right]}, state) do walk(left, state) walk(right, state) end defp walk({:%, _, [module, params]}, state) do walk_module(module, :__struct__, 0, state.pid) walk_module(module, :__struct__, 1, state.pid) walk(params, state) end defp walk({:for, _, generators}, state) when is_list(generators) do Enum.each(generators, fn {:<<>>, _, body} -> walk(body, state) {:<-, _, [identifier, enum]} -> walk(identifier, state) walk(enum, state) [into: expression] -> walk(expression, state) [into: expression, do: expression2] -> walk(expression, state) walk_block(expression2, state) [do: expression] -> walk_block(expression, state) filter -> walk(filter, state) end) end defp walk({:case, _, [condition, [do: clauses]]}, state) do Enum.each(clauses, &walk(&1, state)) walk(condition, state) end defp walk({:cond, _, [[do: clauses]]}, state) do Enum.each(clauses, fn({:->, _, [clause, clause_body]}) -> Enum.each(List.wrap(clause_body), &walk(&1, state)) walk(hd(clause), state) end) end defp walk({:receive, _context, blocks}, state) do do_block = Keyword.get(blocks, :do) after_block = Keyword.get(blocks, :after, nil) walk_block(do_block, state) if after_block do Enum.each(List.wrap(after_block), &walk(&1, state)) end end defp walk({:try, _, [blocks]}, state) do try_block = Keyword.get(blocks, :do) rescue_block = Keyword.get(blocks, :rescue, nil) catch_block = Keyword.get(blocks, :catch, nil) after_block = Keyword.get(blocks, :after, nil) else_block = Keyword.get(blocks, :else, nil) walk_block(try_block, state) if rescue_block do Enum.each(rescue_block, fn {:->, _, [ [{:in, _, [param, names]}], body]} -> walk({[], [param], [{{:., [], [Enum, :member?]}, [], [param, names]}], body}, state) {:->, _, [ [param], body]} -> walk({[], [param], [], body}, state) end) end if catch_block do walk({:fn, [], catch_block}, state) end if after_block do Enum.each(List.wrap(after_block), &walk(&1, state)) end if else_block do walk({:fn, [], else_block}, state) end end defp walk({:fn, _, clauses}, state) do Enum.each(clauses, &walk(&1, state)) end defp walk({:with, _, args}, state) do Enum.each(args, fn {:<-, _, [left, right]} -> walk(left, state) walk(right, state) {:=, _, [left, right]} -> walk(left, state) walk(right, state) [do: expression] -> walk_block(expression, state) [do: expression, else: elses] -> walk_block(expression, state) Enum.each(elses, fn {:->, _, [left, right]} -> walk(left, state) walk(right, state) end) end) end defp walk({{:., _, [:erlang, :apply]}, _, [module, function, params]}, state) do walk({{:., [], [module, function]}, [], params}, state) end defp walk({{:., _, [:erlang, :apply]}, _, [function, params]}, state) do walk({function, [], params}, state) end defp walk({{:., _, [ElixirScript.JS, _]}, _, params}, state) do walk(params, state) end defp walk({{:., _, [module, function]}, _, params}, state) do cond do ElixirScript.Translate.Module.is_js_module(module, state) -> nil ElixirScript.Translate.Module.is_elixir_module(module) -> walk_module(module, function, length(params), state.pid) is_tuple(module) -> walk(module, state) true -> nil end walk(params, state) end defp walk({:super, _, [{_, function} | params]}, state) do walk_module(state.module, function, length(params), state.pid) walk(params, state) end defp walk({function, _, params}, state) when is_atom(function) and is_list(params) do walk_module(state.module, function, length(params), state.pid) walk(params, state) end defp walk({value, _, params}, state) when is_list(params) do walk(value, state) walk(params, state) end defp walk(_, _) do nil end defp walk_block(block, state) do case block do nil -> nil {:__block__, _, block_body} -> Enum.each(block_body, &walk(&1, state)) b when is_list(b) -> Enum.each(b, &walk(&1, state)) _ -> walk(block, state) end end end elixirscript-0.31.1/lib/elixir_script/passes/find_used_modules.ex000066400000000000000000000211101316305330500252610ustar00rootroot00000000000000defmodule ElixirScript.FindUsedModules do @moduledoc false alias ElixirScript.State, as: ModuleState require Logger @doc """ Takes a list of entry modules and finds modules they use. """ @spec execute([atom], pid) :: nil def execute(modules, pid) do modules |> List.wrap |> Enum.each(fn(module) -> do_execute(module, pid) end) end defp do_execute(module, pid) do result = case ModuleState.get_in_memory_module(pid, module) do nil -> ElixirScript.Beam.debug_info(module) beam -> ElixirScript.Beam.debug_info(beam) end case result do {:ok, info} -> walk_module(module, info, pid) {:ok, module, implementations} -> walk_protocol(module, implementations, pid) {:error, "Unknown module"} -> Logger.warn fn() -> "ElixirScript: #{inspect module} is missing or unavailable" end {:error, error} -> raise ElixirScript.CompileError, "An error occurred while compiling #{inspect module}: #{error}" end end defp walk_module(module, %{attributes: [__foreign_info__: %{path: path, name: name, global: global}]} = info, pid) do {name, path} = if global do name = if name, do: name, else: module path = nil {name, path} else name = Enum.join(Module.split(module), "_") path = path <> ".js" {name, path} end ModuleState.put_javascript_module(pid, module, name, path) ModuleState.put_module(pid, module, info) nil end defp walk_module(module, info, pid) do %{ attributes: _attrs, compile_opts: _compile_opts, definitions: defs, file: _file, line: _line, module: ^module, unreachable: unreachable } = info ModuleState.put_module(pid, module, info) reachable_defs = Enum.filter(defs, fn { _, type, _, _} when type in [:defmacro, :defmacrop] -> false { name, _, _, _} -> not(name in unreachable) _ -> true end) state = %{ pid: pid, module: module } Enum.each(reachable_defs, fn(x) -> walk(x, state) end) end defp walk_protocol(module, implementations, pid) do impls = Enum.map(implementations, fn {impl, %{attributes: attrs}} -> protocol_impl = Keyword.fetch!(attrs, :protocol_impl) impl_for = Keyword.fetch!(protocol_impl, :for) {impl, impl_for} end) first_implementation_functions = implementations |> hd |> elem(1) |> Map.get(:definitions) functions = Enum.map(first_implementation_functions, fn { name, _, _, _} -> name end) ModuleState.put_module(pid, module, %{protocol: true, impls: impls, functions: functions}) Enum.each(implementations, fn {impl, info} -> walk_module(impl, info, pid) end) end defp walk({{_name, _arity}, _type, _, clauses}, state) do Enum.each(clauses, &walk(&1, state)) end defp walk({ _, _args, _guards, body}, state) do walk_block(body, state) end defp walk({:->, _, [[{:when, _, params}], body ]}, state) do guards = List.last(params) params = params |> Enum.reverse |> tl |> Enum.reverse walk({[], params, guards, body}, state) end defp walk({:->, _, [params, body]}, state) do walk({[], params, [], body}, state) end defp walk({:|, _, [head, tail]}, state) do walk(head, state) walk(tail, state) end defp walk({:::, _, [target, _type]}, state) do walk(target, state) end defp walk(form, state) when is_list(form) do Enum.each(form, &walk(&1, state)) end defp walk(form, state) when is_atom(form) and form not in [BitString, Function, PID, Port, Reference, Any, Elixir] do if ElixirScript.Translate.Module.is_elixir_module(form) and !ElixirScript.Translate.Module.is_js_module(form, state) do if ModuleState.get_module(state.pid, form) == nil do do_execute(form, state.pid) end end end defp walk({a, b}, state) do walk({:{}, [], [a, b]}, state) end defp walk({:{}, _, elements}, state) do Enum.each(elements, &walk(&1, state)) end defp walk({:%{}, _, properties}, state) do Enum.each(properties, fn (val) -> walk(val, state) end) end defp walk({:<<>>, _, elements}, state) do Enum.each(elements, fn (val) -> walk(val, state) end) end defp walk({:=, _, [left, right]}, state) do walk(left, state) walk(right, state) end defp walk({:%, _, [module, params]}, state) do if ElixirScript.Translate.Module.is_elixir_module(module) and !ElixirScript.Translate.Module.is_js_module(module, state) do if ModuleState.get_module(state.pid, module) == nil do do_execute(module, state.pid) end end walk(params, state) end defp walk({:for, _, generators}, state) when is_list(generators) do walk(Collectable, state) Enum.each(generators, fn {:<<>>, _, body} -> walk(body, state) {:<-, _, [identifier, enum]} -> walk(identifier, state) walk(enum, state) [into: expression] -> walk(expression, state) [into: expression, do: expression2] -> walk(expression, state) walk_block(expression2, state) [do: expression] -> walk_block(expression, state) filter -> walk(filter, state) end) end defp walk({:case, _, [condition, [do: clauses]]}, state) do Enum.each(clauses, &walk(&1, state)) walk(condition, state) end defp walk({:cond, _, [[do: clauses]]}, state) do Enum.each(clauses, fn({:->, _, [clause, clause_body]}) -> Enum.each(List.wrap(clause_body), &walk(&1, state)) walk(hd(clause), state) end) end defp walk({:receive, _context, blocks}, state) when is_list(blocks) do do_block = Keyword.get(blocks, :do) after_block = Keyword.get(blocks, :after, nil) walk_block(do_block, state) if after_block do Enum.each(List.wrap(after_block), &walk(&1, state)) end end defp walk({:try, _, [blocks]}, state) do try_block = Keyword.get(blocks, :do) rescue_block = Keyword.get(blocks, :rescue, nil) catch_block = Keyword.get(blocks, :catch, nil) after_block = Keyword.get(blocks, :after, nil) else_block = Keyword.get(blocks, :else, nil) walk_block(try_block, state) if rescue_block do Enum.each(rescue_block, fn {:->, _, [ [{:in, _, [param, names]}], body]} -> walk({[], [param], [{{:., [], [Enum, :member?]}, [], [param, names]}], body}, state) {:->, _, [ [param], body]} -> walk({[], [param], [], body}, state) end) end if catch_block do walk({:fn, [], catch_block}, state) end if after_block do Enum.each(List.wrap(after_block), &walk(&1, state)) end if else_block do walk({:fn, [], else_block}, state) end end defp walk({:fn, _, clauses}, state) do Enum.each(clauses, &walk(&1, state)) end defp walk({:with, _, args}, state) do Enum.each(args, fn {:<-, _, [left, right]} -> walk(left, state) walk(right, state) {:=, _, [left, right]} -> walk(left, state) walk(right, state) [do: expression] -> walk_block(expression, state) [do: expression, else: elses] -> walk_block(expression, state) Enum.each(elses, fn {:->, _, [left, right]} -> walk(left, state) walk(right, state) end) end) end defp walk({{:., _, [:erlang, :apply]}, _, [module, function, params]}, state) do walk({{:., [], [module, function]}, [], params}, state) end defp walk({{:., _, [:erlang, :apply]}, _, [function, params]}, state) do walk({function, [], params}, state) end defp walk({{:., _, [_module, _function]} = ast, _, params}, state) do walk(ast, state) walk(params, state) end defp walk({:., _, [ElixirScript.JS, _]}, _) do nil end defp walk({:., _, [module, function]}, state) do cond do ElixirScript.Translate.Module.is_elixir_module(module) -> if ModuleState.get_module(state.pid, module) == nil do do_execute(module, state.pid) end true -> walk(module, state) walk(function, state) end end defp walk({:super, _, [{_, _} | params]}, state) do walk(params, state) end defp walk({function, _, params}, state) when is_list(params) do walk(function, state) walk(params, state) end defp walk(_, _) do nil end defp walk_block(block, state) do case block do nil -> nil {:__block__, _, block_body} -> Enum.each(block_body, &walk(&1, state)) b when is_list(b) -> Enum.each(b, &walk(&1, state)) _ -> walk(block, state) end end end elixirscript-0.31.1/lib/elixir_script/passes/output.ex000066400000000000000000000070511316305330500231410ustar00rootroot00000000000000defmodule ElixirScript.Output do @moduledoc false alias ElixirScript.State, as: ModuleState alias ESTree.Tools.{Builder, Generator} @generated_name "elixirscript.build.js" @doc """ Takes outputs the JavaScript code in the specified output """ @spec execute([atom], pid, map) :: nil def execute(modules, pid, opts) do modules = modules |> Enum.filter(fn {_, info} -> Map.has_key?(info, :js_ast) end) |> Enum.map(fn {_module, info} -> info.js_ast end ) js_modules = ModuleState.js_modules(pid) |> Enum.filter(fn {_module, _name, nil} -> false _ -> true end) |> Enum.map(fn {module, name, path} -> import_path = Path.join(opts.root, path) {module, name, path, import_path} end) bundle(modules, opts, js_modules) |> output(Map.get(opts, :output), js_modules) end defp bundle(modules, opts, js_modules) do modules |> ElixirScript.Output.JSModule.compile(opts, js_modules) |> Task.async_stream(fn(js_part) -> js_part |> List.wrap |> Builder.program |> prepare_js_ast |> Generator.generate end) |> Stream.map(fn {:ok, js_code} -> js_code end) |> Enum.to_list |> Enum.join("\n") |> concat end defp concat(code) do bootstrap_code = get_bootstrap_js() "'use strict';\nexport #{bootstrap_code}\n#{code}" end defp get_bootstrap_js() do operating_path = Path.join([Mix.Project.build_path, "lib", "elixir_script", "priv"]) path = Path.join([operating_path, "build", "iife", "ElixirScript.Core.js"]) File.read!(path) end defp prepare_js_ast(js_ast) do case js_ast do modules when is_list(modules) -> modules |> Enum.reduce([], &(&2 ++ &1.body)) |> Builder.program _ -> js_ast end end defp output(code, nil, _) do code end defp output(code, :stdout, _) do IO.puts(code) end defp output(code, path, js_modules) do file_name = get_output_file_name(path) if !File.exists?(Path.dirname(file_name)) do File.mkdir_p!(Path.dirname(file_name)) end apps = get_app_names() output_dir = Path.dirname(file_name) Enum.each(js_modules, fn({_, _, path, _}) -> copy_javascript_module(apps, output_dir, path) end) File.write!(file_name, code) end def get_output_file_name(path) do case Path.extname(path) do ".js" -> path ".mjs" -> path _ -> Path.join([path, @generated_name]) end end defp get_app_names() do Mix.Project.config()[:app] deps = Mix.Project.deps_paths() |> Map.keys [Mix.Project.config()[:app]] ++ deps end defp copy_javascript_module(apps, output_dir, js_module_path) do Enum.each(apps, fn(app) -> base_path = Path.join([:code.priv_dir(app), "elixir_script"]) js_input_path = cond do File.exists?(Path.join([base_path, js_module_path])) -> Path.join([base_path, js_module_path]) File.exists?(Path.join([base_path, slashes_to_dots(js_module_path)])) -> Path.join([base_path, slashes_to_dots(js_module_path)]) true -> nil end if js_input_path != nil do js_output_path = Path.join(output_dir, js_module_path) js_output_dir = Path.dirname(js_output_path) if !File.exists?(js_output_dir) do File.mkdir_p!(js_output_dir) end File.cp(js_input_path, js_output_path) end end) end defp slashes_to_dots(js_module_path) do js_module_path |> String.replace("/", ".") end end elixirscript-0.31.1/lib/elixir_script/passes/output/000077500000000000000000000000001316305330500226005ustar00rootroot00000000000000elixirscript-0.31.1/lib/elixir_script/passes/output/js_module.ex000066400000000000000000000035001316305330500251150ustar00rootroot00000000000000defmodule ElixirScript.Output.JSModule do @moduledoc false alias ESTree.Tools.Builder, as: J alias ElixirScript.Translate.Helpers def compile(body, opts, js_modules) do elixir = Helpers.declare("Elixir", J.object_expression([])) imports = opts.module_formatter.build_imports(js_modules) exports = opts.module_formatter.build_export(J.identifier("Elixir")) [elixir, create_atom_table(), start(), load(), imports] ++ body ++ [exports] end def start do normal = Helpers.symbol("normal") Helpers.assign( J.member_expression( J.identifier("Elixir"), J.identifier("start") ), Helpers.function( [J.identifier(:app), J.identifier(:args)], J.block_statement([ Helpers.call( J.member_expression( Helpers.call( J.member_expression( J.identifier(:app), J.identifier("__load") ), [J.identifier("Elixir")] ), J.identifier("start") ), [normal, J.identifier(:args)] ) ]) ) ) end def load do Helpers.assign( J.member_expression( J.identifier("Elixir"), J.identifier("load") ), Helpers.function( [J.identifier(:module)], J.block_statement([ J.return_statement( Helpers.call( J.member_expression( J.identifier(:module), J.identifier("__load") ), [J.identifier("Elixir")] ) ) ]) ) ) end defp create_atom_table() do Helpers.assign( J.member_expression( J.identifier("Elixir"), J.identifier("__table__") ), J.object_expression([]) ) end end elixirscript-0.31.1/lib/elixir_script/passes/translate.ex000066400000000000000000000007161316305330500235770ustar00rootroot00000000000000defmodule ElixirScript.Translate do @moduledoc false @doc """ Takes a list of modules and translates their ast into JavaScript AST. The modules are the ones collected from the FindUsed pass. """ @spec execute([atom], pid) :: nil def execute(modules, pid) do modules |> List.wrap() |> Task.async_stream(fn {module, info} -> ElixirScript.Translate.Module.compile(module, info, pid) end) |> Stream.run() end end elixirscript-0.31.1/lib/elixir_script/passes/translate/000077500000000000000000000000001316305330500232355ustar00rootroot00000000000000elixirscript-0.31.1/lib/elixir_script/passes/translate/clause.ex000066400000000000000000000055231316305330500250540ustar00rootroot00000000000000defmodule ElixirScript.Translate.Clause do @moduledoc false # Handles translation of all of the clause ASTs alias ESTree.Tools.Builder, as: J alias ElixirScript.Translate.Helpers alias ElixirScript.Translate.Form alias ElixirScript.Translate.Forms.Pattern alias ElixirScript.Translate.Function def compile({ _, args, guards, body}, state) do {patterns, params, state} = Pattern.compile(args, state) guard = compile_guard(params, guards, state) {body, _state} = Function.compile_block(body, state) body = body |> return_last_statement |> Function.update_last_call(state) ast = Helpers.call( J.member_expression( Helpers.patterns(), J.identifier("clause") ), [ J.array_expression(patterns), Helpers.arrow_function( params, J.block_statement(body) ), guard ] ) { ast, state } end def compile({:->, _, [[{:when, _, params}], body ]}, state) do guards = List.last(params) params = params |> Enum.reverse |> tl |> Enum.reverse compile({[], params, guards, body}, state) end def compile({:->, _, [params, body]}, state) do compile({[], params, [], body}, state) end def return_last_statement(body) do body |> List.wrap |> Enum.reverse |> do_return_last_statement |> Enum.reverse end defp do_return_last_statement([%ESTree.ThrowStatement{} = ast]) do [ast] end defp do_return_last_statement([%ESTree.VariableDeclaration{} = head | tail]) do declaration = hd(head.declarations).id return_statement = case declaration do %ESTree.ArrayPattern{elements: elements} -> if length(elements) == 1 do J.return_statement(hd(declaration.elements)) else J.return_statement(J.array_expression(declaration.elements)) end _ -> J.return_statement(declaration) end [return_statement, head] ++ tail end defp do_return_last_statement([head]) do [J.return_statement(head)] end defp do_return_last_statement([%ESTree.ThrowStatement{} = head | tail]) do [head] ++ tail end defp do_return_last_statement([head | tail]) do [J.return_statement(head)] ++ tail end defp do_return_last_statement([]) do [J.return_statement(J.identifier("null"))] end def compile_guard(params, guards, state) do state = Map.put(state, :in_guard, true) guards = guards |> List.wrap |> Enum.reverse |> process_guards |> Form.compile!(state) Helpers.arrow_function( params, J.block_statement([ J.return_statement(guards) ]) ) end defp process_guards([]) do true end defp process_guards([guard]) do guard end defp process_guards([head | tail]) do {{:., [], [:erlang, :orelse]}, [], [process_guards(tail), head]} end end elixirscript-0.31.1/lib/elixir_script/passes/translate/form.ex000066400000000000000000000233501316305330500245410ustar00rootroot00000000000000defmodule ElixirScript.Translate.Form do @moduledoc false # Handles translation of all forms that are not functions or clauses alias ESTree.Tools.Builder, as: J alias ElixirScript.Translate.Helpers alias ElixirScript.Translate.Forms.{Bitstring, Match, Try, For, Receive, Remote, Pattern, With} alias ElixirScript.Translate.Clause require Logger @spec compile!(any, map) :: ESTree.Node.t def compile!(ast, state) do {js_ast, _} = compile(ast, state) js_ast end @spec compile(any, map) :: {ESTree.Node.t, map} def compile(ast, state) def compile(nil, state) do { J.identifier("null"), state } end def compile(map, state) when is_map(map) do quoted = Code.string_to_quoted!("#{inspect map}") compile(quoted, state) end def compile(form, state) when is_boolean(form) or is_integer(form) or is_float(form) or is_binary(form) do { J.literal(form), state } end def compile([{:|, _, [_head, _tail]} = ast], state) do compile(ast, state) end def compile({:|, _, [head, tail]}, state) do ast = Helpers.call( J.member_expression( Helpers.functions(), J.identifier("concat") ), [compile!(head, state), compile!(tail, state)] ) { ast, state } end def compile(form, state) when is_list(form) do ast = J.array_expression( Enum.map(form, &compile!(&1, state)) ) { ast, state } end def compile(form, state) when is_atom(form) do ast = if ElixirScript.Translate.Module.is_elixir_module(form) do Remote.process_module_name(form, state) else Helpers.symbol(form) end { ast, state } end def compile({a, b}, state) do compile({:{}, [], [a, b]}, state) end def compile({:{}, _, elements}, state) do ast = Helpers.new( Helpers.tuple(), Enum.map(elements, &compile!(&1, state)) |> List.flatten ) {ast, state} end def compile({:&, _, [{:/, _, [{{:., _, [_module, _function]} = ast, [], []}, _]}]}, state) do Remote.compile(ast, state) end def compile({:&, _, [{:/, _, [{var, _, _}, _]}]}, state) do ast = ElixirScript.Translate.Identifier.make_function_name(var) {ast, state} end def compile({:%{}, _, _} = map, state) do ElixirScript.Translate.Forms.Map.compile(map, state) end def compile({:<<>>, _, []} = bitstring, state) do Bitstring.compile(bitstring, state) end def compile({:<<>>, _, elements} = bitstring, state) do is_interpolated_string = Enum.all?(elements, fn(x) -> case x do b when is_binary(b) -> true {:::, _, [_target, {:binary, _, _}]} -> true _ -> false end end) if is_interpolated_string do Bitstring.make_interpolated_string(elements, state) else Bitstring.compile(bitstring, state) end end def compile({:=, _, [_, _]} = match, state) do Match.compile(match, state) end def compile({:%, _, [module, params]}, state) do ast = Helpers.call( J.member_expression( Remote.process_module_name(module, state), J.identifier("__struct__") ), [compile!(params, state)] ) { ast, state } end def compile({:for, _, generators} = ast, state) when is_list(generators) do For.compile(ast, state) end def compile({:case, _, [{:=, _, [left, _]} = match, [do: clauses]]}, state) do {match_ast, state} = compile(match, state) {case_ast, state} = compile({:case, [], [left, [do: clauses]]}, state) match_ast = List.wrap(match_ast) { match_ast ++ [case_ast], state } end def compile({:case, _, [condition, [do: clauses]]}, state) do func = Helpers.call( J.member_expression( Helpers.patterns(), J.identifier("defmatch") ), Enum.map(clauses, fn x -> Clause.compile(x, state) |> elem(0) end) |> List.flatten ) ast = Helpers.call( J.member_expression( func, J.identifier("call")), [J.identifier(:this), compile!(condition, state)] ) { ast, state } end def compile({:cond, _, [[do: clauses]]}, state) do processed_clauses = Enum.map(clauses, fn({:->, _, [clause, clause_body]}) -> { translated_body, state } = ElixirScript.Translate.Function.compile_block(clause_body, state) translated_body = translated_body |> Clause.return_last_statement translated_body = Helpers.arrow_function([], J.block_statement(translated_body)) { translated_clause, _ } = compile(hd(clause), state) J.array_expression([translated_clause, translated_body]) end) cond_function = J.member_expression( Helpers.special_forms(), J.identifier("cond") ) ast = Helpers.call( cond_function, processed_clauses ) { ast, state } end def compile({:receive, context, [blocks]}, state) do line = Keyword.get(context, :line, 1) {function, _arity} = Map.get(state, :function) Logger.warn fn() -> "ElixirScript: receive not supported, Module: #{inspect state.module}, Function: #{function}, Line: #{line}" end Receive.compile(blocks, state) end def compile({:try, _, [blocks]}, state) do Try.compile(blocks, state) end def compile({:with, _, args}, state) do With.compile(args, state) end def compile({:fn, _, _} = ast, state) do ElixirScript.Translate.Function.compile(ast, state) end def compile({{:., _, [:erlang, op]}, _, [item]}, state) when op in [:+, :-] do ast = J.unary_expression( op, true, compile!(item, state) ) {ast, state} end def compile({{:., _, [:erlang, op]}, _, [left, right]}, state) when op in [:==, :===] do ast = Helpers.call( J.member_expression( Helpers.core_module("erlang"), J.identifier("equals") ), [compile!(left, state), compile!(right, state)] ) {ast, state} end def compile({{:., _, [:erlang, op]}, _, [left, right]}, state) when op in [:+, :-, :*, :/, :>, :<, :>=] do ast = J.binary_expression( op, compile!(left, state), compile!(right, state) ) {ast, state} end def compile({{:., _, [:erlang, :"=<"]}, _, [left, right]}, state) do ast = J.binary_expression( :<=, compile!(left, state), compile!(right, state) ) {ast, state} end def compile({{:., _, [:erlang, :"=:="]}, _, [left, right]}, state) do ast = J.binary_expression( :===, compile!(left, state), compile!(right, state) ) {ast, state} end def compile({{:., _, [:erlang, :"=/="]}, _, [left, right]}, state) do ast = J.binary_expression( :!==, compile!(left, state), compile!(right, state) ) {ast, state} end def compile({{:., _, [:erlang, :"/="]}, _, [left, right]}, state) do ast = J.binary_expression( :!=, compile!(left, state), compile!(right, state) ) {ast, state} end def compile({{:., _, [:erlang, op]}, _, [left, right]}, state) when op in [:andalso, :and] do ast = J.binary_expression( :&&, compile!(left, state), compile!(right, state) ) {ast, state} end def compile({{:., _, [:erlang, op]}, _, [left, right]}, state) when op in [:orelse, :or] do ast = J.binary_expression( :||, compile!(left, state), compile!(right, state) ) {ast, state} end def compile({{:., _, [var, func_or_prop]}, _, []}, state) when not is_atom(var) do ast = Helpers.call( ElixirScript.Translate.Forms.JS.call_property(), [compile!(var, state), J.literal(to_string(func_or_prop))] ) {ast, state} end def compile({{:., _, [ElixirScript.JS, _]}, _, _} = ast, state) do ElixirScript.Translate.Forms.JS.compile(ast, state) end def compile({:., _, call} = ast, state) when is_list(call) do Remote.compile(ast, state) end def compile({:super, _, [_ | params]}, state) when is_list(params) do {function_name, _} = Map.get(state, :function) {var_decs, params} = compile_params(params, state) ast = Helpers.call( ElixirScript.Translate.Identifier.make_function_name(function_name), params ) case var_decs do [] -> {ast, state} _ -> {var_decs ++ List.wrap(ast), state} end end def compile({:__block__, _, _} = ast, state) do ElixirScript.Translate.Function.compile_block(ast, state) end def compile({var, _, params}, state) when is_list(params) and is_atom(var) do {var_decs, params} = compile_params(params, state) ast = Helpers.call( ElixirScript.Translate.Identifier.make_function_name(var), params ) case var_decs do [] -> {ast, state} _ -> {var_decs ++ List.wrap(ast), state} end end def compile({function, _, []}, state) do ast = Helpers.call( ElixirScript.Translate.Forms.JS.call_property(), [compile!(function, state)] ) {ast, state} end def compile({function, _, params}, state) when is_list(params) do {var_decs, params} = compile_params(params, state) ast = Helpers.call( compile!(function, state), params ) case var_decs do [] -> {ast, state} _ -> {var_decs ++ List.wrap(ast), state} end end def compile({var, meta, _}, state) do counter = Pattern.get_counter(meta) var = ElixirScript.Translate.Identifier.filter_name(var) var = Pattern.get_variable_name(var <> counter, state) { ElixirScript.Translate.Identifier.make_identifier(var), state } end defp compile_params(params, state) do {params, var_decs} = Enum.map_reduce(params, [], fn ({:=, _, [left, _]} = ast, acc) -> {ast, state} = compile(ast, state) left = compile!(left, state) {left, acc ++ List.wrap(ast)} (x, acc) -> {compile!(x, state), acc} end) {var_decs, params} end end elixirscript-0.31.1/lib/elixir_script/passes/translate/forms/000077500000000000000000000000001316305330500243635ustar00rootroot00000000000000elixirscript-0.31.1/lib/elixir_script/passes/translate/forms/bitstring.ex000066400000000000000000000103041316305330500267240ustar00rootroot00000000000000defmodule ElixirScript.Translate.Forms.Bitstring do @moduledoc false alias ESTree.Tools.Builder, as: JS alias ElixirScript.Translate.Helpers alias ElixirScript.Translate.Form def compile({:<<>>, _, elements}, state) do js_ast = Helpers.new( Helpers.bitstring(), Enum.map(elements, &compile_element(&1, state)) ) { js_ast, state } end def compile_element(element, state) when is_number(element) do do_compile_element({:integer, Form.compile!(element, state)}) end def compile_element(element, state) when is_binary(element) do do_compile_element({:binary, Form.compile!(element, state)}) end def compile_element({:<<>>, _, _} = ast, state) do {ast, _} = compile(ast, state) ast end def compile_element({:::, _, [element, {type, _, _}]}, state) when type in [:integer, :float, :bitstring, :bits, :binary, :bytes, :utf8, :utf16, :utf32, :signed, :unsigned] do do_compile_element({type, translate_element(element, state)}) end def compile_element({:::, _, [element, {type, _, params}]}, state) when type in [:size, :unit] do do_compile_element({type, translate_element(element, state), Enum.map(params, &translate_element(&1, state))}) end def compile_element({:::, _, [element, {:*, _, [size, unit]}]}, state) do size_ast = do_compile_element({:size, translate_element(element, state), [translate_element(size, state)]}) do_compile_element({:unit, size_ast, [translate_element(unit, state)]}) end def compile_element({:::, _, [element, {:-, _, types}]}, state) do handle_type_adjectives({:-, [], types}, translate_element(element, state), state) end def compile_element({:::, _, [element, size]}, state) do do_compile_element({:size, translate_element(element, state), [translate_element(size, state)]}) end def compile_element(element, state) do do_compile_element({:binary, translate_element(element, state)}) end def translate_element(ElixirScript.Translate.Forms.Pattern.Patterns, _) do JS.object_expression([JS.property( JS.literal("value"), ElixirScript.Translate.Forms.Pattern.Patterns.parameter() ) ]) end def translate_element(element, state) do Form.compile!(element, state) end defp handle_type_adjectives({:-, _, types}, ast, state) do Enum.reduce(types, ast, fn(type, current_ast) -> case type do {:-, _, sub_types} -> handle_type_adjectives({:-, [], sub_types}, current_ast, state) {:*, _, [size, unit]} -> size_ast = do_compile_element({:size, current_ast, [Form.compile!(size, state)]}) do_compile_element({:unit, size_ast, [Form.compile!(unit, state)]}) {the_type, _, params} when is_list(params) -> do_compile_element({the_type, current_ast, Enum.map(params, &Form.compile!(&1, state))}) {the_type, _, _} -> do_compile_element({the_type, current_ast}) end end) end defp do_compile_element({type, ast}) do Helpers.call( JS.member_expression( Helpers.bitstring(), JS.identifier(type) ), [ ast ] ) end defp do_compile_element({type, ast, params}) when is_list(params) do Helpers.call( JS.member_expression( Helpers.bitstring(), JS.identifier(type) ), [ ast ] ++ params ) end def make_interpolated_string(elements, state) do translated_elements = Enum.map(elements, fn(x) -> case x do elem when is_binary(elem) -> Form.compile!(elem, state) {:::, _, data} -> Form.compile!(hd(data), state) end end) result = case translated_elements do [] -> JS.literal('') [_] -> do_make_interpolated_string([], hd(translated_elements)) elements -> do_make_interpolated_string(tl(elements), hd(elements)) end {result, state} end defp do_make_interpolated_string([], ast) do ast end defp do_make_interpolated_string(elements, ast) do JS.binary_expression( :+, ast, do_make_interpolated_string(tl(elements), hd(elements)) ) end end elixirscript-0.31.1/lib/elixir_script/passes/translate/forms/for.ex000066400000000000000000000072611316305330500255150ustar00rootroot00000000000000defmodule ElixirScript.Translate.Forms.For do @moduledoc false alias ESTree.Tools.Builder, as: JS alias ElixirScript.Translate.{Form, Clause, Helpers, Identifier} alias ElixirScript.Translate.Forms.Pattern def compile({:for, _, generators}, state) do args = handle_args(generators, state) generators = JS.array_expression(args.generators) into = args.into || JS.array_expression([]) filter = args.filter || Helpers.arrow_function([], JS.block_statement([JS.return_statement(JS.identifier("true"))])) fun = args.fun expression = Helpers.call( JS.member_expression( Helpers.patterns(), JS.identifier("clause") ), [JS.array_expression(args.patterns), fun, filter] ) members = ["Elixir", "Collectable" , "__load"] collectable = Helpers.call( Identifier.make_namespace_members(members), [JS.identifier("Elixir")] ) ast = Helpers.call( JS.member_expression( Helpers.special_forms(), JS.identifier("_for") ), [expression, generators, collectable, into] ) {ast, state} end defp handle_args(nil, _) do %{generators: [], args: [], filter: nil, fun: nil, into: nil, patterns: []} end defp handle_args(generators, module_state) do Enum.reduce(generators, %{generators: [], args: [], filter: nil, fun: nil, into: nil, patterns: []}, fn ({:<<>>, _, body}, state) -> {bs_parts, collection} = Enum.map_reduce(body, nil, fn {:::, _, _} = ast, state -> {ast, state} {:<-, _, [var, collection]}, _ -> {var, collection} end) {patterns, params, module_state} = Pattern.compile([{:<<>>, [], bs_parts}], module_state) gen = Helpers.call( JS.member_expression( Helpers.patterns(), JS.identifier("bitstring_generator") ), [hd(patterns), Form.compile!(collection, module_state)] ) %{state | generators: state.generators ++ [gen], args: state.args ++ params, patterns: state.patterns ++ patterns} ({:<-, _, [identifier, enum]}, state) -> {patterns, params, module_state} = Pattern.compile([identifier], module_state) gen = Helpers.call( JS.member_expression( Helpers.patterns(), JS.identifier("list_generator") ), [hd(patterns), Form.compile!(enum, module_state)] ) %{state | generators: state.generators ++ [gen], args: state.args ++ params, patterns: state.patterns ++ patterns} ([into: expression], state) -> %{state | into: Form.compile!(expression, module_state)} ([into: expression, do: expression2], state) -> fun = create_function_expression(expression2, state, module_state) %{state | into: Form.compile!(expression, module_state), fun: fun} ([do: expression], state) -> fun = create_function_expression(expression, state, module_state) %{state | fun: fun} (filter, state) -> fun = create_function_expression(filter, state, module_state) %{state | filter: fun} end) end defp create_function_expression(ast, state, module_state) do { ast, _ } = Enum.map_reduce(List.wrap(ast), module_state, fn x, acc_state -> Form.compile(x, acc_state) end) ast = ast |> List.flatten |> Clause.return_last_statement Helpers.arrow_function( state.args, JS.block_statement(ast) ) end end elixirscript-0.31.1/lib/elixir_script/passes/translate/forms/js.ex000066400000000000000000000064051316305330500253420ustar00rootroot00000000000000defmodule ElixirScript.Translate.Forms.JS do @moduledoc false alias ESTree.Tools.Builder, as: J alias ElixirScript.Translate.Helpers alias ElixirScript.Translate.Form def call_property() do J.member_expression( Helpers.functions(), J.identifier("call_property") ) end def compile({{:., _, [ElixirScript.JS, :debugger]}, _, _}, state) do ast = J.debugger_statement() {ast, state} end def compile({{:., _, [ElixirScript.JS, :this]}, _, _}, state) do ast = J.this_expression() {ast, state} end def compile({{:., _, [ElixirScript.JS, :new]}, _, [module, params]}, state) do members = Module.split(module) members = case members do ["JS" | rest] -> rest x -> x end params = case params do p when is_list(p) -> Enum.map(params, &Form.compile!(&1, state)) _ -> [J.rest_element(Form.compile!(params, state))] end ast = Helpers.new( ElixirScript.Translate.Identifier.make_namespace_members(members), params ) {ast, state} end def compile({{:., _, [ElixirScript.JS, :throw]}, _, [term]}, state) do ast = J.throw_statement( Form.compile!(term, state) ) {ast, state} end def compile({{:., _, [ElixirScript.JS, :import]}, _, [term]}, state) do ast = Helpers.call( J.identifier("import"), [Form.compile!(term, state)] ) {ast, state} end def compile({{:., _, [ElixirScript.JS, :mutate]}, _, [object, map]}, state) do ast = Helpers.call( J.member_expression( J.identifier("Object"), J.identifier("assign") ), [ Form.compile!(object, state), Form.compile!(map, state) ] ) {ast, state} end def compile({{:., _, [ElixirScript.JS, :mutate]}, _, [object, key, value]}, state) do ast = Helpers.assign( J.member_expression( Form.compile!(object, state), Form.compile!(key, state), true ), Form.compile!(value, state) ) {ast, state} end def compile({{:., _, [ElixirScript.JS, :map_to_object]}, _, [map]}, state) do ast = Helpers.call( J.member_expression( Helpers.functions(), J.identifier("map_to_object") ), [ Form.compile!(map, state) ] ) {ast, state} end def compile({{:., _, [ElixirScript.JS, :map_to_object]}, _, [map, options]}, state) do ast = Helpers.call( J.member_expression( Helpers.functions(), J.identifier("map_to_object") ), [ Form.compile!(map, state), Form.compile!(options, state) ] ) {ast, state} end def compile({{:., _, [ElixirScript.JS, :object_to_map]}, _, [object]}, state) do ast = Helpers.call( J.member_expression( Helpers.functions(), J.identifier("object_to_map") ), [ Form.compile!(object, state) ] ) {ast, state} end def compile({{:., _, [ElixirScript.JS, :object_to_map]}, _, [object, options]}, state) do ast = Helpers.call( J.member_expression( Helpers.functions(), J.identifier("object_to_map") ), [ Form.compile!(object, state), Form.compile!(options, state) ] ) {ast, state} end end elixirscript-0.31.1/lib/elixir_script/passes/translate/forms/map.ex000066400000000000000000000030651316305330500255020ustar00rootroot00000000000000defmodule ElixirScript.Translate.Forms.Map do @moduledoc false alias ESTree.Tools.Builder, as: J alias ElixirScript.Translate.{Form, Helpers} def compile({:%{}, _, [{:|, _, [map, new_values]}]}, state) do { map, state } = Form.compile(map, state) data = Enum.map(new_values, fn {x, y} -> J.array_expression([ Form.compile!(x, state), Form.compile!(y, state) ]) end) ast = Helpers.new( J.identifier("Map"), [ J.array_expression( [J.spread_element(map)] ++ data ) ] ) { ast, state } end def compile({:%{}, _, properties}, state) do ast = Helpers.new( J.identifier("Map"), [ J.array_expression( Enum.map(properties, fn {x, y} -> J.array_expression( [ Form.compile!(x, state), Form.compile!(y, state) ] ) end) ) ] ) {ast, state} end def make_property(%ESTree.Identifier{} = key, value) do J.property(key, value) end def make_property(%ESTree.Literal{value: k}, value) when is_binary(k) do key = case String.contains?(k, "-") do true -> J.literal(k) false -> ElixirScript.Translate.Identifier.make_identifier(k) end J.property(key, value) end def make_property(key, value) do J.property(key, value, :init, false, false, true) end def make_shorthand_property(%ESTree.Identifier{} = key) do J.property(key, key, :init, true) end end elixirscript-0.31.1/lib/elixir_script/passes/translate/forms/match.ex000066400000000000000000000070061316305330500260200ustar00rootroot00000000000000defmodule ElixirScript.Translate.Forms.Match do @moduledoc false alias ESTree.Tools.Builder, as: J alias ElixirScript.Translate.Helpers alias ElixirScript.Translate.Form alias ElixirScript.Translate.Forms.Pattern def compile({:=, _, [left, right]}, state) do build_matches(left, right, %{patterns: []}) |> compile_match(state) end defp make_list_ref(array_pattern, params) do {ref, params} = make_params(params) ref_declaration = Helpers.declare(ref, J.array_expression(params)) [array_pattern, ref_declaration] end defp make_tuple_ref(array_pattern, params) do {ref, params} = make_params(params) ref_declaration = Helpers.declare(ref, Helpers.new( Helpers.tuple(), params )) [array_pattern, ref_declaration] end defp make_params(params) do ref = J.identifier("_ref#{:rand.uniform(10000000)}") params = Enum.map(params, fn (nil) -> J.identifier(:undefined) (x) -> x end) { ref, params } end defp build_matches(pattern, {:=, _, [left, right]}, parts) do parts = parts |> Map.update!(:patterns, fn(x) -> x ++ [pattern] end) build_matches(left, right, parts) end defp build_matches(left, right, parts) do parts |> Map.update!(:patterns, fn(x) -> x ++ [left] end) |> Map.put(:expression, right) end defp compile_match(%{patterns: [left], expression: right}, state) do { right_ast, state } = Form.compile(right, state) {var_dec, right_ast} = case right_ast do [variable_declaration, x] -> {variable_declaration, x} x -> {nil, x} end { patterns, params, state } = Pattern.compile([left], state) array_pattern = Helpers.declare(params, Helpers.call( J.member_expression( Helpers.patterns(), J.identifier("match") ), [hd(patterns), right_ast] )) js_ast = case left do list when is_list(list) -> make_list_ref(array_pattern, params) { _, _ } -> make_tuple_ref(array_pattern, params) {:{}, _, _ } -> make_tuple_ref(array_pattern, params) _ -> List.wrap(array_pattern) end js_ast = case var_dec do nil -> js_ast x -> [x] ++ js_ast end { js_ast, state } end defp compile_match(%{patterns: lefts, expression: right}, state) do { right_ast, state } = Form.compile(right, state) {var_dec, right_ast} = case right_ast do [variable_declaration, x] -> {variable_declaration, x} x -> {nil, x} end intermediate_assign = Helpers.assign( J.identifier("__intermediate__"), right_ast ) {js_ast, state} = Enum.map_reduce(lefts, state, fn(left, state) -> { patterns, params, state } = Pattern.compile([left], state) array_pattern = Helpers.declare(params, Helpers.call( J.member_expression( Helpers.patterns(), J.identifier("match") ), [hd(patterns), J.identifier("__intermediate__")] )) js_ast = case left do list when is_list(list) -> make_list_ref(array_pattern, params) { _, _ } -> make_tuple_ref(array_pattern, params) {:{}, _, _ } -> make_tuple_ref(array_pattern, params) _ -> List.wrap(array_pattern) end js_ast = case var_dec do nil -> js_ast x -> [x] ++ js_ast end { js_ast, state } end) js_ast = [intermediate_assign] ++ List.flatten(js_ast) {js_ast, state} end end elixirscript-0.31.1/lib/elixir_script/passes/translate/forms/pattern.ex000066400000000000000000000166601316305330500264070ustar00rootroot00000000000000defmodule ElixirScript.Translate.Forms.Pattern do alias ElixirScript.Translate.Forms.Pattern.Patterns, as: PM alias ESTree.Tools.Builder, as: J alias ElixirScript.Translate.Helpers alias ElixirScript.Translate.Form alias ElixirScript.Translate.Forms.Bitstring @moduledoc false @doc """ Handles all pattern matching translations """ @spec compile(list(), map()) :: { list(), list(), map() } def compile(patterns, state) do patterns |> do_compile(state) |> update_env(state) end defp do_compile(patterns, state) do Enum.reduce(patterns, {[], []}, fn x, { patterns, params } -> {pattern, param} = process_pattern(x, state) { patterns ++ List.wrap(pattern), params ++ List.wrap(param) } end) end defp update_env({ patterns, params }, state) do { params, state } = Enum.map_reduce(params, state, fn (%ESTree.Identifier{name: :undefined} = param, state) -> { param, state } (%ESTree.Identifier{} = param, state) -> state = update_variable(param.name, state) new_name = get_variable_name(param.name, state) { %{ param | name: new_name }, state } (param, state) -> { param, state } end) { patterns, params, state } end @spec get_variable_name(atom(), map()) :: atom() def get_variable_name(function, state) do number = Map.get(state.vars, function) String.to_atom("#{function}#{number}") end defp update_variable(name, state) do vars = Map.update(state.vars, name, 0, fn val -> val + 1 end) Map.put(state, :vars, vars) end defp process_pattern(term, state) when is_number(term) or is_binary(term) or is_boolean(term) or is_atom(term) or is_nil(term) do { [Form.compile!(term, state)], [] } end defp process_pattern({:^, _, [value]}, state) do { [PM.bound(Form.compile!(value, state))], [] } end defp process_pattern({:_, _, _}, _) do { [PM.parameter(J.literal("_"))], [] } end defp process_pattern({a, b}, state) do process_pattern({:{}, [], [a, b] }, state) end defp process_pattern({:{}, _, elements }, state) do { patterns, params } = elements |> Enum.map(&do_compile([&1], state)) |> reduce_patterns(state) pattern = J.object_expression([ J.property( J.identifier("values"), J.array_expression(patterns) ) ]) tuple = Helpers.tuple() { [PM.type(tuple, pattern)], params } end defp process_pattern([{:|, _, [head, tail]}], state) do { head_patterns, head_params } = process_pattern(head, state) { tail_patterns, tail_params } = process_pattern(tail, state) params = head_params ++ tail_params { [PM.head_tail(hd(head_patterns), hd(tail_patterns))], params } end defp process_pattern(list, state) when is_list(list) do { patterns, params } = list |> Enum.map(&do_compile([&1], state)) |> reduce_patterns(state) {[J.array_expression(patterns)], params} end defp process_pattern({:|, _, [head, tail]}, state) do { head_patterns, head_params } = process_pattern(head, state) { tail_patterns, tail_params } = process_pattern(tail, state) params = head_params ++ tail_params { [PM.head_tail(hd(head_patterns), hd(tail_patterns))], params } end defp process_pattern({{:., _, [:erlang, :++]}, context, [head, tail]}, state) do process_pattern({:|, context, [head, tail]}, state) end defp process_pattern({:%, _, [module, {:%{}, _, props}]}, state) do process_pattern({:%{}, [], [__module__struct__: module] ++ props}, state) end defp process_pattern({:%{}, _, props}, state) do properties = Enum.map(props, fn {:__module__struct__, {_, _, nil} = var } -> {pattern, params} = process_pattern(var, state) a = J.object_expression([%ESTree.Property{ key: J.identifier("__MODULE__"), value: hd(List.wrap(pattern)) }]) property = J.array_expression([ Form.compile!(:__struct__, state), a ]) { property, params } {:__module__struct__, module} -> a = J.object_expression([%ESTree.Property{ key: J.identifier("__MODULE__"), value: Helpers.symbol(to_string(module)) }]) property = J.array_expression([ Form.compile!(:__struct__, state), a ]) { property, [] } {key, value} -> {pattern, params} = process_pattern(value, state) property = case key do {:^, _, [the_key]} -> J.array_expression([ Form.compile!(the_key, state), hd(List.wrap(pattern)) ]) _ -> J.array_expression([ Form.compile!(key, state), hd(List.wrap(pattern)) ]) end { property, params } end) {props, params} = Enum.reduce(properties, {[], []}, fn({prop, param}, {props, params}) -> { props ++ [prop], params ++ param } end) ast = Helpers.new( J.identifier("Map"), [ J.array_expression(List.wrap(props)) ] ) { [ast], params } end defp process_pattern({:<<>>, _, elements}, state) do params = Enum.reduce(elements, [], fn ({:::, _, [{ _, _, params } = ast, _]}, state) when is_nil(params) when is_list(params) and length(params) == 0 -> var_str = make_identifier(ast) var_atom = String.to_atom(var_str) state ++ [ElixirScript.Translate.Identifier.make_identifier(var_atom)] _, state -> state end) elements = Enum.map(elements, fn ({:::, context, [{ _, _, params }, options]}) when is_atom(params) -> Bitstring.compile_element({:::, context, [ElixirScript.Translate.Forms.Pattern.Patterns, options]}, state) x -> Bitstring.compile_element(x, state) end) { [PM.bitstring_match(elements)], params } end defp process_pattern({:<>, _, [prefix, value]}, state) do { [PM.starts_with(prefix)], [Form.compile!(value, state)] } end defp process_pattern({:=, _, [{name, _, _} = target, right]}, state) when not name in [:%, :{}, :^, :%{}, :<<>>] do unify(target, right, state) end defp process_pattern({:=, _, [left, {name, _, _} = target]}, state) when not name in [:%, :{}, :^, :%{}, :<<>>] do unify(target, left, state) end defp process_pattern({_, _, a} = ast, _) when is_atom(a) do var_str = make_identifier(ast) var_atom = String.to_atom(var_str) { [PM.parameter(J.literal(var_str))], [ElixirScript.Translate.Identifier.make_identifier(var_atom)] } end defp process_pattern(ast, state) do { [Form.compile!(ast, state)], [] } end defp reduce_patterns(patterns, _) do patterns |> Enum.reduce({ [], [] }, fn({ pattern, new_param }, { patterns, new_params }) -> { patterns ++ List.wrap(pattern), new_params ++ List.wrap(new_param) } end) end defp unify(target, source, state) do { patterns, params } = do_compile([source], state) { [_] , [param] } = process_pattern(target, state) { [PM.capture(hd(patterns))], params ++ [param] } end def get_counter(meta) do case Keyword.get(meta, :counter, nil) do nil -> "" counter -> counter |> Kernel.abs() |> to_string() end end defp make_identifier({var, meta, _}) do counter = get_counter(meta) to_string(var) <> counter end end elixirscript-0.31.1/lib/elixir_script/passes/translate/forms/pattern/000077500000000000000000000000001316305330500260405ustar00rootroot00000000000000elixirscript-0.31.1/lib/elixir_script/passes/translate/forms/pattern/patterns.ex000066400000000000000000000030411316305330500302340ustar00rootroot00000000000000defmodule ElixirScript.Translate.Forms.Pattern.Patterns do @moduledoc false alias ESTree.Tools.Builder, as: J alias ElixirScript.Translate.Helpers @parameter J.member_expression( Helpers.patterns(), J.identifier(:variable) ) @head_tail J.member_expression( Helpers.patterns(), J.identifier(:headTail) ) @starts_with J.member_expression( Helpers.patterns(), J.identifier(:startsWith) ) @capture J.member_expression( Helpers.patterns(), J.identifier(:capture) ) @bound J.member_expression( Helpers.patterns(), J.identifier(:bound) ) @_type J.member_expression( Helpers.patterns(), J.identifier(:type) ) @bitstring_match J.member_expression( Helpers.patterns(), J.identifier(:bitStringMatch) ) def parameter() do Helpers.call( @parameter, [] ) end def parameter(name) do Helpers.call( @parameter, [name] ) end def head_tail(headParameter, tailParameter) do Helpers.call( @head_tail, [headParameter, tailParameter] ) end def starts_with(prefix) do Helpers.call( @starts_with, [J.literal(prefix)] ) end def capture(value) do Helpers.call( @capture, [value] ) end def bound(value) do Helpers.call( @bound, [value] ) end def type(prototype, value) do Helpers.call( @_type, [prototype, value] ) end def bitstring_match(values) do Helpers.call( @bitstring_match, values ) end end elixirscript-0.31.1/lib/elixir_script/passes/translate/forms/receive.ex000066400000000000000000000021721316305330500263450ustar00rootroot00000000000000defmodule ElixirScript.Translate.Forms.Receive do @moduledoc false alias ESTree.Tools.Builder, as: J alias ElixirScript.Translate.{Helpers, Form, Function, Clause} @doc """ receive is not supported just yet, but we compile it to a stub function for now """ def compile(blocks, state) do receive_block = blocks |> Keyword.get(:do) |> Enum.map(fn x -> Clause.compile(x, state) |> elem(0) end) |> List.flatten |> J.array_expression() receive_function = J.member_expression( Helpers.special_forms(), J.identifier("receive") ) after_block = Keyword.get(blocks, :after, nil) args = [receive_block] ++ process_after(after_block, state) ast = Helpers.call( receive_function, args ) { ast, state } end defp process_after(nil, _) do [] end defp process_after([{:->, _, [[timeout], body]}], state) do timeout = Form.compile!(timeout, state) {body, _state} = Function.compile_block(body, state) function = Helpers.arrow_function( [], J.block_statement(List.wrap(body)) ) [timeout, function] end end elixirscript-0.31.1/lib/elixir_script/passes/translate/forms/remote.ex000066400000000000000000000064151316305330500262220ustar00rootroot00000000000000defmodule ElixirScript.Translate.Forms.Remote do @moduledoc false alias ESTree.Tools.Builder, as: J alias ElixirScript.Translate.{Form, Identifier, Helpers} alias ElixirScript.State, as: ModuleState @erlang_modules [ :erlang, :maps, :lists, :gen, :elixir_errors, :elixir_config, :supervisor, :application, :code, :elixir_utils, :file, :io, :binary, :unicode, :math, :calendar, :filename, :epp, :re, :ets, :sys, :global, :os, :rand, :orddict, :filelib, :net_adm, :net_kernel, ] @doc """ Compiles functions into JavaScript AST. These are not actual function calls, but the function identifiers themselves. Also includes function heads for converting some erlang functions into JavaScript functions. """ def compile({:., _, [:erlang, :++]}, state) do ast = erlang_compat_function("erlang", "list_concatenation") { ast, state } end def compile({:., _, [:erlang, :--]}, state) do ast = erlang_compat_function("erlang", "list_substraction") { ast, state } end def compile({:., _, [module, function]}, state) when module in @erlang_modules do ast = J.member_expression( Helpers.core_module(module), J.identifier(function) ) { ast, state } end def compile({:., _, [function_name]}, state) do Form.compile(function_name, state) end def compile({:., _, [module, function]}, state) do function_name = ElixirScript.Translate.Identifier.make_function_name(function) ast = J.member_expression( process_module_name(module, state), function_name ) {ast, state} end def process_module_name(module, state) when is_atom(module) do cond do ElixirScript.Translate.Module.is_js_module(module, state) -> process_js_module_name(module, state) module === Elixir -> members = ["Elixir", "__load"] Helpers.call( Identifier.make_namespace_members(members), [J.identifier("Elixir")] ) module === :ElixirScript -> members = ["Elixir", "ElixirScript", "__load"] Helpers.call( Identifier.make_namespace_members(members), [J.identifier("Elixir")] ) ElixirScript.Translate.Module.is_elixir_module(module) -> members = ["Elixir"] ++ Module.split(module) ++ ["__load"] Helpers.call( Identifier.make_namespace_members(members), [J.identifier("Elixir")] ) true -> ElixirScript.Translate.Identifier.make_identifier(module) end end def process_module_name(module, state) do Form.compile!(module, state) end defp process_js_module_name(module, state) do case ModuleState.get_js_module_name(state.pid, module) do name when is_binary(name) -> J.identifier(name) name when is_atom(name) -> case to_string(name) do "Elixir." <> _ -> members = Module.split(module) Identifier.make_namespace_members(members) x -> J.identifier(x) end end end defp erlang_compat_function(module, function) do J.member_expression( Helpers.core_module(module), ElixirScript.Translate.Identifier.make_function_name(function) ) end end elixirscript-0.31.1/lib/elixir_script/passes/translate/forms/try.ex000066400000000000000000000045141316305330500255430ustar00rootroot00000000000000defmodule ElixirScript.Translate.Forms.Try do @moduledoc false alias ESTree.Tools.Builder, as: JS alias ElixirScript.Translate.{Form, Function, Clause, Helpers} def compile(blocks, state) do try_block = Keyword.get(blocks, :do) rescue_block = Keyword.get(blocks, :rescue, nil) catch_block = Keyword.get(blocks, :catch, nil) after_block = Keyword.get(blocks, :after, nil) else_block = Keyword.get(blocks, :else, nil) translated_body = prepare_function_body(try_block, state) translated_body = JS.block_statement(translated_body) try_block = Helpers.arrow_function([], translated_body) rescue_block = if rescue_block do process_rescue_block(rescue_block, state) else JS.identifier(:null) end catch_block = if catch_block do Form.compile!({:fn, [], catch_block}, state) else JS.identifier(:null) end after_block = if after_block do process_after_block(after_block, state) else JS.identifier(:null) end else_block = if else_block do Form.compile!({:fn, [], else_block}, state) else JS.identifier(:null) end js_ast = Helpers.call( JS.member_expression( Helpers.special_forms(), JS.identifier("_try") ), [ try_block, rescue_block, catch_block, else_block, after_block ] ) { js_ast, state } end defp process_rescue_block(rescue_block, state) do processed_clauses = Enum.map(rescue_block, fn {:->, _, [ [{:in, _, [param, names]}], body]} -> {ast, _} = Clause.compile({[], [param], [{{:., [], [Enum, :member?]}, [], [param, names]}], body}, state) ast {:->, _, [ [param], body]} -> {ast, _} = Clause.compile({[], [param], [], body}, state) ast end) Helpers.call( JS.member_expression( Helpers.patterns(), JS.identifier("defmatch") ), processed_clauses ) end defp process_after_block(after_block, state) do translated_body = prepare_function_body(after_block, state) translated_body = JS.block_statement(translated_body) Helpers.arrow_function([], translated_body) end defp prepare_function_body(body, state) do {ast, _} = Function.compile_block(body, state) Clause.return_last_statement(ast) end end elixirscript-0.31.1/lib/elixir_script/passes/translate/forms/with.ex000066400000000000000000000035351316305330500257020ustar00rootroot00000000000000defmodule ElixirScript.Translate.Forms.With do @moduledoc false alias ESTree.Tools.Builder, as: JS alias ElixirScript.Translate.{Function, Clause, Helpers} alias ElixirScript.Translate.Forms.Pattern def compile(args, module_state) do result = Enum.reduce(args, %{ expressions: [], arguments: [], module_state: module_state }, fn {symbol, _, [pattern, body] }, state when symbol in [:<-, :=] -> {ast, module_state} = Function.compile_block(body, state.module_state) body = Clause.return_last_statement(ast) expr_function = Helpers.arrow_function(state.arguments, JS.block_statement(body)) { patterns, params, module_state } = Pattern.compile([pattern], module_state) %{state | arguments: state.arguments ++ params, expressions: state.expressions ++ [ JS.array_expression([hd(patterns), expr_function]) ], module_state: module_state } [do: expr], state -> expr_function = process_block(expr, state.arguments, state.module_state) %{state | expressions: state.expressions ++ [ expr_function ] } [do: do_expr, else: else_expr], state -> do_function = process_block(do_expr, state.arguments, state.module_state) { else_function, _ } = Function.compile({:fn, [], else_expr}, state.module_state) %{state | expressions: state.expressions ++ [ do_function, else_function ] } end) expressions = result.expressions js_ast = Helpers.call( JS.member_expression( Helpers.special_forms(), JS.identifier("_with") ), expressions ) { js_ast, module_state } end defp process_block(body, arguments, module_state) do {ast, _} = Function.compile_block(body, module_state) body = Clause.return_last_statement(ast) Helpers.arrow_function(arguments, JS.block_statement(body)) end end elixirscript-0.31.1/lib/elixir_script/passes/translate/function.ex000066400000000000000000000137671316305330500254360ustar00rootroot00000000000000defmodule ElixirScript.Translate.Function do @moduledoc false # Translates the given Elixir function AST into the # equivalent JavaScript AST. alias ESTree.Tools.Builder, as: J alias ElixirScript.Translate.{Clause, Form, Helpers} alias ElixirScript.Translate.Forms.Pattern @spec compile(any, map) :: {ESTree.Node.t, map} def compile({:fn, _, clauses}, state) do anonymous? = Map.get(state, :anonymous_fn, false) state = Map.put(state, :anonymous_fn, true) |> Map.put(:in_guard, false) clauses = compile_clauses(clauses, state) arg_matches_declaration = Helpers.declare_let("__arg_matches__", J.identifier("null")) function_recur_dec = Helpers.function( "recur", [J.rest_element(J.identifier("__function_args__"))], J.block_statement([ arg_matches_declaration, clauses, J.throw_statement( Helpers.new( J.member_expression( Helpers.patterns(), J.identifier("MatchError") ), [J.identifier("__function_args__")] ) ) ]) ) function_dec = Helpers.arrow_function( [J.rest_element(J.identifier("__function_args__"))], J.block_statement([ function_recur_dec, J.return_statement( trampoline() ) ]) ) state = Map.put(state, :anonymous_fn, anonymous?) { function_dec, state } end def compile({{name, arity}, _type, _, clauses}, state) do state = Map.put(state, :function, {name, arity}) |> Map.put(:anonymous_fn, false) |> Map.put(:in_guard, false) clauses = compile_clauses(clauses, state) arg_matches_declaration = Helpers.declare_let("__arg_matches__", J.identifier("null")) intermediate_declaration = Helpers.declare_let("__intermediate__", J.identifier("null")) function_recur_dec = Helpers.function( "recur", [J.rest_element(J.identifier("__function_args__"))], J.block_statement([ arg_matches_declaration, intermediate_declaration, clauses, J.throw_statement( Helpers.new( J.member_expression( Helpers.patterns(), J.identifier("MatchError") ), [J.identifier("__function_args__")] ) ) ]) ) function_dec = Helpers.function( ElixirScript.Translate.Identifier.make_function_name(name), [J.rest_element(J.identifier("__function_args__"))], J.block_statement([ function_recur_dec, J.return_statement( trampoline() ) ]) ) { function_dec, state } end defp compile_clauses(clauses, state) do clauses |> Enum.map(&compile_clause(&1, state)) |> Enum.map(fn {patterns, _params, guards, body} -> match_or_default_call = Helpers.call( J.member_expression( Helpers.patterns(), J.identifier("match_or_default") ), [J.array_expression(patterns), J.identifier("__function_args__"), guards] ) J.if_statement( J.binary_expression( :!==, Helpers.assign(J.identifier("__arg_matches__"), match_or_default_call), J.identifier("null") ), J.block_statement(body) ) end) |> Enum.reverse |> Enum.reduce(nil, fn if_ast, nil -> if_ast if_ast, ast -> %{if_ast | alternate: ast} end) end defp compile_clause({ _, args, guards, body}, state) do state = if Map.has_key?(state, :vars) do state else Map.put(state, :vars, %{}) end {patterns, params, state} = Pattern.compile(args, state) guard = Clause.compile_guard(params, guards, state) {body, _state} = compile_block(body, state) body = body |> Clause.return_last_statement |> update_last_call(state) declaration = Helpers.declare_let(params, J.identifier("__arg_matches__")) body = [declaration] ++ body {patterns, params, guard, body} end defp compile_clause({:->, _, [[{:when, _, params}], body ]}, state) do guards = List.last(params) params = params |> Enum.reverse |> tl |> Enum.reverse compile_clause({[], params, guards, body}, state) end defp compile_clause({:->, _, [params, body]}, state) do compile_clause({[], params, [], body}, state) end @spec compile_block(any, map) :: {ESTree.Node.t, map} def compile_block(block, state) do ast = case block do nil -> J.identifier("null") {:__block__, _, block_body} -> {list, _} = Enum.map_reduce(block_body, state, &Form.compile(&1, &2)) List.flatten(list) _ -> Form.compile!(block, state) end {ast, state} end @spec update_last_call([ESTree.Node.t], map) :: ESTree.Node.t def update_last_call(clause_body, %{function: {name, _}, anonymous_fn: anonymous?}) do last_item = List.last(clause_body) function_name = ElixirScript.Translate.Identifier.make_function_name(name) case last_item do %ESTree.ReturnStatement{ argument: %ESTree.CallExpression{ callee: ^function_name, arguments: arguments } } -> if anonymous? do clause_body else new_last_item = J.return_statement( recurse( recur_bind(arguments) ) ) List.replace_at(clause_body, length(clause_body) - 1, new_last_item) end _ -> clause_body end end defp recur_bind(args) do Helpers.call( J.member_expression( J.identifier("recur"), J.identifier("bind") ), [J.identifier("null")] ++ args ) end defp recurse(func) do Helpers.new( J.member_expression( Helpers.functions(), J.identifier("Recurse") ), [ func ] ) end defp trampoline() do Helpers.call( J.member_expression( Helpers.functions(), J.identifier("trampoline") ), [ recurse( recur_bind([J.rest_element(J.identifier("__function_args__"))]) ) ] ) end end elixirscript-0.31.1/lib/elixir_script/passes/translate/helpers.ex000066400000000000000000000045541316305330500252450ustar00rootroot00000000000000defmodule ElixirScript.Translate.Helpers do @moduledoc false alias ESTree.Tools.Builder, as: J def symbol(value) do J.call_expression( J.member_expression( J.identifier("Symbol"), J.identifier("for") ), [J.literal(value)] ) end def new(callee, arguments) do J.new_expression( callee, arguments ) end def call(callee, arguments) do J.call_expression( callee, arguments ) end def arrow_function(params, body) do J.arrow_function_expression( params, [], body ) end def function(%ESTree.Identifier{} = name, params, body) do J.function_declaration( name, params, [], body ) end def function(name, params, body) when is_binary(name) do function(J.identifier(name), params, body) end def function(params, body) do J.function_expression( params, [], body ) end def core do J.member_expression( J.identifier("ElixirScript"), J.identifier("Core") ) end def core_module(module) do J.member_expression( core(), J.identifier(module) ) end def tuple do core_module("Tuple") end def bitstring do core_module("BitString") end def patterns do core_module("Patterns") end def functions do core_module("Functions") end def special_forms do core_module("SpecialForms") end def declare(%ESTree.Identifier{} = name, value) do declarator = J.variable_declarator( name, value ) J.variable_declaration([declarator], :const) end def declare(names, value) when is_list(names) do declarator = J.variable_declarator( J.array_pattern(names), value ) J.variable_declaration([declarator], :const) end def declare(name, value) when is_binary(name) do declare(J.identifier(name), value) end def declare_let(names, value) when is_list(names) do declarator = J.variable_declarator( J.array_pattern(names), value ) J.variable_declaration([declarator], :let) end def declare_let(name, value) do declarator = J.variable_declarator( J.identifier(name), value ) J.variable_declaration([declarator], :let) end def assign(name, value) do J.assignment_expression( :=, name, value ) end end elixirscript-0.31.1/lib/elixir_script/passes/translate/identifier.ex000066400000000000000000000026561316305330500257260ustar00rootroot00000000000000defmodule ElixirScript.Translate.Identifier do @moduledoc false alias ESTree.Tools.Builder, as: J @js_reserved_words [ :break, :case, :class, :const, :continue, :debugger, :default, :delete, :do, :else, :export, :extends, :finally, :function, :if, :import, :in, :instanceof, :new, :return, :super, :switch, :throw, :try, :typeof, :var, :void, :while, :with, :yield ] def make_identifier(ast) do ast |> filter_name |> J.identifier end def filter_name(reserved_word) when reserved_word in @js_reserved_words do "__#{Atom.to_string(reserved_word)}__" end def filter_name(name) do name = to_string(name) if String.contains?(name, ["?", "!"]) do name |> String.replace("?", "__qmark__") |> String.replace("!", "__emark__") else name end end defp make_alias([x]) do make_identifier(x) end defp make_alias([h|t]) do J.member_expression(make_alias(t), make_identifier(h)) end def make_namespace_members(module_name) do case module_name do m when is_list(m) -> m m when is_atom(m) -> Module.split(m) end |> Enum.reverse |> make_alias end def make_function_name(name) do name = filter_name(name) J.identifier(name) end def js_reserved_words() do @js_reserved_words end end elixirscript-0.31.1/lib/elixir_script/passes/translate/module.ex000066400000000000000000000142571316305330500250710ustar00rootroot00000000000000defmodule ElixirScript.Translate.Module do @moduledoc false alias ESTree.Tools.Builder, as: J alias ElixirScript.Translate.Helpers alias ElixirScript.Translate.Function alias ElixirScript.State, as: ModuleState alias ElixirScript.Translate.Form @doc """ Translate the given module's ast to JavaScript AST """ def compile(module, %{protocol: true} = info, pid) do ElixirScript.Translate.Protocol.compile(module, info, pid) end def compile(module, info, pid) do %{ attributes: attrs, compile_opts: _compile_opts, definitions: defs, file: _file, line: _line, module: ^module, unreachable: unreachable, used: used } = info state = %{ module: module, pid: pid } # Filter so that we only have the # Used functions to compile reachable_defs = Enum.filter(defs, fn { _, type, _, _} when type in [:defmacro, :defmacrop] -> false { name, _, _, _} -> not(name in unreachable) _ -> true end) used_defs = if Keyword.has_key?(attrs, :protocol_impl) do reachable_defs else Enum.filter(reachable_defs, fn { {:start, 2}, _, _, _ } -> true { {:__struct__, _}, _, _, _ } -> true { name, _, _, _} -> name in used _ -> false end) end #we combine our function arities combined_defs = combine_defs(used_defs) exports = make_exports(module, combined_defs) # If there are no public exports, skip compilation case exports do %ESTree.ObjectExpression{ properties: props } when length(props) == 2 -> nil _ -> { compiled_functions, _ } = Enum.map_reduce(combined_defs, state, &Function.compile(&1, &2)) info_function = make_info_function(module, state) compiled_functions = [info_function] ++ compiled_functions js_ast = ElixirScript.ModuleSystems.Namespace.build( module, compiled_functions, exports ) ModuleState.put_module(pid, module, Map.put(info, :js_ast, hd(js_ast))) end end defp combine_defs(used_defs) do used_defs |> Enum.sort(fn { {name1, arity1}, _, _, _ }, { {name2, arity2}, _, _, _ } -> "#{name1}#{arity1}" < "#{name2}#{arity2}" end) |> Enum.group_by(fn {{name, _}, _, _, _ } -> name end) |> Enum.map(fn {group, funs} -> {_, type, _, _} = hd(funs) Enum.reduce(funs, {{group, nil}, type, [], []}, fn {_, _, _, clauses}, {name, type, context, acc_clauses} -> {name, type, context, acc_clauses ++ clauses} end) end) end defp make_exports(module, reachable_defs) do exports = Enum.reduce(reachable_defs, [], fn {{name, _arity}, :def, _, _}, list -> function_name = ElixirScript.Translate.Identifier.make_identifier(name) list ++ [J.property(function_name, function_name, :init, true)] _, list -> list end) # Add an attribute to use to determine if this is a module # Will be used by the is_atom implementation exports = exports ++ [%ESTree.Property{ key: J.identifier("__MODULE__"), value: Helpers.symbol(to_string(module)) }, J.property( J.identifier("__info__"), J.identifier("__info__"), :init, true )] J.object_expression(exports) end @doc """ Determins if the given atom is an Elixir function """ def is_elixir_module(module) when is_atom(module) do str_module = Atom.to_string(module) case str_module do "Elixir" <> _ -> true _ -> false end end def is_elixir_module(_) do false end @doc """ Determines is given function is a JS module. A JS module is either one that begins with "JS" or is a module defined from the js_modules compiler opt """ def is_js_module(module, state) do cond do module in ModuleState.list_javascript_modules(state.pid) -> true module === Elixir -> false true -> false end end defp make_info_map(module, state) do functions = module.__info__(:functions) |> Form.compile!(state) macros = module.__info__(:macros) |> Form.compile!(state) attributes = module.__info__(:attributes) |> Form.compile!(state) compile = module.__info__(:compile) |> Keyword.update(:source, "", fn(x) -> :erlang.list_to_binary(x) end) |> Form.compile!(state) md5 = module.__info__(:md5) |> :erlang.binary_to_list md5 = Form.compile!({:<<>>, [], md5}, state) module = Helpers.symbol(to_string(module)) map_entries = J.array_expression([ J.array_expression([ Helpers.symbol("functions"), functions ]), J.array_expression([ Helpers.symbol("macros"), macros ]), J.array_expression([ Helpers.symbol("attributes"), attributes ]), J.array_expression([ Helpers.symbol("compile"), compile ]), J.array_expression([ Helpers.symbol("md5"), md5 ]), J.array_expression([ Helpers.symbol("module"), module ]), ]) map = Helpers.new( J.identifier("Map"), [ map_entries ] ) Helpers.declare("__info__map__", map) end # Builds the __info__ function that Elixir modules # have. defp make_info_function(module, state) do info_map = make_info_map(module, state) get_call = Helpers.call( J.member_expression( J.identifier("__info__map__"), J.identifier("get") ), [ J.identifier("kind") ] ) value = Helpers.declare("value", get_call) body = J.if_statement( J.binary_expression( :!==, J.identifier("value"), J.identifier("null") ), J.block_statement([ J.return_statement(J.identifier("value")) ]) ) body = J.block_statement([ info_map, value, body, J.throw_statement( Helpers.new( J.member_expression( Helpers.patterns(), J.identifier("MatchError") ), [J.identifier("kind")] ) ) ]) Helpers.function( "__info__", [J.identifier("kind")], body ) end end elixirscript-0.31.1/lib/elixir_script/passes/translate/protocol.ex000066400000000000000000000051361316305330500254410ustar00rootroot00000000000000defmodule ElixirScript.Translate.Protocol do @moduledoc false alias ESTree.Tools.Builder, as: J alias ElixirScript.Translate.Helpers alias ElixirScript.Translate.{Function, Identifier} alias ElixirScript.State, as: ModuleState @doc """ This compiles and consolidates the given protocol """ def compile(module, %{protocol: true, impls: impls, functions: functions} = info, pid) do object = Enum.map(functions, fn {function, _} -> {Identifier.make_function_name(function), Helpers.function([], J.block_statement([]))} end) |> Enum.map(fn({key, value}) -> ElixirScript.Translate.Forms.Map.make_property(key, value) end) |> J.object_expression declaration = Helpers.declare( "protocol", Helpers.call( J.member_expression( Helpers.functions(), J.identifier(:defprotocol) ), [object] ) ) body = build_implementations(impls) body = [declaration] ++ body js_ast = ElixirScript.ModuleSystems.Namespace.build( module, body, J.identifier("protocol") ) ModuleState.put_module(pid, module, Map.put(info, :js_ast, hd(js_ast))) end defp build_implementations(impls) do Enum.map(impls, fn({impl, impl_for}) -> members = ["Elixir"] ++ Module.split(impl) ++ ["__load"] ast = Helpers.call( Identifier.make_namespace_members(members), [J.identifier("Elixir")] ) Helpers.call( J.member_expression( Helpers.functions(), J.identifier(:defimpl) ), [ J.identifier("protocol"), map_to_js(impl_for), ast ] ) end) end defp map_to_js(Integer) do Helpers.core_module("Integer") end defp map_to_js(Tuple) do Helpers.tuple() end defp map_to_js(Atom) do J.identifier(:Symbol) end defp map_to_js(List) do J.identifier(:Array) end defp map_to_js(BitString) do Helpers.bitstring() end defp map_to_js(Float) do Helpers.core_module("Float") end defp map_to_js(Function) do J.identifier(:Function) end defp map_to_js(PID) do Helpers.core_module("PID") end defp map_to_js(Port) do Helpers.core_module("Port") end defp map_to_js(Reference) do Helpers.core_module("Reference") end defp map_to_js(Map) do J.identifier(:Map) end defp map_to_js(Any) do J.identifier(:null) end defp map_to_js(module) when is_atom(module) do case Module.split(module) do ["JS" | rest] -> Identifier.make_namespace_members(rest) _ -> Helpers.symbol(module) end end end elixirscript-0.31.1/lib/elixir_script/state.ex000066400000000000000000000051211316305330500214170ustar00rootroot00000000000000defmodule ElixirScript.State do @moduledoc false # Holds the state for the ElixirScript compiler def start_link() do Agent.start_link(fn -> %{ modules: Keyword.new, js_modules: [], in_memory_modules: [] } end) end def stop(pid) do Agent.stop(pid) end def get_module(pid, module) do Agent.get(pid, fn(state) -> Keyword.get(state.modules, module) end) end def put_module(pid, module, value) do Agent.update(pid, fn(state) -> value = Map.put(value, :used, []) modules = Keyword.put(state.modules, module, value) %{ state | modules: modules } end) end def has_used?(pid, module, func) do Agent.get(pid, fn(state) -> module_info = Keyword.get(state.modules, module) Enum.find(module_info.used, fn(x) -> x == func end) != nil end) end def add_used(pid, module, {_function, _arity} = func) do Agent.update(pid, fn(state) -> module_info = Keyword.get(state.modules, module) used = Map.get(module_info, :used, []) used = [func | used] module_info = Map.put(module_info, :used, used) modules = Keyword.put(state.modules, module, module_info) %{ state | modules: modules } end) end def put_javascript_module(pid, module, name, path) do Agent.update(pid, fn(state) -> js_modules = Map.get(state, :js_modules, []) js_modules = [{module, name, path} | js_modules] %{ state | js_modules: js_modules } end) end def list_javascript_modules(pid) do Agent.get(pid, fn(state) -> state.js_modules |> Enum.map(fn {module, _name, _path} -> module end) end) end def js_modules(pid) do Agent.get(pid, fn(state) -> state.js_modules end) end def get_js_module_name(pid, module) do Agent.get(pid, fn(state) -> {_, name, _} = state.js_modules |> Enum.find(fn {m, _, _} -> module == m end) name end) end def list_modules(pid) do Agent.get(pid, fn(state) -> state.modules end) end def get_in_memory_module(pid, module) do Agent.get(pid, fn(state) -> Keyword.get(state.in_memory_modules, module) end) end def get_in_memory_modules(pid) do Agent.get(pid, fn(state) -> state.in_memory_modules end) end def put_in_memory_module(pid, module, beam) do Agent.update(pid, fn(state) -> in_memory_modules = Map.get(state, :in_memory_modules, []) in_memory_modules = Keyword.put(in_memory_modules, module, beam) %{ state | in_memory_modules: in_memory_modules } end) end end elixirscript-0.31.1/lib/mix/000077500000000000000000000000001316305330500156575ustar00rootroot00000000000000elixirscript-0.31.1/lib/mix/tasks/000077500000000000000000000000001316305330500170045ustar00rootroot00000000000000elixirscript-0.31.1/lib/mix/tasks/compile.elixir_script.ex000066400000000000000000000044641316305330500236610ustar00rootroot00000000000000defmodule Mix.Tasks.Compile.ElixirScript do use Mix.Task @recursive true @moduledoc """ Mix compiler to allow mix to compile Elixirscript source files into JavaScript Looks for an `elixir_script` or `elixirscript` key in your mix project config def project do [ app: :my_app, version: "0.1.0", elixir: "~> 1.0", deps: deps, elixir_script: [ input: Example, output: "dest/js"], compilers: Mix.compilers ++ [:elixir_script] ] end Available options are: * `input`: The module or modules that are the entry to your application (required) * `output`: The path of the generated JavaScript file. (defaults to `priv/elixir_script/build`) If path ends in `.js` then that will be the name of the file. If a directory is given, file will be named `elixirscript.build.js` * `root`: Optional root for imports of FFI JavaScript modules. Defaults to `.`. If using output directly in a browser, you may want to make it something like `/js` or some uri. The mix compiler will also compile any dependencies that have the elixirscript compiler in its mix compilers as well """ @spec run(any()) :: :ok def run(_) do do_compile() :ok end defp do_compile() do {input, opts} = get_compiler_params() ElixirScript.Compiler.compile(input, opts) end def clean do {_, opts} = get_compiler_params() case opts[:output] do path when is_binary(path) -> file_name = ElixirScript.Output.get_output_file_name(path) File.rm!(file_name) _ -> nil end :ok end @doc false def get_compiler_params() do elixirscript_config = get_elixirscript_config() input = Keyword.fetch!(elixirscript_config, :input) opts = [ output: Keyword.get(elixirscript_config, :output) ] {input, opts} end defp get_elixirscript_config() do config = Mix.Project.config exjs_config = cond do Keyword.has_key?(config, :elixir_script) -> Keyword.get(config, :elixir_script, []) Keyword.has_key?(config, :elixirscript) -> Keyword.get(config, :elixirscript, []) true -> defaults() end Keyword.merge(defaults(), exjs_config) end defp defaults() do [ output: "priv/elixir_script/build" ] end end elixirscript-0.31.1/lib/mix/tasks/elixirscript.ex000066400000000000000000000004711316305330500220650ustar00rootroot00000000000000defmodule Mix.Tasks.Elixirscript do @moduledoc """ A command-line interface to the elixirscript compiler """ use Mix.Task @shortdoc "Translate Elixir to JavaScript" def run(args) do Mix.Task.run "app.start" args |> ElixirScript.CLI.parse_args |> ElixirScript.CLI.process end end elixirscript-0.31.1/mix.exs000066400000000000000000000025071316305330500156360ustar00rootroot00000000000000defmodule ElixirScript.Mixfile do use Mix.Project def project do [ app: :elixir_script, version: "0.31.1", elixir: "~> 1.5", elixirc_paths: elixirc_paths(Mix.env), deps: deps(), description: description(), package: package(), source_url: "https://github.com/elixirscript/elixirscript", test_coverage: [tool: ExCoveralls], docs: [ main: "ElixirScript", extras: ["JavaScriptInterop.md"] ] ] end def application do [ extra_applications: [:logger] ] end defp deps do [ {:estree, "~> 2.6"}, {:ex_doc, "~> 0.16", only: :dev}, {:excoveralls, "~> 0.7", only: :test}, {:credo, "~> 0.8", only: [:dev, :test]}, {:stream_data, "~> 0.1", only: :test}, {:poison, "~> 3.1", only: :test} ] end defp elixirc_paths(:test), do: ["lib", "test/support"] defp elixirc_paths(_), do: ["lib"] defp description do """ ElixirScript: compiles Elixir code to JavaScript """ end defp package do [ files: ["lib", "priv/**/*.*", "mix.exs", "README.md", "LICENSE", "CHANGELOG.md"], maintainers: ["Bryan Joseph"], licenses: ["MIT"], links: %{ "GitHub" => "https://github.com/elixirscript/elixirscript" }, build_tools: ["mix"] ] end end elixirscript-0.31.1/mix.lock000066400000000000000000000057301316305330500157700ustar00rootroot00000000000000%{"bunt": {:hex, :bunt, "0.2.0", "951c6e801e8b1d2cbe58ebbd3e616a869061ddadcc4863d0a2182541acae9a38", [:mix], [], "hexpm"}, "certifi": {:hex, :certifi, "2.0.0", "a0c0e475107135f76b8c1d5bc7efb33cd3815cb3cf3dea7aefdd174dabead064", [:rebar3], [], "hexpm"}, "credo": {:hex, :credo, "0.8.6", "335f723772d35da499b5ebfdaf6b426bfb73590b6fcbc8908d476b75f8cbca3f", [:mix], [{:bunt, "~> 0.2.0", [hex: :bunt, repo: "hexpm", optional: false]}], "hexpm"}, "earmark": {:hex, :earmark, "1.2.3", "206eb2e2ac1a794aa5256f3982de7a76bf4579ff91cb28d0e17ea2c9491e46a4", [:mix], [], "hexpm"}, "estree": {:hex, :estree, "2.6.1", "0a17cc0e9e35315dc4fcd79d30a746b1f3e9ed654be6084ce882ab491165ae22", [:mix], [], "hexpm"}, "ex_doc": {:hex, :ex_doc, "0.16.3", "cd2a4cfe5d26e37502d3ec776702c72efa1adfa24ed9ce723bb565f4c30bd31a", [:mix], [{:earmark, "~> 1.1", [hex: :earmark, repo: "hexpm", optional: false]}], "hexpm"}, "excoveralls": {:hex, :excoveralls, "0.7.2", "f69ede8c122ccd3b60afc775348a53fc8c39fe4278aee2f538f0d81cc5e7ff3a", [:mix], [{:exjsx, ">= 3.0.0", [hex: :exjsx, repo: "hexpm", optional: false]}, {:hackney, ">= 0.12.0", [hex: :hackney, repo: "hexpm", optional: false]}], "hexpm"}, "exjsx": {:hex, :exjsx, "4.0.0", "60548841e0212df401e38e63c0078ec57b33e7ea49b032c796ccad8cde794b5c", [:mix], [{:jsx, "~> 2.8.0", [hex: :jsx, repo: "hexpm", optional: false]}], "hexpm"}, "hackney": {:hex, :hackney, "1.9.0", "51c506afc0a365868469dcfc79a9d0b94d896ec741cfd5bd338f49a5ec515bfe", [:rebar3], [{:certifi, "2.0.0", [hex: :certifi, repo: "hexpm", optional: false]}, {:idna, "5.1.0", [hex: :idna, repo: "hexpm", optional: false]}, {:metrics, "1.0.1", [hex: :metrics, repo: "hexpm", optional: false]}, {:mimerl, "1.0.2", [hex: :mimerl, repo: "hexpm", optional: false]}, {:ssl_verify_fun, "1.1.1", [hex: :ssl_verify_fun, repo: "hexpm", optional: false]}], "hexpm"}, "idna": {:hex, :idna, "5.1.0", "d72b4effeb324ad5da3cab1767cb16b17939004e789d8c0ad5b70f3cea20c89a", [:rebar3], [{:unicode_util_compat, "0.3.1", [hex: :unicode_util_compat, repo: "hexpm", optional: false]}], "hexpm"}, "jsx": {:hex, :jsx, "2.8.2", "7acc7d785b5abe8a6e9adbde926a24e481f29956dd8b4df49e3e4e7bcc92a018", [:mix, :rebar3], [], "hexpm"}, "metrics": {:hex, :metrics, "1.0.1", "25f094dea2cda98213cecc3aeff09e940299d950904393b2a29d191c346a8486", [:rebar3], [], "hexpm"}, "mimerl": {:hex, :mimerl, "1.0.2", "993f9b0e084083405ed8252b99460c4f0563e41729ab42d9074fd5e52439be88", [:rebar3], [], "hexpm"}, "poison": {:hex, :poison, "3.1.0", "d9eb636610e096f86f25d9a46f35a9facac35609a7591b3be3326e99a0484665", [:mix], [], "hexpm"}, "ssl_verify_fun": {:hex, :ssl_verify_fun, "1.1.1", "28a4d65b7f59893bc2c7de786dec1e1555bd742d336043fe644ae956c3497fbe", [:make, :rebar], [], "hexpm"}, "stream_data": {:hex, :stream_data, "0.2.0", "887b7701cd4ea235e0d704ce60f86096ff5754dae55c3ead4e1d43f152a9239e", [:mix], [], "hexpm"}, "unicode_util_compat": {:hex, :unicode_util_compat, "0.3.1", "a1f612a7b512638634a603c8f401892afbf99b8ce93a45041f8aaca99cadb85e", [:rebar3], [], "hexpm"}} elixirscript-0.31.1/package.json000066400000000000000000000025251316305330500166060ustar00rootroot00000000000000{ "name": "elixirscript", "version": "0.26.1", "description": "Convert Elixir to JavaScript", "main": "elixir.js", "bin": { "elixirscript": "./elixirscript" }, "engines": { "node": ">=7.1" }, "scripts": { "lint": "eslint src/javascript/lib/**/*.js src/javascript/tests/**/*.js", "lint:fix": "eslint src/javascript/lib/**/*.js src/javascript/tests/**/*.js --fix", "build": "rollup -c rollup.config.js", "clean": "rm -rf priv/build", "test": "nyc ava src/javascript/tests" }, "repository": { "type": "git", "url": "git@github.com:bryanjos/elixirscript.git" }, "author": "", "license": "MIT", "dependencies": { "erlang-types": "^1.0.1", "grapheme-splitter": "^1.0.2", "rollup-plugin-commonjs": "^8.2.1", "tailored": "^2.7.4" }, "devDependencies": { "@std/esm": "^0.8.3", "ava": "^0.22.0", "babel-core": "^6.26.0", "babel-preset-env": "^1.6.0", "babel-register": "^6.26.0", "eslint": "^4.6.1", "eslint-config-airbnb-base": "^12.0.0", "eslint-plugin-import": "^2.7.0", "nyc": "^11.2.1", "rollup": "^0.49.3", "rollup-plugin-babel": "^3.0.2", "rollup-plugin-babel-minify": "^3.1.2", "rollup-plugin-node-resolve": "^3.0.0" }, "ava": { "require": [ "babel-register" ], "babel": { "babelrc": true } } } elixirscript-0.31.1/rollup.config.js000066400000000000000000000010631316305330500174330ustar00rootroot00000000000000import nodeResolve from 'rollup-plugin-node-resolve'; import commonjs from 'rollup-plugin-commonjs'; import babel from 'rollup-plugin-babel'; import minify from 'rollup-plugin-babel-minify'; export default { input: 'src/javascript/elixir.js', name: 'ElixirScript', plugins: [ nodeResolve({ jsnext: true, main: true, }), commonjs(), babel({ babelrc: false, }), minify({ keepFnName: true, keepClassName: true, }), ], output: [{ file: 'priv/build/iife/ElixirScript.Core.js', format: 'iife' }], }; elixirscript-0.31.1/src/000077500000000000000000000000001316305330500151035ustar00rootroot00000000000000elixirscript-0.31.1/src/javascript/000077500000000000000000000000001316305330500172515ustar00rootroot00000000000000elixirscript-0.31.1/src/javascript/elixir.js000066400000000000000000000000741316305330500211040ustar00rootroot00000000000000import Core from './lib/core'; export default { Core, }; elixirscript-0.31.1/src/javascript/lib/000077500000000000000000000000001316305330500200175ustar00rootroot00000000000000elixirscript-0.31.1/src/javascript/lib/core.js000066400000000000000000000027341316305330500213130ustar00rootroot00000000000000import Patterns from 'tailored'; import ErlangTypes from 'erlang-types'; import Functions from './core/functions'; import SpecialForms from './core/special_forms'; import erlang from './core/erlang_compat/erlang'; import maps from './core/erlang_compat/maps'; import lists from './core/erlang_compat/lists'; import elixir_errors from './core/erlang_compat/elixir_errors'; import elixir_config from './core/erlang_compat/elixir_config'; import io from './core/erlang_compat/io'; import binary from './core/erlang_compat/binary'; import unicode from './core/erlang_compat/unicode'; import Store from './core/store'; import math from './core/erlang_compat/math'; import proplists from './core/erlang_compat/proplists'; class Integer {} class Float {} function get_global() { if (typeof self !== 'undefined') { return self; } else if (typeof window !== 'undefined') { return window; } else if (typeof global !== 'undefined') { return global; } console.warn('No global state found'); return null; } const globalState = get_global(); globalState.__elixirscript_store__ = new Map(); globalState.__elixirscript_names__ = new Map(); export default { Tuple: ErlangTypes.Tuple, PID: ErlangTypes.PID, BitString: ErlangTypes.BitString, Reference: ErlangTypes.Reference, Patterns, Integer, Float, Functions, SpecialForms, Store, global: globalState, erlang, maps, lists, elixir_errors, io, binary, unicode, elixir_config, math, proplists, }; elixirscript-0.31.1/src/javascript/lib/core/000077500000000000000000000000001316305330500207475ustar00rootroot00000000000000elixirscript-0.31.1/src/javascript/lib/core/erlang_compat/000077500000000000000000000000001316305330500235625ustar00rootroot00000000000000elixirscript-0.31.1/src/javascript/lib/core/erlang_compat/binary.js000066400000000000000000000026261316305330500254120ustar00rootroot00000000000000import erlang from './erlang'; import proplists from './proplists'; function at(subject, pos) { return subject.charAt(pos); } function copy(subject, n = 1) { return subject.repeat(n); } function first(subject) { if (subject.length === 0) { throw new Error('Binary is of length 0'); } return at(subject, 0); } function last(subject) { if (subject.length === 0) { throw new Error('Binary is of length 0'); } return subject.slice(-1); } function list_to_bin(bytelist) { return erlang.list_to_binary(bytelist); } function part(subject, posOrTuple, len = null) { if (len === null) { const [pos, theLen] = posOrTuple.values; return subject.substr(pos, theLen); } return subject.substr(posOrTuple, len); } // TODO: Support more options // TODO: pattern cannot be list of strings function replace(subject, pattern, replacement, options = []) { const opt_global = proplists.get_value(Symbol.for('global'), options); let regex; if (opt_global !== Symbol.for('undefined')) { regex = new RegExp(pattern, 'g'); } else { regex = new RegExp(pattern, ''); } return subject.replace(regex, replacement); } // TODO: Support more options, global is implied // TODO: pattern cannot be list of strings function split(subject, pattern, options = []) { return subject.split(pattern); } export default { at, copy, first, last, list_to_bin, part, replace, split, }; elixirscript-0.31.1/src/javascript/lib/core/erlang_compat/elixir_config.js000066400000000000000000000012771316305330500267500ustar00rootroot00000000000000const MODULE = Symbol.for('elixir_config'); const ets = new Map(); function _new(opts) { ets.set(MODULE, new Map()); ets.get(MODULE).set(MODULE, opts); return MODULE; } function _delete(module) { ets.delete(module); return true; } function put(key, value) { ets.get(MODULE).set(key, value); return Symbol.for('ok'); } function get(key) { return ets.get(MODULE).get(key); } function update(key, fun) { const value = fun(ets.get(MODULE).get(key)); put(key, value); return value; } function get_and_put(key, value) { const oldValue = get(key); put(key, value); return oldValue; } export default { new: _new, delete: _delete, put, get, update, get_and_put, }; elixirscript-0.31.1/src/javascript/lib/core/erlang_compat/elixir_errors.js000066400000000000000000000002531316305330500270100ustar00rootroot00000000000000function warn(message) { const messageString = message.join(''); console.warn(`warning: ${messageString}`); return Symbol.for('ok'); } export default { warn, }; elixirscript-0.31.1/src/javascript/lib/core/erlang_compat/erlang.js000066400000000000000000000252421316305330500253750ustar00rootroot00000000000000// http://erlang.org/doc/man/erlang.html import ErlangTypes from 'erlang-types'; import lists from './lists'; const selfPID = new ErlangTypes.PID(); function is_boolean(value) { return typeof value === 'boolean' || value instanceof Boolean; } function atom_to_binary(atom, encoding = Symbol.for('utf8')) { if (encoding !== Symbol.for('utf8')) { throw new Error(`unsupported encoding ${encoding}`); } if (atom === null) { return 'nil'; } else if (is_boolean(atom)) { return atom.toString(); } else if (atom.__MODULE__) { return Symbol.keyFor(atom.__MODULE__); } return Symbol.keyFor(atom); } function atom_to_list(atom) { return atom_to_binary(atom); } function binary_to_atom(binary, encoding = Symbol.for('utf8')) { if (encoding !== Symbol.for('utf8')) { throw new Error(`unsupported encoding ${encoding}`); } if (binary === 'nil') { return null; } else if (binary === 'true') { return true; } else if (binary === 'false') { return false; } return Symbol.for(binary); } function binary_to_existing_atom(binary, encoding = Symbol.for('utf8')) { return binary_to_atom(binary, encoding); } function list_concatenation(list1, list2) { return list1.concat(list2); } function list_subtraction(list1, list2) { const list = [...list1]; for (const item of list2) { const index = list.indexOf(item); if (index > -1) { list.splice(index, 1); } } return list; } function arrayEquals(left, right) { if (!Array.isArray(right)) { return false; } if (left.length !== right.length) { return false; } for (let i = 0; i < left.length; i++) { if (equals(left[i], right[i]) === false) { return false; } } return true; } function tupleEquals(left, right) { if (right instanceof ErlangTypes.Tuple === false) { return false; } if (left.length !== right.length) { return false; } return arrayEquals(left.values, right.values); } function bitstringEquals(left, right) { if (right instanceof ErlangTypes.BitString === false) { return false; } if (left.length !== right.length) { return false; } return arrayEquals(left.value, right.value); } function pidEquals(left, right) { if (right instanceof ErlangTypes.PID === false) { return false; } return left.id === right.id; } function referenceEquals(left, right) { if (right instanceof ErlangTypes.Reference === false) { return false; } return left.id === right.id; } function mapEquals(left, right) { if (right instanceof Map === false) { return false; } const leftEntries = Array.from(left.entries()); const rightEntries = Array.from(right.entries()); return arrayEquals(leftEntries, rightEntries); } function equals(left, right) { if (Array.isArray(left)) { return arrayEquals(left, right); } if (left instanceof ErlangTypes.Tuple) { return tupleEquals(left, right); } if (left instanceof ErlangTypes.PID) { return pidEquals(left, right); } if (left instanceof ErlangTypes.BitString) { return bitstringEquals(left, right); } if (left instanceof ErlangTypes.Reference) { return referenceEquals(left, right); } if (left instanceof Map) { return mapEquals(left, right); } return left === right; } function div(left, right) { return left / right; } function not(x) { return !x; } function rem(left, right) { return left % right; } function band(left, right) { return left & right; } function bor(left, right) { return left | right; } function bnot(x) { return ~x; } function bsl(left, right) { return left << right; } function bsr(left, right) { return left >> right; } function bxor(left, right) { return left ^ right; } function is_atom(value) { if (value === null) { return true; } else if (is_boolean(value)) { return true; } return typeof value === 'symbol' || value instanceof Symbol || value.__MODULE__ != null; } function is_bitstring(value) { return value instanceof ErlangTypes.BitString; } function is_number(value) { return typeof value === 'number' || value instanceof Number; } function is_float(value) { return is_number(value) && !Number.isInteger(value); } function is_function(value) { return typeof value === 'function' || value instanceof Function; } function is_integer(value) { return Number.isInteger(value); } function is_list(value) { return Array.isArray(value); } function is_map(value) { return value instanceof Map; } function is_pid(value) { return value instanceof ErlangTypes.PID; } function is_port() { return false; } function is_reference(value) { return value instanceof ErlangTypes.Reference; } function is_tuple(value) { return value instanceof ErlangTypes.Tuple; } function is_binary(value) { return typeof value === 'string' || value instanceof String; } function element(n, tuple) { return tuple.get(n - 1); } function setelement(index, tuple1, value) { const tupleData = [...tuple1.values]; tupleData[index - 1] = value; return new ErlangTypes.Tuple(...tupleData); } function make_tuple(arity, initialValue) { const list = []; for (let i = 0; i < arity; i++) { list.push(initialValue); } return new ErlangTypes.Tuple(...list); } function insert_element(index, tuple, term) { const list = [...tuple.values]; list.splice(index - 1, 0, term); return new ErlangTypes.Tuple(...list); } function append_element(tuple, term) { const list = [...tuple.values]; list.push(term); return new ErlangTypes.Tuple(...list); } function delete_element(index, tuple) { const list = [...tuple.values]; list.splice(index - 1, 1); return new ErlangTypes.Tuple(...list); } function tuple_to_list(tuple) { const list = [...tuple.values]; return list; } function abs(number) { return Math.abs(number); } function apply(...args) { if (args.length === 2) { return args[0].apply(this, ...args[1]); } return args[0][atom_to_binary(args[1])].apply(this, ...args[2]); } function binary_part(binary, start, _length) { return binary.substring(start, start + _length); } function bit_size(bitstring) { return bitstring.bit_size; } function byte_size(bitstring) { if (typeof bitstring === 'string' || bitstring instanceof String) { return bitstring.length; } return bitstring.byte_size; } function hd(list) { return list[0]; } function length(list) { return list.length; } function make_ref() { return new ErlangTypes.Reference(); } function map_size(map) { return map.size; } function max(first, second) { return Math.max(first, second); } function min(first, second) { return Math.min(first, second); } function round(number) { return Math.round(number); } function tl(list) { return list.slice(1); } function trunc(number) { return Math.trunc(number); } function tuple_size(tuple) { return tuple.length; } function binary_to_float(str) { return parseFloat(str); } function binary_to_integer(str, base = 10) { return parseInt(str, base); } function process_info(pid, item) { if (item) { if (item === Symbol.for('current_stacktrace')) { return new ErlangTypes.Tuple(item, []); } return new ErlangTypes.Tuple(item, null); } return []; } function list_to_binary(iolist) { const iolistFlattened = lists.flatten(iolist); const value = iolistFlattened.reduce((acc, current) => { if (current === null) { return acc; } else if (is_integer(current)) { return acc + String.fromCodePoint(current); } else if (is_bitstring(current)) { return acc + String.fromCodePoint(...current.value); } return acc + current; }, ''); return value; } function iolist_to_binary(ioListOrBinary) { if (ioListOrBinary === null) { return ''; } if (is_binary(ioListOrBinary)) { return ioListOrBinary; } if (is_bitstring(ioListOrBinary)) { return String.fromCodePoint(...ioListOrBinary.value); } if (is_number(ioListOrBinary)) { return String.fromCodePoint(ioListOrBinary); } const iolistFlattened = lists.flatten(ioListOrBinary); const value = iolistFlattened.reduce((acc, current) => { if (current === null) { return acc; } else if (is_integer(current)) { return acc + String.fromCodePoint(current); } else if (is_bitstring(current)) { return acc + String.fromCodePoint(...current.value); } return acc + iolist_to_binary(current); }, ''); return value; } function io_size(ioListOrBinary) { return iolist_to_binary(ioListOrBinary).length; } function integer_to_binary(integer, base = 10) { return integer.toString(base); } function node() { return Symbol.for('nonode@nohost'); } function nodes(arg = []) { const nodeTypes = Array.isArray(arg) ? arg : [arg]; const nodesFound = []; for (const nodeType of nodeTypes) { if (nodeType === Symbol.for('this')) { nodesFound.push(Symbol.for('nonode@nohost')); console.log(nodesFound); } } return nodesFound; } function self() { return selfPID; } function _throw(term) { throw term; } function error(reason) { if (reason instanceof Map && reason.has(Symbol.for('__exception__'))) { let name = Symbol.keyFor(reason.get(Symbol.for('__struct__')).__MODULE__); name = name .split('.') .slice(1) .join('.'); const message = reason.get(Symbol.for('message')); throw new Error(`** (${name}) ${message}`); } else if (is_binary(reason)) { throw new Error(`** (RuntimeError) ${reason}`); } else { throw new Error(`** (ErlangError) Erlang Error ${reason.toString()}`); } } function exit(...args) { if (args.length === 2) { throw args[1]; } else { throw args[0]; } } function raise(_class, reason) { if (_class === Symbol.for('throw')) { _throw(reason); } else if (_class === Symbol.for('error')) { error(reason); } else { exit(reason); } } function function_exported(module, _function) { return module[_function] != null; } export default { atom_to_binary, binary_to_atom, binary_to_existing_atom, list_concatenation, list_subtraction, div, not, rem, band, bor, bsl, bsr, bxor, bnot, is_bitstring, is_boolean, is_float, is_function, is_integer, is_list, is_map, is_number, is_pid, is_port, is_reference, is_tuple, is_atom, is_binary, element, setelement, make_tuple, insert_element, append_element, delete_element, tuple_to_list, abs, apply, binary_part, bit_size, byte_size, hd, length, make_ref, map_size, max, min, round, tl, trunc, tuple_size, binary_to_float, binary_to_integer, process_info, iolist_to_binary, io_size, integer_to_binary, atom_to_list, node, self, throw: _throw, error, exit, raise, list_to_binary, nodes, function_exported, equals, }; elixirscript-0.31.1/src/javascript/lib/core/erlang_compat/io.js000066400000000000000000000004731316305330500245330ustar00rootroot00000000000000import erlang from './erlang'; function put_chars(ioDevice, charData) { const dataToWrite = erlang.iolist_to_binary(charData); if (ioDevice === Symbol.for('stderr')) { console.error(dataToWrite); } else { console.log(dataToWrite); } return Symbol.for('ok'); } export default { put_chars, }; elixirscript-0.31.1/src/javascript/lib/core/erlang_compat/lists.js000066400000000000000000000111041316305330500252530ustar00rootroot00000000000000// http://erlang.org/doc/man/lists.html import ErlangTypes from 'erlang-types'; function reverse(list) { return [...list].reverse(); } function foreach(fun, list) { list.forEach(x => fun(x)); return Symbol.for('ok'); } function duplicate(n, elem) { const list = []; while (list.length < n) { list.push(elem); } return list; } function flatten(deepList, tail = []) { const val = deepList.reduce((acc, value) => { if (Array.isArray(value)) { return acc.concat(flatten(value)); } return acc.concat(value); }, []); return val.concat(tail); } function foldl(fun, acc0, list) { return list.reduce((acc, value) => fun(value, acc), acc0); } function foldr(fun, acc0, list) { return foldl(fun, acc0, reverse(list)); } function keyfind(key, n, list) { for (const ele of list) { if (ele instanceof ErlangTypes.Tuple && ele.get(n - 1) === key) { return ele; } } return false; } function keymember(key, n, tupleList) { if (keyfind(key, n, tupleList) === false) { return false; } return true; } function keyreplace(key, n, tupleList, newTuple) { const newTupleList = [...tupleList]; for (let index = 0; index < newTupleList.length; index++) { if (newTupleList[index].get(n - 1) === key) { newTupleList[index] = newTuple; return newTupleList; } } return newTupleList; } function keysort(n, tupleList) { const newTupleList = [...tupleList]; return newTupleList.sort((a, b) => { if (a.get(n - 1) < b.get(n - 1)) { return -1; } else if (a.get(n - 1) > b.get(n - 1)) { return 1; } return 0; }); } function keystore(key, n, tupleList, newTuple) { const newTupleList = [...tupleList]; for (let index = 0; index < newTupleList.length; index++) { if (newTupleList[index].get(n - 1) === key) { newTupleList[index] = newTuple; return newTupleList; } } return newTupleList.concat(newTuple); } function keydelete(key, n, tupleList) { const newTupleList = []; let deleted = false; for (let index = 0; index < tupleList.length; index++) { if (deleted === false && tupleList[index].get(n - 1) === key) { deleted = true; } else { newTupleList.push(tupleList[index]); } } return newTupleList; } function keytake(key, n, tupleList) { const result = keyfind(key, n, tupleList); if (result !== false) { return new ErlangTypes.Tuple(result.get(n - 1), result, keydelete(key, n, tupleList)); } return false; } function mapfoldl(fun, acc0, list1) { const listResult = []; let accResult = acc0; for (const item of list1) { const tuple = fun(item, accResult); listResult.push(tuple.get(0)); accResult = tuple.get(1); } return new ErlangTypes.Tuple(listResult, accResult); } function concat(things) { return things.map(v => v.toString()).join(); } function map(fun, list) { return list.map(value => fun(value)); } function filter(pred, list1) { return list1.filter(x => pred(x)); } function filtermap(fun, list1) { const list2 = []; for (const item of list1) { const value = fun(item); if (value === true) { list2.push(item); } else if (value instanceof ErlangTypes.Tuple && value.get(0) === true) { list2.push(value.get(1)); } } return list2; } function member(elem, list) { for (const item of list) { if (item === elem) { return true; } } return false; } function all(pred, list) { for (const item of list) { if (pred(item) === false) { return false; } } return true; } function any(pred, list) { for (const item of list) { if (pred(item) === true) { return true; } } return false; } function splitwith(pred, list) { let switchToList2 = false; const list1 = []; const list2 = []; for (const item of list) { if (switchToList2 === true) { list2.push(item); } else if (pred(item) === true) { list1.push(item); } else { switchToList2 = true; list2.push(item); } } return new ErlangTypes.Tuple(list1, list2); } function sort(...args) { if (args.length === 1) { const list2 = [...args[0]]; return list2.sort(); } const fun = args[0]; const list2 = [...args[1]]; return list2.sort((a, b) => { const result = fun(a, b); if (result === true) { return -1; } return 1; }); } export default { reverse, foreach, duplicate, flatten, foldl, foldr, keydelete, keyfind, keymember, keyreplace, keysort, keystore, keytake, mapfoldl, concat, map, filter, filtermap, member, all, any, splitwith, sort, }; elixirscript-0.31.1/src/javascript/lib/core/erlang_compat/maps.js000066400000000000000000000102521316305330500250600ustar00rootroot00000000000000// http://erlang.org/doc/man/maps.html import ErlangTypes from 'erlang-types'; import erlang from './erlang'; const OK = Symbol.for('ok'); const ERROR = Symbol.for('error'); const BADMAP = Symbol.for('badmap'); const BADKEY = Symbol.for('badkey'); function is_non_primitive(key) { return ( erlang.is_list(key) || erlang.is_map(key) || erlang.is_pid(key) || erlang.is_reference(key) || erlang.is_bitstring(key) || erlang.is_tuple(key) ); } function __put(map, key, value) { const map2 = new Map(map); if (is_non_primitive(key)) { for (const map_key of map.keys()) { if (erlang.equals(map_key, key)) { map2.set(map_key, value); return map2; } } } map2.set(key, value); return map2; } function __has(map, key) { if (is_non_primitive(key)) { for (const map_key of map.keys()) { if (erlang.equals(map_key, key)) { return true; } } return false; } return map.has(key); } function __get(map, key) { if (is_non_primitive(key)) { for (const map_key of map.keys()) { if (erlang.equals(map_key, key)) { return map.get(map_key); } } return null; } return map.get(key); } function __delete(map, key) { if (is_non_primitive(key)) { for (const map_key of map.keys()) { if (erlang.equals(map_key, key)) { map.delete(map_key); } } } else { map.delete(key); } } function find(key, map) { if (erlang.is_map(map) === false) { return new ErlangTypes.Tuple(BADMAP, map); } const value = __get(map, key); if (typeof value !== 'undefined') { return new ErlangTypes.Tuple(OK, value); } return ERROR; } function fold(fun, init, map) { let acc = init; for (const [key, value] of map.entries()) { acc = fun(key, value, acc); } return acc; } function remove(key, map1) { if (erlang.is_map(map1) === false) { return new ErlangTypes.Tuple(BADMAP, map1); } const map2 = new Map(map1); __delete(map2, key); return map2; } function to_list(map) { if (erlang.is_map(map) === false) { return new ErlangTypes.Tuple(BADMAP, map); } const list = []; for (const [key, value] of map.entries()) { list.push(new ErlangTypes.Tuple(key, value)); } return list; } function from_list(list) { return list.reduce((acc, item) => { const [key, value] = item; acc.set(key, value); return acc; }, new Map()); } function keys(map) { if (erlang.is_map(map) === false) { return new ErlangTypes.Tuple(BADMAP, map); } return Array.from(map.keys()); } function values(map) { if (erlang.is_map(map) === false) { return new ErlangTypes.Tuple(BADMAP, map); } return Array.from(map.values()); } function is_key(key, map) { return __has(map, key); } function put(key, value, map1) { if (erlang.is_map(map1) === false) { return new ErlangTypes.Tuple(BADMAP, map1); } return __put(map1, key, value); } function merge(map1, map2) { if (erlang.is_map(map1) === false) { return new ErlangTypes.Tuple(BADMAP, map1); } if (erlang.is_map(map2) === false) { return new ErlangTypes.Tuple(BADMAP, map2); } return new Map([...map1, ...map2]); } function update(key, value, map1) { if (erlang.is_map(map1) === false) { return new ErlangTypes.Tuple(BADMAP, map1); } if (is_key(key, map1) === false) { return new ErlangTypes.Tuple(BADKEY, key); } return new Map([...map1, [key, value]]); } function get(...args) { const key = args[0]; const map = args[1]; if (erlang.is_map(map) === false) { return new ErlangTypes.Tuple(BADMAP, map); } if (is_key(key, map)) { return __get(map, key); } if (args.length === 3) { return args[2]; } return new ErlangTypes.Tuple(BADKEY, key); } function take(key, map1) { if (erlang.is_map(map1) === false) { return new ErlangTypes.Tuple(BADMAP, map1); } if (!is_key(key, map1)) { return ERROR; } const value = __get(map1, key); const map2 = new Map(map1); __delete(map2, key); return new ErlangTypes.Tuple(value, map2); } export default { find, fold, remove, to_list, from_list, keys, values, is_key, put, merge, update, get, take, __has, }; elixirscript-0.31.1/src/javascript/lib/core/erlang_compat/math.js000066400000000000000000000001111316305330500250420ustar00rootroot00000000000000function log2(x) { return Math.log2(x); } export default { log2, }; elixirscript-0.31.1/src/javascript/lib/core/erlang_compat/proplists.js000066400000000000000000000007331316305330500261620ustar00rootroot00000000000000import lists from './lists'; function get_value(key, list, defaultv = Symbol.for('undefined')) { const tuple = lists.keyfind(key, 1, list); if (tuple) { const [, value] = tuple.values; return value; } else if (lists.member(key, list)) { return true; } return defaultv; } function is_defined(key, list) { const tuple = lists.keyfind(key, 1, list); if (tuple) { return true; } return false; } export default { get_value, is_defined, }; elixirscript-0.31.1/src/javascript/lib/core/erlang_compat/unicode.js000066400000000000000000000013221316305330500255440ustar00rootroot00000000000000import erlang from './erlang'; import lists from './lists'; function characters_to_list(characters, inEncoding = Symbol.for('unicode')) { let values = characters; if (Array.isArray(characters)) { values = lists.flatten(characters); } if (erlang.is_binary(values)) { return values.split('').map(c => c.codePointAt(0)); } return values.reduce((acc, c) => { if (erlang.is_integer(c)) { return acc.concat(c); } return acc.concat(characters_to_list(c, inEncoding)); }, []); } function characters_to_binary(characters) { const values = characters_to_list(characters); return String.fromCodePoint(...values); } export default { characters_to_list, characters_to_binary, }; elixirscript-0.31.1/src/javascript/lib/core/functions.js000066400000000000000000000117521316305330500233230ustar00rootroot00000000000000import GraphemeSplitter from 'grapheme-splitter'; import Protocol from './protocol'; import Core from '../core'; import proplists from './erlang_compat/proplists'; import erlang from './erlang_compat/erlang'; function call_property(item, property) { if (!property) { if (item instanceof Function || typeof item === 'function') { return item(); } return item; } if (item instanceof Map) { let prop = null; if (item.has(property)) { prop = property; } else if (item.has(Symbol.for(property))) { prop = Symbol.for(property); } if (prop === null) { throw new Error(`Property ${property} not found in ${item}`); } return item.get(prop); } let prop = null; if ( typeof item === 'number' || typeof item === 'symbol' || typeof item === 'boolean' || typeof item === 'string' ) { if (item[property] !== undefined) { prop = property; } else if (item[Symbol.for(property)] !== undefined) { prop = Symbol.for(property); } } else if (property in item) { prop = property; } else if (Symbol.for(property) in item) { prop = Symbol.for(property); } if (prop === null) { throw new Error(`Property ${property} not found in ${item}`); } if (item[prop] instanceof Function || typeof item[prop] === 'function') { return item[prop](); } return item[prop]; } function defprotocol(spec) { return new Protocol(spec); } function defimpl(protocol, type, impl) { protocol.implementation(type, impl); } function build_namespace(ns, ns_string) { let parts = ns_string.split('.'); const root = ns; let parent = ns; if (parts[0] === 'Elixir') { parts = parts.slice(1); } for (const part of parts) { if (typeof parent[part] === 'undefined') { parent[part] = {}; } parent = parent[part]; } root.__table__ = ns.__table__ || {}; root.__table__[Symbol.for(ns_string)] = parent; return parent; } function map_to_object(map, options = []) { const opt_keys = proplists.get_value(Symbol.for('keys'), options); const opt_symbols = proplists.get_value(Symbol.for('symbols'), options); const object = {}; for (const entry of map.entries()) { let key = entry[0]; const value = entry[1]; if (opt_keys === Symbol.for('string') && typeof key === 'number') { key = key.toString(); } else if ( (opt_keys === Symbol.for('string') || opt_symbols !== Symbol.for('undefined')) && typeof key === 'symbol' ) { key = erlang.atom_to_binary(key); } if (value instanceof Map) { object[key] = map_to_object(value, options); } else if (opt_symbols !== Symbol.for('undefined') && typeof value === 'symbol') { object[key] = erlang.atom_to_binary(value); } else { object[key] = value; } } return object; } function object_to_map(object, options = []) { const opt_atom_keys = proplists.get_value(Symbol.for('keys'), options) === Symbol.for('atom'); const opt_recurse_array = proplists.get_value(Symbol.for('recurse_array'), options) === true; if (object.constructor === Object) { const map = new Map(); Reflect.ownKeys(object).forEach((key) => { let key2 = key; let value = object[key]; if (opt_atom_keys && typeof key === 'string') { key2 = Symbol.for(key); } if (value !== null && (value.constructor === Object || (value instanceof Array && opt_recurse_array))) { value = object_to_map(value, options); } map.set(key2, value); }); return map; } else if (object instanceof Array && opt_recurse_array) { return object.map((ele) => { if (ele !== null && (ele.constructor === Object || ele instanceof Array)) { return object_to_map(ele, options); } return ele; }); } throw new Error(`Object ${object} is not an native object or array`); } class Recurse { constructor(func) { this.func = func; } } function trampoline(f) { let currentValue = f; while (currentValue && currentValue instanceof Recurse) { currentValue = currentValue.func(); } return currentValue; } function split_at(value, position) { const splitter = new GraphemeSplitter(); const splitValues = splitter.splitGraphemes(value); if (position < 0) { const newPosition = splitValues.length + position; if (newPosition < 0) { return new Core.Tuple('', value); } return split_at(value, newPosition); } let first = ''; let second = ''; let index = 0; for (const character of splitValues) { if (index < position) { first += character; } else { second += character; } index += 1; } return new Core.Tuple(first, second); } function graphemes(str) { const splitter = new GraphemeSplitter(); return splitter.splitGraphemes(str); } function concat(head, tail) { return [head].concat(tail); } export default { call_property, defprotocol, defimpl, build_namespace, map_to_object, object_to_map, trampoline, Recurse, split_at, graphemes, concat, }; elixirscript-0.31.1/src/javascript/lib/core/protocol.js000066400000000000000000000043541316305330500231540ustar00rootroot00000000000000import Core from '../core'; // https://github.com/airportyh/protomorphism class Protocol { constructor(spec) { this.registry = new Map(); this.fallback = null; function createFun(funName) { return function (...args) { const thing = args[0]; let fun = null; if (thing === null && this.hasImplementation(Symbol('null'))) { fun = this.registry.get(Symbol)[funName]; } else if (Number.isInteger(thing) && this.hasImplementation(Core.Integer)) { fun = this.registry.get(Core.Integer)[funName]; } else if ( typeof thing === 'number' && !Number.isInteger(thing) && this.hasImplementation(Core.Float) ) { fun = this.registry.get(Core.Float)[funName]; } else if (typeof thing === 'string' && this.hasImplementation(Core.BitString)) { fun = this.registry.get(Core.BitString)[funName]; } else if ( thing && thing instanceof Map && thing.has(Symbol.for('__struct__')) && this.hasImplementation(thing) ) { fun = this.registry.get(thing.get(Symbol.for('__struct__')).__MODULE__)[funName]; } else if (thing !== null && this.hasImplementation(thing)) { fun = this.registry.get(thing.constructor)[funName]; } else if (this.fallback) { fun = this.fallback[funName]; } if (fun != null) { const retval = fun.apply(this, args); return retval; } throw new Error(`No implementation found for ${thing}`); }; } for (const funName in spec) { this[funName] = createFun(funName).bind(this); } } implementation(type, implementation) { if (type === null) { this.fallback = implementation; } else { this.registry.set(type, implementation); } } hasImplementation(thing) { if (thing === Core.Integer || thing === Core.Float || thing === Core.BitString) { return this.registry.has(thing); } else if (thing && thing instanceof Map && thing.has(Symbol.for('__struct__'))) { return this.registry.has(thing.get(Symbol.for('__struct__')).__MODULE__); } return this.registry.has(thing.constructor); } } export default Protocol; elixirscript-0.31.1/src/javascript/lib/core/special_forms.js000066400000000000000000000067411316305330500241430ustar00rootroot00000000000000import Core from '../core'; function _case(condition, clauses) { return Core.Patterns.defmatch(...clauses)(condition); } function cond(...clauses) { for (const clause of clauses) { if (clause[0]) { return clause[1](); } } throw new Error(); } function run_list_generators(generator, generators) { if (generators.length === 0) { return generator.map((x) => { if (Array.isArray(x)) { return x; } return [x]; }); } const list = generators.pop(); const next_gen = []; for (const j of list()) { for (const i of generator) { next_gen.push([j].concat(i)); } } return run_list_generators(next_gen, generators); } function _for(expression, generators, collectable_protocol, into = []) { const [result, fun] = collectable_protocol.into(into); let accumulatingResult = result; const generatedValues = run_list_generators(generators.pop()(), generators); for (const value of generatedValues) { if (expression.guard.apply(this, value)) { accumulatingResult = fun( accumulatingResult, new Core.Tuple(Symbol.for('cont'), expression.fn.apply(this, value)), ); } } return fun(accumulatingResult, Symbol.for('done')); } function _try(do_fun, rescue_function, catch_fun, else_function, after_function) { let result = null; try { result = do_fun(); } catch (e) { let ex_result = null; if (rescue_function) { try { ex_result = rescue_function(e); return ex_result; } catch (ex) { if (ex instanceof Core.Patterns.MatchError) { throw ex; } } } if (catch_fun) { try { ex_result = catch_fun(e); return ex_result; } catch (ex) { if (ex instanceof Core.Patterns.MatchError) { throw ex; } } } throw e; } finally { if (after_function) { after_function(); } } if (else_function) { try { return else_function(result); } catch (ex) { if (ex instanceof Core.Patterns.MatchError) { throw new Error('No Match Found in Else'); } throw ex; } } else { return result; } } function _with(...args) { let argsToPass = []; let successFunction = null; let elseFunction = null; if (typeof args[args.length - 2] === 'function') { [successFunction, elseFunction] = args.splice(-2); } else { successFunction = args.pop(); } for (let i = 0; i < args.length; i++) { const [pattern, func] = args[i]; const result = func(...argsToPass); const patternResult = Core.Patterns.match_or_default(pattern, result); if (patternResult == null) { if (elseFunction) { return elseFunction.call(null, result); } return result; } argsToPass = argsToPass.concat(patternResult); } return successFunction(...argsToPass); } function receive(clauses, timeout = 0, timeoutFn = () => true) { console.warn('Receive not supported'); const messages = []; // this.mailbox.get(); const NOMATCH = Symbol('NOMATCH'); for (let i = 0; i < messages.length; i++) { for (const clause of clauses) { const value = Core.Patterns.match_or_default( clause.pattern, messages[i], clause.guard, NOMATCH, ); if (value !== NOMATCH) { this.mailbox.removeAt(i); return clause.fn.apply(null, value); } } } return null; } export default { _case, cond, _for, _try, _with, receive, }; elixirscript-0.31.1/src/javascript/lib/core/store.js000066400000000000000000000017141316305330500224440ustar00rootroot00000000000000import Core from '../core'; function get_key(key) { let real_key = key; if (Core.global.__elixirscript_names__.has(key)) { real_key = Core.global.__elixirscript_names__.get(key); } if (Core.global.__elixirscript_store__.has(real_key)) { return real_key; } throw new Error(`Key ${real_key} not found`); } function create(value, name = null) { const key = new Core.PID(); if (name !== null) { Core.global.__elixirscript_names__.set(name, key); } return Core.global.__elixirscript_store__.set(key, value); } function update(key, value) { const real_key = get_key(key); return Core.global.__elixirscript_store__.set(real_key, value); } function read(key) { const real_key = get_key(key); return Core.global.__elixirscript_store__.get(real_key); } function remove(key) { const real_key = get_key(key); return Core.global.__elixirscript_store__.delete(real_key); } export default { create, update, read, remove, }; elixirscript-0.31.1/src/javascript/tests/000077500000000000000000000000001316305330500204135ustar00rootroot00000000000000elixirscript-0.31.1/src/javascript/tests/case.spec.js000066400000000000000000000010121316305330500226070ustar00rootroot00000000000000import test from 'ava'; import Core from '../lib/core'; const Patterns = Core.Patterns; const SpecialForms = Core.SpecialForms; const Tuple = Core.Tuple; test('case', (t) => { const clauses = [ Patterns.clause( [new Tuple(Symbol.for('selector'), Patterns.variable(), Patterns.variable())], (i, value) => value, i => Kernel.is_integer(i), ), Patterns.clause([Patterns.variable()], value => value), ]; const result = SpecialForms._case('thing', clauses); t.is(result, 'thing'); }); elixirscript-0.31.1/src/javascript/tests/cond.spec.js000066400000000000000000000005321316305330500226250ustar00rootroot00000000000000import test from 'ava'; import Core from '../lib/core'; const SpecialForms = Core.SpecialForms; test('cond', (t) => { const clauses = [ [1 + 1 === 1, () => 'This will never match'], [2 * 2 !== 4, () => 'Nor this'], [true, () => 'This will'], ]; const result = SpecialForms.cond(...clauses); t.is(result, 'This will'); }); elixirscript-0.31.1/src/javascript/tests/core/000077500000000000000000000000001316305330500213435ustar00rootroot00000000000000elixirscript-0.31.1/src/javascript/tests/core/erlang_compat/000077500000000000000000000000001316305330500241565ustar00rootroot00000000000000elixirscript-0.31.1/src/javascript/tests/core/erlang_compat/binary_spec.js000066400000000000000000000030021316305330500270050ustar00rootroot00000000000000import test from 'ava'; import Core from '../../../lib/core'; test('at/1', (t) => { const result = Core.binary.at('abc', 0); t.deepEqual(result, 'a'); }); test('copy/1', (t) => { const result = Core.binary.copy('h'); t.deepEqual(result, 'h'); }); test('copy/2', (t) => { const result = Core.binary.copy('h', 3); t.deepEqual(result, 'hhh'); }); test('first/1', (t) => { const result = Core.binary.first('abc'); t.deepEqual(result, 'a'); }); test('last/1', (t) => { const result = Core.binary.last('abc'); t.deepEqual(result, 'c'); }); test('list_to_bin/1', (t) => { const result = Core.binary.list_to_bin([104, 101, 108, 108, 111]); t.deepEqual(result, 'hello'); }); test('part/2', (t) => { let posLen = new Core.Tuple(1, 1); let result = Core.binary.part('abcde', posLen); t.deepEqual(result, 'b'); posLen = new Core.Tuple(1, 3); result = Core.binary.part('abcde', posLen); t.deepEqual(result, 'bcd'); }); test('part/3', (t) => { let result = Core.binary.part('abcde', 1, 1); t.deepEqual(result, 'b'); result = Core.binary.part('abcde', 1, 3); t.deepEqual(result, 'bcd'); }); test('replace/3', (t) => { const result = Core.binary.replace('abcb', 'b', 'c'); t.deepEqual(result, 'accb'); }); test('replace/4', (t) => { const result = Core.binary.replace('abcb', 'b', 'c', [ new Core.Tuple(Symbol.for('global'), true), ]); t.deepEqual(result, 'accc'); }); test('split/2', (t) => { const result = Core.binary.split('abcd', 'b'); t.deepEqual(result, ['a', 'cd']); }); elixirscript-0.31.1/src/javascript/tests/core/erlang_compat/elixir_errors_spec.js000066400000000000000000000003031316305330500304120ustar00rootroot00000000000000import test from 'ava'; import Core from '../../../lib/core'; test('warn', (t) => { const result = Core.elixir_errors.warn(['this is a warning']); t.deepEqual(result, Symbol.for('ok')); }); elixirscript-0.31.1/src/javascript/tests/core/erlang_compat/erlang_spec.js000066400000000000000000000122551316305330500270030ustar00rootroot00000000000000import test from 'ava'; import Core from '../../../lib/core'; test('is_atom', (t) => { t.is(Core.erlang.is_atom(null), true); t.is(Core.erlang.is_atom(true), true); t.is(Core.erlang.is_atom(false), true); t.is(Core.erlang.is_atom(Symbol.for('error')), true); t.is(Core.erlang.is_atom('Hello'), false); }); test('is_boolean', (t) => { t.is(Core.erlang.is_boolean(null), false); t.is(Core.erlang.is_boolean(true), true); t.is(Core.erlang.is_boolean(false), true); t.is(Core.erlang.is_boolean(Symbol.for('error')), false); t.is(Core.erlang.is_boolean('Hello'), false); }); test('is_number', (t) => { t.is(Core.erlang.is_number(null), false); t.is(Core.erlang.is_number(1), true); t.is(Core.erlang.is_number(2.3), true); t.is(Core.erlang.is_number(Symbol.for('error')), false); t.is(Core.erlang.is_number('Hello'), false); }); test('is_float', (t) => { t.is(Core.erlang.is_float(null), false); t.is(Core.erlang.is_float(1), false); t.is(Core.erlang.is_float(2.3), true); t.is(Core.erlang.is_float(Symbol.for('error')), false); t.is(Core.erlang.is_float('Hello'), false); }); test('is_integer', (t) => { t.is(Core.erlang.is_integer(null), false); t.is(Core.erlang.is_integer(1), true); t.is(Core.erlang.is_integer(2.3), false); t.is(Core.erlang.is_integer(Symbol.for('error')), false); t.is(Core.erlang.is_integer('Hello'), false); }); test('is_function', (t) => { t.is(Core.erlang.is_function(null), false); t.is(Core.erlang.is_function(Math.max), true); t.is(Core.erlang.is_function(2.3), false); t.is(Core.erlang.is_function(Symbol.for('error')), false); t.is(Core.erlang.is_function(() => 'hello'), true); }); test('is_list', (t) => { t.is(Core.erlang.is_list(null), false); t.is(Core.erlang.is_list([]), true); t.is(Core.erlang.is_list(2.3), false); t.is(Core.erlang.is_list(Symbol.for('error')), false); t.is(Core.erlang.is_list(() => 'hello'), false); }); test('atom_to_binary', (t) => { t.is(Core.erlang.atom_to_binary(Symbol.for('error')), 'error'); t.is(Core.erlang.atom_to_binary(Symbol.for('error'), Symbol.for('utf8')), 'error'); t.is(Core.erlang.atom_to_binary(null, Symbol.for('utf8')), 'nil'); t.is(Core.erlang.atom_to_binary(true, Symbol.for('utf8')), 'true'); t.is(Core.erlang.atom_to_binary(false, Symbol.for('utf8')), 'false'); t.throws(() => Core.erlang.atom_to_binary(Symbol.for('error'), Symbol.for('utf16')), Error); }); test('list_concatenation', (t) => { t.deepEqual(Core.erlang.list_concatenation([], []), []); t.deepEqual(Core.erlang.list_concatenation([1], []), [1]); t.deepEqual(Core.erlang.list_concatenation([1, 2, 3], [4, 5, 6]), [1, 2, 3, 4, 5, 6]); }); test('list_subtraction', (t) => { t.deepEqual(Core.erlang.list_subtraction([], []), []); t.deepEqual(Core.erlang.list_subtraction([1], []), [1]); t.deepEqual(Core.erlang.list_subtraction([1, 2, 3], [4, 5, 6]), [1, 2, 3]); t.deepEqual(Core.erlang.list_subtraction([1, 2, 3], [1, 2, 3]), []); t.deepEqual(Core.erlang.list_subtraction([1, 2, 3], [1, 2]), [3]); }); test('node', (t) => { t.deepEqual(Core.erlang.node(), Symbol.for('nonode@nohost')); }); test('nodes/0', (t) => { t.deepEqual(Core.erlang.nodes(), []); }); test('nodes/1', (t) => { t.deepEqual(Core.erlang.nodes(Symbol.for('this')), [Symbol.for('nonode@nohost')]); t.deepEqual(Core.erlang.nodes([Symbol.for('this')]), [Symbol.for('nonode@nohost')]); t.deepEqual(Core.erlang.nodes([Symbol.for('connected')]), []); }); test('equals', (t) => { t.is(Core.erlang.equals(1, 1), true); t.is(Core.erlang.equals(1, 'a'), false); t.is(Core.erlang.equals('a', 'a'), true); t.is(Core.erlang.equals('a', 'b'), false); t.is(Core.erlang.equals(Symbol.for('this'), Symbol.for('this')), true); t.is(Core.erlang.equals([], []), true); t.is(Core.erlang.equals([1], []), false); t.is( Core.erlang.equals( new Map([[Symbol.for('nest1'), 'valuenest1']]), new Map([[Symbol.for('nest2'), 'valuenest2']]), ), false, ); t.is( Core.erlang.equals( new Map([[Symbol.for('nest1'), 'valuenest1']]), new Map([[Symbol.for('nest1'), 'valuenest1']]), ), true, ); t.is(Core.erlang.equals(new Core.Tuple('abc'), new Core.Tuple('abc')), true); t.is(Core.erlang.equals(new Core.Tuple('abc'), new Core.Tuple('abc', 's')), false); const pid = new Core.PID(); t.is(Core.erlang.equals(pid, pid), true); t.is(Core.erlang.equals(pid, new Core.PID()), false); const ref = new Core.Reference(); t.is(Core.erlang.equals(ref, ref), true); t.is(Core.erlang.equals(ref, new Core.Reference()), false); }); test('error/1', (t) => { let error = t.throws(() => { Core.erlang.error( new Map([ [Symbol.for('__exception__'), true], [Symbol.for('message'), 'hi'], [ Symbol.for('__struct__'), { __MODULE__: Symbol.for('Elixir.ArgumentError'), }, ], ]), ); }, Error); t.is(error.message, '** (ArgumentError) hi'); error = t.throws(() => { Core.erlang.error('hi'); }, Error); t.is(error.message, '** (RuntimeError) hi'); error = t.throws(() => { Core.erlang.error(new Core.Tuple('abc', 's')); }, Error); t.is(error.message, '** (ErlangError) Erlang Error {abc, s}'); }); elixirscript-0.31.1/src/javascript/tests/core/erlang_compat/io_spec.js000066400000000000000000000004561316305330500261420ustar00rootroot00000000000000import test from 'ava'; import Core from '../../../lib/core'; test('put_chars', (t) => { let result = Core.io.put_chars(Symbol.for('stdio'), 'Hello'); t.deepEqual(result, Symbol.for('ok')); result = Core.io.put_chars(Symbol.for('stderr'), 'Hello'); t.deepEqual(result, Symbol.for('ok')); }); elixirscript-0.31.1/src/javascript/tests/core/erlang_compat/lists_spec.js000066400000000000000000000021221316305330500266610ustar00rootroot00000000000000import test from 'ava'; import Core from '../../../lib/core'; test('reverse', (t) => { t.deepEqual(Core.lists.reverse([1, 2, 3]), [3, 2, 1]); }); test('duplicate', (t) => { t.deepEqual(Core.lists.duplicate(0, 1), []); t.deepEqual(Core.lists.duplicate(1, 1), [1]); t.deepEqual(Core.lists.duplicate(2, 1), [1, 1]); }); test('flatten', (t) => { t.deepEqual(Core.lists.flatten([1, 2, 3]), [1, 2, 3]); t.deepEqual(Core.lists.flatten([1, [[2], 3]]), [1, 2, 3]); }); test('foldl', (t) => { t.deepEqual(Core.lists.foldl((v, acc) => acc + v, 0, [1, 2, 3]), 6); }); test('foldr', (t) => { t.deepEqual(Core.lists.foldr((v, acc) => acc + v.toString(), '', [1, 2, 3]), '321'); }); test('member/2', (t) => { let result = Core.lists.member('abc', ['abc']); t.deepEqual(result, true); result = Core.lists.member('abc', ['abcd']); t.deepEqual(result, false); }); test('keyfind/3', (t) => { let result = Core.lists.keyfind('abc', 1, ['abc']); t.deepEqual(result, false); result = Core.lists.keyfind('abc', 1, [new Core.Tuple('abc')]); t.deepEqual(result, new Core.Tuple('abc')); }); elixirscript-0.31.1/src/javascript/tests/core/erlang_compat/maps_spec.js000066400000000000000000000042461316305330500264740ustar00rootroot00000000000000import test from 'ava'; import Core from '../../../lib/core'; test('find', (t) => { let myMap = new Map(); let result = Core.maps.find('t', myMap); t.is(result, Symbol.for('error')); myMap = 'Hello'; result = Core.maps.find('t', myMap); t.deepEqual(result.values, [Symbol.for('badmap'), myMap]); myMap = new Map([['t', 'b']]); result = Core.maps.find('t', myMap); t.deepEqual(result.values, [Symbol.for('ok'), 'b']); myMap = new Map([[[1], 'b']]); result = Core.maps.find([1], myMap); t.deepEqual(result.values, [Symbol.for('ok'), 'b']); myMap = new Map([[new Map(), 'b']]); result = Core.maps.find(new Map(), myMap); t.deepEqual(result.values, [Symbol.for('ok'), 'b']); }); test('fold', (t) => { const myMap = new Map([['a', 1], ['b', 2]]); const result = Core.maps.fold((k, v, acc) => acc + v, 0, myMap); t.is(result, 3); }); test('is_key', (t) => { const myMap = new Map([['a', 1], ['b', 2]]); let result = Core.maps.is_key('a', myMap); t.is(result, true); result = Core.maps.is_key('c', myMap); t.is(result, false); }); test('get/2', (t) => { const myMap = new Map([['a', 1], ['b', 2]]); const result = Core.maps.get('a', myMap); t.is(result, 1); }); test('get/3', (t) => { let myMap = new Map([['a', 1], ['b', 2]]); let result = Core.maps.get('a', myMap); t.is(result, 1); myMap = new Map([['a', 1], ['b', 2]]); result = Core.maps.get('c', myMap, 'undefined'); t.is(result, 'undefined'); }); test('put/3', (t) => { const keyMap = new Map([['a', 5]]); let myMap = new Map([]); myMap = Core.maps.put(keyMap, 5, myMap); myMap = Core.maps.put(new Map([['a', 5]]), 6, myMap); const result = Core.maps.get(new Map([['a', 5]]), myMap); t.is(result, 6); }); test('take/2', (t) => { const myMap = new Map([['a', 1], ['b', 2]]); let a; let result; [a, result] = Core.maps.take('a', myMap); t.is(a, 1); t.is(result.has('a'), false); }); test('remove', (t) => { let myMap = new Map([['a', 1], ['b', 2]]); let result = Core.maps.remove('a', myMap); t.is(result.has('a'), false); myMap = new Map([[[1], 1], ['b', 2]]); result = Core.maps.remove([1], myMap); t.is(Core.maps.__has(result, [1]), false); }); elixirscript-0.31.1/src/javascript/tests/core/erlang_compat/math_spec.js000066400000000000000000000003641316305330500264620ustar00rootroot00000000000000import test from 'ava'; import Core from '../../../lib/core'; test('log2/1', (t) => { let result = Core.math.log2(1); t.is(result, 0); result = Core.math.log2(2); t.is(result, 1); result = Core.math.log2(4); t.is(result, 2); }); elixirscript-0.31.1/src/javascript/tests/core/erlang_compat/proplists_spec.js000066400000000000000000000013741316305330500275720ustar00rootroot00000000000000import test from 'ava'; import Core from '../../../lib/core'; test('get_value/2', (t) => { let result = Core.proplists.get_value('abc', [new Core.Tuple('abc', '123')]); t.deepEqual(result, '123'); result = Core.proplists.get_value('abc', ['abc']); t.deepEqual(result, true); result = Core.proplists.get_value('abcd', ['abc']); t.deepEqual(result, Symbol.for('undefined')); }); test('get_value/3', (t) => { let result = Core.proplists.get_value('abc', [new Core.Tuple('abc', '123')], 'xyz'); t.deepEqual(result, '123'); result = Core.proplists.get_value('abcd', [new Core.Tuple('abc', '123')], 'xyz'); t.deepEqual(result, 'xyz'); }); test('is_defined/2', (t) => { const result = Core.binary.at('abc', 0); t.deepEqual(result, 'a'); }); elixirscript-0.31.1/src/javascript/tests/core/erlang_compat/unicode_spec.js000066400000000000000000000020321316305330500271510ustar00rootroot00000000000000import test from 'ava'; import Core from '../../../lib/core'; test('characters_to_list', (t) => { let result = Core.unicode.characters_to_list('hello'); t.deepEqual(result, [104, 101, 108, 108, 111]); result = Core.unicode.characters_to_list(['hello', 'fg']); t.deepEqual(result, [104, 101, 108, 108, 111, 102, 103]); result = Core.unicode.characters_to_list(['hello', 'fg', 34]); t.deepEqual(result, [104, 101, 108, 108, 111, 102, 103, 34]); result = Core.unicode.characters_to_list(['hello', 'fg', 34, ['s']]); t.deepEqual(result, [104, 101, 108, 108, 111, 102, 103, 34, 115]); }); test('characters_to_binary', (t) => { let result = Core.unicode.characters_to_binary('hello'); t.deepEqual(result, 'hello'); result = Core.unicode.characters_to_binary(['hello', 'fg']); t.deepEqual(result, 'hellofg'); result = Core.unicode.characters_to_binary(['hello', 'fg', 34]); t.deepEqual(result, 'hellofg"'); result = Core.unicode.characters_to_binary(['hello', 'fg', 34, ['s']]); t.deepEqual(result, 'hellofg"s'); }); elixirscript-0.31.1/src/javascript/tests/core/functions.spec.js000066400000000000000000000060071316305330500246450ustar00rootroot00000000000000import test from 'ava'; import Core from '../../lib/core'; const Functions = Core.Functions; test('call_property', (t) => { t.is(Functions.call_property(1, 'toString'), '1'); t.is(Functions.call_property([], 'toString'), ''); t.is(Functions.call_property([], 'length'), 0); t.is(Functions.call_property('', 'toString'), ''); t.is(Functions.call_property('', 'length'), 0); t.is(Functions.call_property(Symbol('test'), 'toString'), 'Symbol(test)'); t.is(Functions.call_property({ completed: false }, 'completed'), false); t.is(Functions.call_property({ id: 0 }, 'id'), 0); }); test('split_at', (t) => { t.deepEqual(Functions.split_at('sweetelixir', 5).values, ['sweet', 'elixir']); t.deepEqual(Functions.split_at('sweetelixir', -6).values, ['sweet', 'elixir']); t.deepEqual(Functions.split_at('abc', 0).values, ['', 'abc']); t.deepEqual(Functions.split_at('abc', 1000).values, ['abc', '']); t.deepEqual(Functions.split_at('abc', -1000).values, ['', 'abc']); t.deepEqual(Functions.split_at('😀abélkm', 4).values, ['😀abé', 'lkm']); t.deepEqual(Functions.split_at('👨‍👩‍👦‍👦abélkm', 4).values, ['👨‍👩‍👦‍👦abé', 'lkm']); }); test('map_to_object/1', (t) => { const map = new Map([[Symbol.for('key'), 'value'], [Symbol.for('anotherKey'), 'value2']]); const result = Functions.map_to_object(map); const obj = {}; obj[Symbol.for('key')] = 'value'; obj[Symbol.for('anotherKey')] = 'value2'; t.deepEqual(result, obj); }); test('map_to_object/2', (t) => { const map = new Map([[Symbol.for('key'), 'value'], [Symbol.for('anotherKey'), 'value2']]); const options = [new Core.Tuple(Symbol.for('keys'), Symbol.for('string'))]; const result = Functions.map_to_object(map, options); t.deepEqual(result, { key: 'value', anotherKey: 'value2' }); }); test('object_to_map/1', (t) => { let obj = {}; let result = Functions.object_to_map(obj); t.deepEqual(result, new Map()); obj = { key: 'value', key2: null }; result = Functions.object_to_map(obj); t.deepEqual(result, new Map([['key', 'value'], ['key2', null]])); obj = {}; obj[Symbol.for('key')] = 'value'; result = Functions.object_to_map(obj); t.deepEqual(result, new Map([[Symbol.for('key'), 'value']])); }); test('object_to_map/2', (t) => { let obj = {}; let result = Functions.object_to_map(obj, []); t.deepEqual(result, new Map()); obj = { key: 'value' }; result = Functions.object_to_map(obj, [new Core.Tuple(Symbol.for('keys'), Symbol.for('atom'))]); t.deepEqual(result, new Map([[Symbol.for('key'), 'value']])); obj = {}; obj[Symbol.for('key')] = [{ nest1: 'valuenest1' }, { nest2: 'valuenest2' }]; result = Functions.object_to_map(obj, [ new Core.Tuple(Symbol.for('keys'), Symbol.for('atom')), new Core.Tuple(Symbol.for('recurse_array'), true), ]); t.deepEqual( result, new Map([ [ Symbol.for('key'), [ new Map([[Symbol.for('nest1'), 'valuenest1']]), new Map([[Symbol.for('nest2'), 'valuenest2']]), ], ], ]), ); }); elixirscript-0.31.1/src/javascript/tests/for.spec.js000066400000000000000000000062041316305330500224720ustar00rootroot00000000000000import test from 'ava'; import Core from '../lib/core'; const Patterns = Core.Patterns; const SpecialForms = Core.SpecialForms; const Tuple = Core.Tuple; const BitString = Core.BitString; const $ = Patterns.variable(); const collectable = { into(original) { const fun = Patterns.defmatch( Patterns.clause( [ $, Patterns.type(Tuple, { values: [Symbol.for('cont'), Patterns.variable()], }), ], (list, x) => list.concat([x]), ), Patterns.clause([$, Symbol.for('done')], list => list), ); return new Tuple([], fun); }, }; test('simple for', (t) => { const gen = Patterns.list_generator($, [1, 2, 3, 4]); const result = SpecialForms._for(Patterns.clause([$], x => x * 2), [gen], collectable); t.deepEqual(result, [2, 4, 6, 8]); }); test('for with multiple generators', (t) => { // for x <- [1, 2], y <- [2, 3], do: x*y const gen = Patterns.list_generator($, [1, 2]); const gen2 = Patterns.list_generator($, [2, 3]); const result = SpecialForms._for( Patterns.clause([$, $], (x, y) => x * y), [gen, gen2], collectable, ); t.deepEqual(result, [2, 3, 4, 6]); }); test('for with filter', (t) => { // for n <- [1, 2, 3, 4, 5, 6], rem(n, 2) == 0, do: n const gen = Patterns.list_generator($, [1, 2, 3, 4, 5, 6]); const result = SpecialForms._for( Patterns.clause([$], x => x, x => x % 2 === 0), [gen], collectable, ); t.deepEqual(result, [2, 4, 6]); }); test('for with pattern matching', (t) => { // for {:user, name} <- [user: "john", admin: "john", user: "meg"], do // String.upcase(name) // end const gen = Patterns.list_generator( [Symbol.for('user'), $], [[Symbol.for('user'), 'john'], [Symbol.for('admin'), 'john'], [Symbol.for('user'), 'meg']], ); const result = SpecialForms._for( Patterns.clause([[Symbol.for('user'), $]], name => name.toUpperCase()), [gen], collectable, ); t.deepEqual(result, ['JOHN', 'MEG']); }); test('for with bitstring', (t) => { // for <> >>, do: {r, g, b} const gen = Patterns.bitstring_generator( Patterns.bitStringMatch( BitString.integer({ value: $ }), BitString.integer({ value: $ }), BitString.integer({ value: $ }), ), new BitString( BitString.integer(213), BitString.integer(45), BitString.integer(132), BitString.integer(64), BitString.integer(76), BitString.integer(32), BitString.integer(76), BitString.integer(0), BitString.integer(0), BitString.integer(234), BitString.integer(32), BitString.integer(15), ), ); const expression = Patterns.clause( [ Patterns.bitStringMatch( BitString.integer({ value: $ }), BitString.integer({ value: $ }), BitString.integer({ value: $ }), ), ], (r, g, b) => new Tuple(r, g, b), ); const result = SpecialForms._for(expression, [gen], collectable); t.deepEqual(result, [ new Tuple(213, 45, 132), new Tuple(64, 76, 32), new Tuple(76, 0, 0), new Tuple(234, 32, 15), ]); }); elixirscript-0.31.1/src/javascript/tests/try.spec.js000066400000000000000000000011751316305330500225240ustar00rootroot00000000000000import test from 'ava'; import Core from '../lib/core'; const Patterns = Core.Patterns; const SpecialForms = Core.SpecialForms; test('try', (t) => { /* try do 1 / x else y when y < 1 and y > -1 -> :small _ -> :large end */ const x = 1; const value = SpecialForms._try( () => 1 / x, null, null, Patterns.defmatch( Patterns.clause([Patterns.variable()], () => Symbol.for('small'), y => y < 1 && y > -1), Patterns.clause([Patterns.wildcard()], () => Symbol.for('large')), ), null, ); t.is(value, Symbol.for('large')); }); elixirscript-0.31.1/src/javascript/tests/with.spec.js000066400000000000000000000074131316305330500226620ustar00rootroot00000000000000import Core from '../lib/core'; import test from 'ava'; const Patterns = Core.Patterns; const SpecialForms = Core.SpecialForms; const Tuple = Core.Tuple; const MatchError = Core.Patterns.MatchError; const $ = Patterns.variable(); function map_fetch(map, key) { if (key in map) { return new Tuple(Symbol.for('ok'), map[key]); } return Symbol.for('error'); } test('with', (t) => { /* opts = %{width: 10, height: 15} with {:ok, width} <- Map.fetch(opts, :width), {:ok, height} <- Map.fetch(opts, :height), do: {:ok, width * height} {:ok, 150} */ const opts = { width: 10, height: 15 }; const value = SpecialForms._with( [new Tuple(Symbol.for('ok'), $), () => map_fetch(opts, 'width')], [new Tuple(Symbol.for('ok'), $), width => map_fetch(opts, 'height')], (width, height) => new Tuple(Symbol.for('ok'), width * height), ); t.deepEqual(value, new Tuple(Symbol.for('ok'), 150)); }); test('with without match', (t) => { /* opts = %{width: 10} with {:ok, width} <- Map.fetch(opts, :width), {:ok, height} <- Map.fetch(opts, :height), do: {:ok, width * height} :error */ const opts = { width: 10 }; const value = SpecialForms._with( [new Tuple(Symbol.for('ok'), $), () => map_fetch(opts, 'width')], [new Tuple(Symbol.for('ok'), $), () => map_fetch(opts, 'height')], (width, height) => new Tuple(Symbol.for('ok'), width * height), ); t.deepEqual(value, Symbol.for('error')); }); test('with bare expression', (t) => { /* opts = %{width: 10} with {:ok, width} <- Map.fetch(opts, :width), double_width = width * 2, {:ok, height} <- Map.fetch(opts, :height), do: {:ok, double_width * height} {:ok, 300} */ const opts = { width: 10, height: 15 }; const value = SpecialForms._with( [new Tuple(Symbol.for('ok'), $), () => map_fetch(opts, 'width')], [$, width => width * 2], [new Tuple(Symbol.for('ok'), $), () => map_fetch(opts, 'height')], (width, double_width, height) => new Tuple(Symbol.for('ok'), double_width * height), ); t.deepEqual(value, new Tuple(Symbol.for('ok'), 300)); }); test('with else', (t) => { /* opts = %{width: 10} with {:ok, width} <- Map.fetch(opts, :width), {:ok, height} <- Map.fetch(opts, :height) do {:ok, width * height} else :error -> {:error, :wrong_data} end {:error, :wrong_data} */ const opts = { width: 10 }; const value = SpecialForms._with( [new Tuple(Symbol.for('ok'), $), () => map_fetch(opts, 'width')], [new Tuple(Symbol.for('ok'), $), () => map_fetch(opts, 'height')], (width, height) => new Tuple(Symbol.for('ok'), width * height), Patterns.defmatch( Patterns.clause( [Symbol.for('error')], () => new Tuple(Symbol.for('error'), Symbol.for('wrong_data')), ), ), ); t.deepEqual(value, new Tuple(Symbol.for('error'), Symbol.for('wrong_data'))); }); test('with else that don`t match', (t) => { /* opts = %{width: 10} with {:ok, width} <- Map.fetch(opts, :width), {:ok, height} <- Map.fetch(opts, :height) do {:ok, width * height} else :fail -> {:error, :wrong_data} end {:error, :wrong_data} */ const opts = { width: 10 }; const withFunction = SpecialForms._with.bind( null, [new Tuple(Symbol.for('ok'), $), () => map_fetch(opts, 'width')], [new Tuple(Symbol.for('ok'), $), () => map_fetch(opts, 'height')], (width, height) => new Tuple(Symbol.for('ok'), width * height), Patterns.defmatch( Patterns.clause( [Symbol.for('fail')], () => new Tuple(Symbol.for('error'), Symbol.for('wrong_data')), ), ), ); t.throws(withFunction, MatchError); }); elixirscript-0.31.1/test/000077500000000000000000000000001316305330500152735ustar00rootroot00000000000000elixirscript-0.31.1/test/beam_test.exs000066400000000000000000000006151316305330500177610ustar00rootroot00000000000000defmodule ElixirScript.Beam.Test do use ExUnit.Case test "can get ast from beam" do assert {:ok, _} = ElixirScript.Beam.debug_info(Atom) end test "errors when not found" do assert {:error, _} = ElixirScript.Beam.debug_info(Some.Module) end test "can get ast from beam that is protocol" do assert {:ok, Enumerable, _} = ElixirScript.Beam.debug_info(Enumerable) end end elixirscript-0.31.1/test/cli_test.exs000066400000000000000000000015031316305330500176210ustar00rootroot00000000000000defmodule ElixirScript.CLI.Test do use ExUnit.Case import ExUnit.CaptureIO test "parse_args" do {_, args} = ElixirScript.CLI.parse_args(["Atom", "--output", "build"]) assert args == [output: "build"] end test "process help" do assert capture_io(fn -> ElixirScript.CLI.process(:help) end) =~ "usage: elixirscript [options]" end test "process version" do assert capture_io(fn -> ElixirScript.CLI.process(:version) end) =~ Mix.Project.config()[:version] end test "process unknown" do assert capture_io(fn -> ElixirScript.CLI.process({"", [unknown: ""]}) end) =~ "usage: elixirscript [options]" end test "process input" do assert capture_io(fn -> ElixirScript.CLI.process({["Atom"], []}) end) =~ "export default Elixir" end end elixirscript-0.31.1/test/compiler_test.exs000066400000000000000000000030251316305330500206650ustar00rootroot00000000000000defmodule ElixirScript.Compiler.Test do use ExUnit.Case test "Can compile one entry module" do result = ElixirScript.Compiler.compile(Version) assert is_binary(result) end test "Can compile multiple entry modules" do result = ElixirScript.Compiler.compile([Atom, String, Agent]) assert is_binary(result) end test "Output" do result = ElixirScript.Compiler.compile(Atom, []) assert result =~ "export default Elixir" end test "Output file with default name" do path = System.tmp_dir() ElixirScript.Compiler.compile(Atom, [output: path]) assert File.exists?(Path.join([path, "elixirscript.build.js"])) end test "Output file with custom name" do path = System.tmp_dir() path = Path.join([path, "myfile.js"]) ElixirScript.Compiler.compile(Atom, [output: path]) assert File.exists?(path) end test "compile file" do path = System.tmp_dir() path = Path.join([path, "myfile.js"]) input_path = Path.join([File.cwd!(), "test", "beam_test.exs"]) ElixirScript.Compiler.compile(input_path, [output: path]) assert File.exists?(path) assert String.contains?(File.read!(path), "Elixir.ElixirScript.Beam.Test") end test "compile wildcard" do path = System.tmp_dir() path = Path.join([path, "myfile.js"]) input_path = Path.join([File.cwd!(), "test", "*fi_test.exs"]) ElixirScript.Compiler.compile(input_path, [output: path]) assert File.exists?(path) assert String.contains?(File.read!(path), "Elixir.ElixirScript.FFI.Test") end end elixirscript-0.31.1/test/ffi_test.exs000066400000000000000000000006721316305330500176240ustar00rootroot00000000000000defmodule ElixirScript.FFI.Test do use ExUnit.Case defmodule MyTestModule do use ElixirScript.FFI defexternal my_test_function(arg1, arg2) end test "FFI module has __foreign_info__ attribute" do assert Keyword.has_key?(MyTestModule.__info__(:attributes), :__foreign_info__) end test "FFI module makes foreign function" do assert Keyword.has_key?(MyTestModule.__info__(:functions), :my_test_function) end end elixirscript-0.31.1/test/integration/000077500000000000000000000000001316305330500176165ustar00rootroot00000000000000elixirscript-0.31.1/test/integration/integration_test.exs000066400000000000000000000023331316305330500237220ustar00rootroot00000000000000defmodule ElixirScript.Integration.Test do use ExUnit.Case import Helpers test "Atom.to_string" do val = call_compiled_function Atom, :to_string, [:atom] assert val == "atom" end test "String interpolation with number" do val = call_compiled_function Integration, :test_string_interpolation, [] assert val == "5" end test "shorthand failure" do val = call_compiled_function Integration, :shorthand_failure, [] assert val == [ [:option, %{value: "test@hotmail.com"}, "test@hotmail.com"], [:option, %{value: "test2@hotmail.com"}, "test2@hotmail.com"] ] end test "map equals" do val = call_compiled_function Integration, :map_equals, [] assert val == true end test "multi-remote call" do val = call_compiled_function Integration, :multi_field_call, [] assert val == "5,000,000" end test "filter names in guards" do val = call_compiled_function Integration, :filter_names_in_guards, [] assert val == true end test "tuple_get" do val = call_compiled_function Integration, :tuple_get, [] assert val == 5 end test "multi_bind" do val = call_compiled_function Integration, :multi_bind, [] assert val == [1, 2, 3, 4, 5] end end elixirscript-0.31.1/test/passes/000077500000000000000000000000001316305330500165715ustar00rootroot00000000000000elixirscript-0.31.1/test/passes/translate/000077500000000000000000000000001316305330500205665ustar00rootroot00000000000000elixirscript-0.31.1/test/passes/translate/form_test.exs000066400000000000000000000132401316305330500233110ustar00rootroot00000000000000defmodule ElixirScript.Translate.Forms.Test do use ExUnit.Case alias ElixirScript.Translate.Form alias ElixirScript.Translate.Identifier alias ElixirScript.Translate.Helpers alias ESTree.Tools.Builder, as: J require StreamData import PropertyTest setup_all do {:ok, pid} = ElixirScript.State.start_link() state = %{ pid: pid, vars: %{} } [state: state] end property "integers, floats, binaries, and booleans translates to a literal JavaScript AST node", %{state: state} do check all value <- StreamData.one_of([ StreamData.integer(), StreamData.boolean(), StreamData.binary(), StreamData.uniform_float() ]) do {js_ast, _} = Form.compile(value, state) assert js_ast == J.literal(value) end end property "atom translates to Symbol.for call", %{state: state} do check all atom <- StreamData.unquoted_atom() do {js_ast, _} = Form.compile(atom, state) assert js_ast == J.call_expression( J.member_expression( J.identifier("Symbol"), J.identifier("for") ), [J.literal(atom)] ) end end property "tuple translates to new Tuple object", %{state: state} do check all tuple <- StreamData.tuple({StreamData.integer(), StreamData.binary()}) do {js_ast, _} = Form.compile(tuple, state) assert js_ast == J.new_expression( J.member_expression( J.member_expression( J.identifier("ElixirScript"), J.identifier("Core") ), J.identifier("Tuple") ), [J.literal(elem(tuple, 0)), J.literal(elem(tuple, 1))] ) end end property "list translates to a JavaScript Array", %{state: state} do check all list <- StreamData.list_of(StreamData.binary()) do {js_ast, _} = Form.compile(list, state) assert js_ast.type == "ArrayExpression" assert length(js_ast.elements) == length(list) Enum.zip(js_ast.elements, list) |> Enum.each(fn {ast, original} -> assert ast == J.literal(original) end) end end property "local function call translates to local JavaScript function call", %{state: state} do check all func <- StreamData.filter(StreamData.unquoted_atom(), fn(x) -> not(x in [:fn]) end), params <- StreamData.list_of(StreamData.binary()) do ast = {func, [], params} str_func = if func in ElixirScript.Translate.Identifier.js_reserved_words() do "__#{to_string(func)}__" else to_string(func) end {js_ast, _} = Form.compile(ast, state) assert js_ast.type == "CallExpression" assert length(js_ast.arguments) == length(params) assert js_ast.callee.type == "Identifier" assert js_ast.callee.name == str_func Enum.zip(js_ast.arguments, params) |> Enum.each(fn {ast, original} -> assert ast == J.literal(original) end) end end property "super function call translates to local JavaScript function call" do check all func <- StreamData.unquoted_atom(), params <- StreamData.list_of(StreamData.binary()) do ast = {:super, [], [{:def, func}] ++ params} state = %{function: {func, nil}, vars: %{}} str_func = if func in ElixirScript.Translate.Identifier.js_reserved_words() do "__#{to_string(func)}__" else to_string(func) end {js_ast, _} = Form.compile(ast, state) assert js_ast.type == "CallExpression" assert length(js_ast.arguments) == length(params) assert js_ast.callee.type == "Identifier" assert js_ast.callee.name == str_func Enum.zip(js_ast.arguments, params) |> Enum.each(fn {ast, original} -> assert ast == J.literal(original) end) end end test "module", %{state: state} do ast = IO {js_ast, _} = Form.compile(ast, state) assert js_ast == J.call_expression( Identifier.make_namespace_members(["Elixir", "IO", "__load"]), [J.identifier("Elixir")] ) end test "function returning an array" do ast = {:fn, [], [{:foo, [], [], [1, 2, 3]}]} state = %{function: {:something, nil}} {js_ast, _} = Form.compile(ast, state) return_statement = Enum.at(Enum.at(hd(js_ast.body.body).body.body, 1).consequent.body, 1) assert return_statement.argument == J.array_expression([ J.literal(1), J.literal(2), J.literal(3) ]) end test "calling field on field" do ast = {{:., [line: 16], [{{:., [line: 16], [{:map, [line: 16], nil}, :token_count]}, [line: 16], []}, :toLocaleString]}, [line: 16], []} state = %{function: {:something, nil}, vars: %{}} {js_ast, _} = Form.compile(ast, state) assert js_ast == Helpers.call( ElixirScript.Translate.Forms.JS.call_property(), [ Helpers.call( ElixirScript.Translate.Forms.JS.call_property(), [J.identifier("map"), J.literal("token_count")] ), J.literal("toLocaleString") ] ) end test "make sure counter used in guard", %{state: state} do state = Map.merge(state, %{anonymous_fn: false, function: {:filter_names_in_guards, nil}, in_guard: true, module: Integration, vars: %{"has__qmark__" => 0}}) ast = {{:., [], [:erlang, :==]}, [line: 29], [{:has?, [line: 29], nil}, 5]} {js_ast, _} = Form.compile(ast, state) assert hd(js_ast.arguments).name === "has__qmark__0" end test "multi bind", %{state: state} do ast = {:=, [line: 35], [[{:|, [line: 35], [{:a, [line: 35], nil}, {:_, [line: 35], nil}]}], {:=, [line: 35], [{:b, [line: 35], nil}, [1, 2, 3, 4, 5]]}]} {js_ast, _} = Form.compile(ast, state) assert length(js_ast) > 1 end end elixirscript-0.31.1/test/passes/translate/forms/000077500000000000000000000000001316305330500217145ustar00rootroot00000000000000elixirscript-0.31.1/test/passes/translate/forms/bitstring_test.exs000066400000000000000000000014011316305330500254750ustar00rootroot00000000000000defmodule ElixirScript.Translate.Forms.Bitstring.Test do use ExUnit.Case alias ElixirScript.Translate.Form alias ESTree.Tools.Builder, as: J setup_all do {:ok, pid} = ElixirScript.State.start_link() state = %{ pid: pid, vars: %{} } [state: state] end test "string interpolation", %{state: state} do ast = {:<<>>, [line: 5], [{:::, [], ["Hello, ", {:binary, [], []}]}, {:::, [line: 5], [{{:., [line: 5], [String.Chars, :to_string]}, [line: 5], [{:name, [line: 5], nil}]}, {:binary, [], []}]}]} {js_ast, _} = Form.compile(ast, state) assert js_ast.type == "BinaryExpression" assert js_ast.left == J.literal("Hello, ") assert js_ast.right.type == "CallExpression" end end elixirscript-0.31.1/test/passes/translate/forms/js_test.exs000066400000000000000000000055071316305330500241170ustar00rootroot00000000000000defmodule ElixirScript.Translate.Forms.JS.Test do use ExUnit.Case alias ElixirScript.Translate.{Form, Helpers} alias ESTree.Tools.Builder, as: J setup_all do {:ok, pid} = ElixirScript.State.start_link() state = %{ pid: pid, vars: %{} } [state: state] end test "debugger" do ast = {{:., [], [ElixirScript.JS, :debugger]}, [], []} state = %{function: {:each, nil}, module: Enum, vars: %{:_ => 0, "entry" => 0, "enumerable" => 0, "fun" => 0}} {js_ast, _} = Form.compile(ast, state) assert js_ast == J.debugger_statement() end test "this" do ast = {{:., [], [ElixirScript.JS, :this]}, [], []} state = %{function: {:each, nil}, module: Enum, vars: %{:_ => 0, "entry" => 0, "enumerable" => 0, "fun" => 0}} {js_ast, _} = Form.compile(ast, state) assert js_ast == J.this_expression() end test "new" do ast = {{:., [], [ElixirScript.JS, :new]}, [], [BLT, ["bacon", "lettuce", "tomato"]]} state = %{function: {:each, nil}, module: Enum, vars: %{:_ => 0, "entry" => 0, "enumerable" => 0, "fun" => 0}} {js_ast, _} = Form.compile(ast, state) assert js_ast == J.new_expression( J.identifier("BLT"), [ J.literal("bacon"), J.literal("lettuce"), J.literal("tomato") ] ) end test "throw" do ast = {{:., [], [ElixirScript.JS, :throw]}, [], [1]} state = %{function: {:each, nil}, module: Enum, vars: %{:_ => 0, "entry" => 0, "enumerable" => 0, "fun" => 0}} {js_ast, _} = Form.compile(ast, state) assert js_ast == J.throw_statement(J.literal(1)) end test "import" do ast = {{:., [], [ElixirScript.JS, :import]}, [], ["react"]} state = %{function: {:each, nil}, module: Enum, vars: %{:_ => 0, "entry" => 0, "enumerable" => 0, "fun" => 0}} {js_ast, _} = Form.compile(ast, state) assert js_ast == J.call_expression( J.identifier("import"), [J.literal("react")] ) end test "mutate/3" do ast = {{:., [], [ElixirScript.JS, :mutate]}, [], [{:entry, [], nil}, "a", 2]} state = %{function: {:each, nil}, module: Enum, vars: %{:_ => 0, "entry" => 0, "enumerable" => 0, "fun" => 0}} {js_ast, _} = Form.compile(ast, state) assert js_ast == J.assignment_expression( :=, J.member_expression( J.identifier("entry0"), J.literal("a"), true ), J.literal(2) ) end test "map_to_object/1" do ast = {{:., [], [ElixirScript.JS, :map_to_object]}, [], [{:entry, [], nil}]} state = %{function: {:each, nil}, module: Enum, vars: %{:_ => 0, "entry" => 0, "enumerable" => 0, "fun" => 0}} {js_ast, _} = Form.compile(ast, state) assert js_ast == J.call_expression( J.member_expression( Helpers.functions(), J.identifier("map_to_object") ), [ J.identifier("entry0") ] ) end end elixirscript-0.31.1/test/passes/translate/forms/map_test.exs000066400000000000000000000037511316305330500242570ustar00rootroot00000000000000defmodule ElixirScript.Translate.Forms.Map.Test do use ExUnit.Case alias ElixirScript.Translate.Form alias ESTree.Tools.Builder, as: J require StreamData import PropertyTest setup_all do {:ok, pid} = ElixirScript.State.start_link() state = %{ pid: pid } [state: state] end property "maps convert to Map objects", %{state: state} do check all tuple <- StreamData.tuple({ StreamData.one_of([ StreamData.integer(), StreamData.boolean(), StreamData.binary(), StreamData.uniform_float() ]), StreamData.binary() }) do properties = [tuple] ast = {:%{}, [], properties} {js_ast, _} = Form.compile(ast, state) assert js_ast == J.new_expression( J.identifier("Map"), [ J.array_expression([ J.array_expression([ J.literal(elem(tuple, 0)), J.literal(elem(tuple, 1)), ]) ]) ] ) end end property "maps update converts to new Map objects using old version", %{state: state} do check all key <- StreamData.binary(), old_value <- StreamData.integer(), new_value <- StreamData.integer() do properties = [{key, old_value}] map_ast = {:%{}, [], properties} new_values = [{key, new_value}] ast = {:%{}, [], [{:|, [], [map_ast, new_values]}]} map_js_ast = J.new_expression( J.identifier("Map"), [ J.array_expression([ J.array_expression([ J.literal(key), J.literal(old_value), ]) ]) ] ) {js_ast, _} = Form.compile(ast, state) assert js_ast == J.new_expression( J.identifier("Map"), [ J.array_expression( [J.spread_element(map_js_ast)] ++ [J.array_expression([ J.literal(key), J.literal(new_value) ])] ) ] ) end end end elixirscript-0.31.1/test/passes/translate/forms/receive_test.exs000066400000000000000000000010661316305330500251210ustar00rootroot00000000000000defmodule ElixirScript.Translate.Forms.Receive.Test do use ExUnit.Case alias ElixirScript.Translate.{Form, Helpers} alias ESTree.Tools.Builder, as: J test "receive translation" do clause = {:->, [line: 644], [[], [{:__block__, [], [1]}]]} ast = {:receive, [line: 644], [[do: [clause], after: nil]]} state = %{function: {:each, nil}, module: __MODULE__, anonymous_fn: false} {js_ast, _} = Form.compile(ast, state) assert js_ast.callee == J.member_expression( Helpers.special_forms(), J.identifier("receive") ) end end elixirscript-0.31.1/test/passes/translate/forms/remote_test.exs000066400000000000000000000006721316305330500247740ustar00rootroot00000000000000defmodule ElixirScript.Translate.Forms.Remote.Test do use ExUnit.Case alias ElixirScript.Translate.Form alias ESTree.Tools.Builder, as: J test "variable counter" do ast = {:., [line: 644], [{:fun, [line: 644], nil}]} state = %{function: {:each, nil}, module: Enum, vars: %{:_ => 0, "entry" => 0, "enumerable" => 0, "fun" => 0}} {js_ast, _} = Form.compile(ast, state) assert js_ast == J.identifier("fun0") end end elixirscript-0.31.1/test/support/000077500000000000000000000000001316305330500170075ustar00rootroot00000000000000elixirscript-0.31.1/test/support/helpers.ex000066400000000000000000000022221316305330500210050ustar00rootroot00000000000000defmodule Helpers do @moduledoc false def call_compiled_function(module, func, args \\ []) when is_list(args) do File.mkdir "tmp" filename = Macro.underscore(inspect(module) <> "_" <> to_string(func)) path = Path.join("tmp", filename <> ".mjs") ElixirScript.Compiler.compile(module, [output: path]) args_to_js = args |> Enum.map(&ElixirScript.TermConverter.encode/1) |> Enum.join(",") main = """ import Elixir, {ElixirScript} from './#{filename}.mjs' const mod = Elixir.#{inspect module}.__load(Elixir) const ret = mod.#{func}(#{args_to_js}) const jsonRet = JSON.stringify(ret, (name, value) => { if(typeof value === 'symbol') { value = `@@@${Symbol.keyFor(value)}` } if(value instanceof Map) { value = {__type__: "map", values: Array.from(value.entries())} } return value }) process.stdout.write(jsonRet) """ main_path = Path.join("tmp", filename <> ".main.mjs") File.write!(main_path, main) {out, _a} = System.cmd "node", ["-r", "@std/esm", main_path] out |> Poison.decode! |> ElixirScript.TermConverter.decode end end elixirscript-0.31.1/test/support/integration.ex000066400000000000000000000013441316305330500216720ustar00rootroot00000000000000defmodule Integration do @moduledoc false def test_string_interpolation do "#{5}" end def shorthand_failure do orders = [%{email: "test@hotmail.com"},%{email: "test2@hotmail.com"}] Enum.reduce(orders, [], &(&2 ++ [ [:option, %{value: &1.email}, &1.email] ])) end def map_equals do map1 = %{test: "map"} map2 = %{test: "map"} map1 == map2 end def multi_field_call do map = %{token_count: 5000000} map.token_count.toLocaleString() end def filter_names_in_guards do has? = 5 case 5 do _ when has? == 5 -> true end end def multi_bind do [a | _] = b = [1, 2, 3, 4, 5] end def tuple_get do map = %{{1} => 5} Map.get(map, {1}) end end elixirscript-0.31.1/test/support/term_converter.ex000066400000000000000000000025121316305330500224030ustar00rootroot00000000000000defmodule ElixirScript.TermConverter do def encode(nil), do: "null" def encode(term) when is_boolean(term) or is_number(term), do: to_string(term) def encode(term) when is_binary(term), do: "'#{term}'" def encode(term) when is_atom(term), do: "Symbol.for('#{to_string(term)}')" def encode(term) when is_list(term) do terms = term |> Enum.map(fn(x) -> encode(x) end) |> Enum.join(",") "[#{terms}]" end def encode(term) when is_map(term) do terms = term |> Enum.map(fn({key, term}) -> key = encode(key) term = encode(term) "[#{key}, #{term}]" end) |> Enum.join(",") "[#{terms}]" end def encode(term) when is_tuple(term) do terms = term |> Tuple.to_list |> Enum.map(fn(x) -> encode(x) end) |> Enum.join(",") "new ElixirScript.Core.Tuple(#{terms})" end def decode("@@@" <> term) do String.to_atom(term) end def decode(term) when is_binary(term) or is_boolean(term) or is_number(term) or is_nil(term) do term end def decode(term) when is_list(term) do Enum.map(term, &decode/1) end def decode(%{"length" => _, "terms" => terms}) do List.to_tuple(terms) end def decode(%{"__type__" => "map", "values" => values}) do Enum.map(values, fn [key, term] -> {decode(key), decode(term)} end) |> Enum.into(%{}) end end elixirscript-0.31.1/test/test_helper.exs000066400000000000000000000001251316305330500203300ustar00rootroot00000000000000exclude = if Node.alive?, do: [], else: [skip: true] ExUnit.start(exclude: exclude) elixirscript-0.31.1/yarn.lock000066400000000000000000004511701316305330500161470ustar00rootroot00000000000000# THIS IS AN AUTOGENERATED FILE. DO NOT EDIT THIS FILE DIRECTLY. # yarn lockfile v1 "@ava/babel-plugin-throws-helper@^2.0.0": version "2.0.0" resolved "https://registry.yarnpkg.com/@ava/babel-plugin-throws-helper/-/babel-plugin-throws-helper-2.0.0.tgz#2fc1fe3c211a71071a4eca7b8f7af5842cd1ae7c" "@ava/babel-preset-stage-4@^1.1.0": version "1.1.0" resolved "https://registry.yarnpkg.com/@ava/babel-preset-stage-4/-/babel-preset-stage-4-1.1.0.tgz#ae60be881a0babf7d35f52aba770d1f6194f76bd" dependencies: babel-plugin-check-es2015-constants "^6.8.0" babel-plugin-syntax-trailing-function-commas "^6.20.0" babel-plugin-transform-async-to-generator "^6.16.0" babel-plugin-transform-es2015-destructuring "^6.19.0" babel-plugin-transform-es2015-function-name "^6.9.0" babel-plugin-transform-es2015-modules-commonjs "^6.18.0" babel-plugin-transform-es2015-parameters "^6.21.0" babel-plugin-transform-es2015-spread "^6.8.0" babel-plugin-transform-es2015-sticky-regex "^6.8.0" babel-plugin-transform-es2015-unicode-regex "^6.11.0" babel-plugin-transform-exponentiation-operator "^6.8.0" package-hash "^1.2.0" "@ava/babel-preset-transform-test-files@^3.0.0": version "3.0.0" resolved "https://registry.yarnpkg.com/@ava/babel-preset-transform-test-files/-/babel-preset-transform-test-files-3.0.0.tgz#cded1196a8d8d9381a509240ab92e91a5ec069f7" dependencies: "@ava/babel-plugin-throws-helper" "^2.0.0" babel-plugin-espower "^2.3.2" "@ava/write-file-atomic@^2.2.0": version "2.2.0" resolved "https://registry.yarnpkg.com/@ava/write-file-atomic/-/write-file-atomic-2.2.0.tgz#d625046f3495f1f5e372135f473909684b429247" dependencies: graceful-fs "^4.1.11" imurmurhash "^0.1.4" slide "^1.1.5" "@comandeer/babel-plugin-banner@^1.0.0": version "1.0.0" resolved "https://registry.yarnpkg.com/@comandeer/babel-plugin-banner/-/babel-plugin-banner-1.0.0.tgz#40bcce0bbee084b5b02545a33635d053c248356f" "@concordance/react@^1.0.0": version "1.0.0" resolved "https://registry.yarnpkg.com/@concordance/react/-/react-1.0.0.tgz#fcf3cad020e5121bfd1c61d05bc3516aac25f734" dependencies: arrify "^1.0.1" "@std/esm@^0.8.3": version "0.8.3" resolved "https://registry.yarnpkg.com/@std/esm/-/esm-0.8.3.tgz#7a3c3144ca0905c9b92d82b79987503ecb58a193" abbrev@1: version "1.1.0" resolved "https://registry.yarnpkg.com/abbrev/-/abbrev-1.1.0.tgz#d0554c2256636e2f56e7c2e5ad183f859428d81f" acorn-jsx@^3.0.0: version "3.0.1" resolved "https://registry.yarnpkg.com/acorn-jsx/-/acorn-jsx-3.0.1.tgz#afdf9488fb1ecefc8348f6fb22f464e32a58b36b" dependencies: acorn "^3.0.4" acorn@^3.0.4: version "3.3.0" resolved "https://registry.yarnpkg.com/acorn/-/acorn-3.3.0.tgz#45e37fb39e8da3f25baee3ff5369e2bb5f22017a" acorn@^5.1.1: version "5.1.2" resolved "https://registry.yarnpkg.com/acorn/-/acorn-5.1.2.tgz#911cb53e036807cf0fa778dc5d370fbd864246d7" ajv-keywords@^1.0.0: version "1.5.1" resolved "https://registry.yarnpkg.com/ajv-keywords/-/ajv-keywords-1.5.1.tgz#314dd0a4b3368fad3dfcdc54ede6171b886daf3c" ajv@^4.7.0, ajv@^4.9.1: version "4.11.8" resolved "https://registry.yarnpkg.com/ajv/-/ajv-4.11.8.tgz#82ffb02b29e662ae53bdc20af15947706739c536" dependencies: co "^4.6.0" json-stable-stringify "^1.0.1" ajv@^5.2.0: version "5.2.2" resolved "https://registry.yarnpkg.com/ajv/-/ajv-5.2.2.tgz#47c68d69e86f5d953103b0074a9430dc63da5e39" dependencies: co "^4.6.0" fast-deep-equal "^1.0.0" json-schema-traverse "^0.3.0" json-stable-stringify "^1.0.1" align-text@^0.1.1, align-text@^0.1.3: version "0.1.4" resolved "https://registry.yarnpkg.com/align-text/-/align-text-0.1.4.tgz#0cd90a561093f35d0a99256c22b7069433fad117" dependencies: kind-of "^3.0.2" longest "^1.0.1" repeat-string "^1.5.2" amdefine@>=0.0.4: version "1.0.1" resolved "https://registry.yarnpkg.com/amdefine/-/amdefine-1.0.1.tgz#4a5282ac164729e93619bcfd3ad151f817ce91f5" ansi-align@^2.0.0: version "2.0.0" resolved "https://registry.yarnpkg.com/ansi-align/-/ansi-align-2.0.0.tgz#c36aeccba563b89ceb556f3690f0b1d9e3547f7f" dependencies: string-width "^2.0.0" ansi-escapes@^2.0.0: version "2.0.0" resolved "https://registry.yarnpkg.com/ansi-escapes/-/ansi-escapes-2.0.0.tgz#5bae52be424878dd9783e8910e3fc2922e83c81b" ansi-regex@^2.0.0: version "2.1.1" resolved "https://registry.yarnpkg.com/ansi-regex/-/ansi-regex-2.1.1.tgz#c3b33ab5ee360d86e0e628f0468ae7ef27d654df" ansi-regex@^3.0.0: version "3.0.0" resolved "https://registry.yarnpkg.com/ansi-regex/-/ansi-regex-3.0.0.tgz#ed0317c322064f79466c02966bddb605ab37d998" ansi-styles@^2.2.1: version "2.2.1" resolved "https://registry.yarnpkg.com/ansi-styles/-/ansi-styles-2.2.1.tgz#b432dd3358b634cf75e1e4664368240533c1ddbe" ansi-styles@^3.1.0: version "3.1.0" resolved "https://registry.yarnpkg.com/ansi-styles/-/ansi-styles-3.1.0.tgz#09c202d5c917ec23188caa5c9cb9179cd9547750" dependencies: color-convert "^1.0.0" ansi-styles@~1.0.0: version "1.0.0" resolved "https://registry.yarnpkg.com/ansi-styles/-/ansi-styles-1.0.0.tgz#cb102df1c56f5123eab8b67cd7b98027a0279178" anymatch@^1.3.0: version "1.3.0" resolved "https://registry.yarnpkg.com/anymatch/-/anymatch-1.3.0.tgz#a3e52fa39168c825ff57b0248126ce5a8ff95507" dependencies: arrify "^1.0.0" micromatch "^2.1.5" append-transform@^0.4.0: version "0.4.0" resolved "https://registry.yarnpkg.com/append-transform/-/append-transform-0.4.0.tgz#d76ebf8ca94d276e247a36bad44a4b74ab611991" dependencies: default-require-extensions "^1.0.0" aproba@^1.0.3: version "1.1.2" resolved "https://registry.yarnpkg.com/aproba/-/aproba-1.1.2.tgz#45c6629094de4e96f693ef7eab74ae079c240fc1" archy@^1.0.0: version "1.0.0" resolved "https://registry.yarnpkg.com/archy/-/archy-1.0.0.tgz#f9c8c13757cc1dd7bc379ac77b2c62a5c2868c40" are-we-there-yet@~1.1.2: version "1.1.4" resolved "https://registry.yarnpkg.com/are-we-there-yet/-/are-we-there-yet-1.1.4.tgz#bb5dca382bb94f05e15194373d16fd3ba1ca110d" dependencies: delegates "^1.0.0" readable-stream "^2.0.6" argparse@^1.0.7: version "1.0.9" resolved "https://registry.yarnpkg.com/argparse/-/argparse-1.0.9.tgz#73d83bc263f86e97f8cc4f6bae1b0e90a7d22c86" dependencies: sprintf-js "~1.0.2" arr-diff@^2.0.0: version "2.0.0" resolved "https://registry.yarnpkg.com/arr-diff/-/arr-diff-2.0.0.tgz#8f3b827f955a8bd669697e4a4256ac3ceae356cf" dependencies: arr-flatten "^1.0.1" arr-exclude@^1.0.0: version "1.0.0" resolved "https://registry.yarnpkg.com/arr-exclude/-/arr-exclude-1.0.0.tgz#dfc7c2e552a270723ccda04cf3128c8cbfe5c631" arr-flatten@^1.0.1: version "1.0.3" resolved "https://registry.yarnpkg.com/arr-flatten/-/arr-flatten-1.0.3.tgz#a274ed85ac08849b6bd7847c4580745dc51adfb1" array-differ@^1.0.0: version "1.0.0" resolved "https://registry.yarnpkg.com/array-differ/-/array-differ-1.0.0.tgz#eff52e3758249d33be402b8bb8e564bb2b5d4031" array-find-index@^1.0.1: version "1.0.2" resolved "https://registry.yarnpkg.com/array-find-index/-/array-find-index-1.0.2.tgz#df010aa1287e164bbda6f9723b0a96a1ec4187a1" array-union@^1.0.1: version "1.0.2" resolved "https://registry.yarnpkg.com/array-union/-/array-union-1.0.2.tgz#9a34410e4f4e3da23dea375be5be70f24778ec39" dependencies: array-uniq "^1.0.1" array-uniq@^1.0.1, array-uniq@^1.0.2: version "1.0.3" resolved "https://registry.yarnpkg.com/array-uniq/-/array-uniq-1.0.3.tgz#af6ac877a25cc7f74e058894753858dfdb24fdb6" array-unique@^0.2.1: version "0.2.1" resolved "https://registry.yarnpkg.com/array-unique/-/array-unique-0.2.1.tgz#a1d97ccafcbc2625cc70fadceb36a50c58b01a53" arrify@^1.0.0, arrify@^1.0.1: version "1.0.1" resolved "https://registry.yarnpkg.com/arrify/-/arrify-1.0.1.tgz#898508da2226f380df904728456849c1501a4b0d" asn1@~0.2.3: version "0.2.3" resolved "https://registry.yarnpkg.com/asn1/-/asn1-0.2.3.tgz#dac8787713c9966849fc8180777ebe9c1ddf3b86" assert-plus@1.0.0, assert-plus@^1.0.0: version "1.0.0" resolved "https://registry.yarnpkg.com/assert-plus/-/assert-plus-1.0.0.tgz#f12e0f3c5d77b0b1cdd9146942e4e96c1e4dd525" assert-plus@^0.2.0: version "0.2.0" resolved "https://registry.yarnpkg.com/assert-plus/-/assert-plus-0.2.0.tgz#d74e1b87e7affc0db8aadb7021f3fe48101ab234" async-each@^1.0.0: version "1.0.1" resolved "https://registry.yarnpkg.com/async-each/-/async-each-1.0.1.tgz#19d386a1d9edc6e7c1c85d388aedbcc56d33602d" async@^1.4.0: version "1.5.2" resolved "https://registry.yarnpkg.com/async/-/async-1.5.2.tgz#ec6a61ae56480c0c3cb241c95618e20892f9672a" asynckit@^0.4.0: version "0.4.0" resolved "https://registry.yarnpkg.com/asynckit/-/asynckit-0.4.0.tgz#c79ed97f7f34cb8f2ba1bc9790bcc366474b4b79" auto-bind@^1.1.0: version "1.1.0" resolved "https://registry.yarnpkg.com/auto-bind/-/auto-bind-1.1.0.tgz#93b864dc7ee01a326281775d5c75ca0a751e5961" ava-init@^0.2.0: version "0.2.0" resolved "https://registry.yarnpkg.com/ava-init/-/ava-init-0.2.0.tgz#9304c8b4c357d66e3dfdae1fbff47b1199d5c55d" dependencies: arr-exclude "^1.0.0" execa "^0.5.0" has-yarn "^1.0.0" read-pkg-up "^2.0.0" write-pkg "^2.0.0" ava@^0.22.0: version "0.22.0" resolved "https://registry.yarnpkg.com/ava/-/ava-0.22.0.tgz#4c28a1fdef7e749ba0c8131ac18a7ca489eef049" dependencies: "@ava/babel-preset-stage-4" "^1.1.0" "@ava/babel-preset-transform-test-files" "^3.0.0" "@ava/write-file-atomic" "^2.2.0" "@concordance/react" "^1.0.0" ansi-escapes "^2.0.0" ansi-styles "^3.1.0" arr-flatten "^1.0.1" array-union "^1.0.1" array-uniq "^1.0.2" arrify "^1.0.0" auto-bind "^1.1.0" ava-init "^0.2.0" babel-core "^6.17.0" bluebird "^3.0.0" caching-transform "^1.0.0" chalk "^2.0.1" chokidar "^1.4.2" clean-stack "^1.1.1" clean-yaml-object "^0.1.0" cli-cursor "^2.1.0" cli-spinners "^1.0.0" cli-truncate "^1.0.0" co-with-promise "^4.6.0" code-excerpt "^2.1.0" common-path-prefix "^1.0.0" concordance "^3.0.0" convert-source-map "^1.2.0" core-assert "^0.2.0" currently-unhandled "^0.4.1" debug "^2.2.0" dot-prop "^4.1.0" empower-core "^0.6.1" equal-length "^1.0.0" figures "^2.0.0" find-cache-dir "^1.0.0" fn-name "^2.0.0" get-port "^3.0.0" globby "^6.0.0" has-flag "^2.0.0" hullabaloo-config-manager "^1.1.0" ignore-by-default "^1.0.0" import-local "^0.1.1" indent-string "^3.0.0" is-ci "^1.0.7" is-generator-fn "^1.0.0" is-obj "^1.0.0" is-observable "^0.2.0" is-promise "^2.1.0" js-yaml "^3.8.2" last-line-stream "^1.0.0" lodash.clonedeepwith "^4.5.0" lodash.debounce "^4.0.3" lodash.difference "^4.3.0" lodash.flatten "^4.2.0" loud-rejection "^1.2.0" make-dir "^1.0.0" matcher "^1.0.0" md5-hex "^2.0.0" meow "^3.7.0" ms "^2.0.0" multimatch "^2.1.0" observable-to-promise "^0.5.0" option-chain "^1.0.0" package-hash "^2.0.0" pkg-conf "^2.0.0" plur "^2.0.0" pretty-ms "^2.0.0" require-precompiled "^0.1.0" resolve-cwd "^2.0.0" safe-buffer "^5.1.1" slash "^1.0.0" source-map-support "^0.4.0" stack-utils "^1.0.0" strip-ansi "^4.0.0" strip-bom-buf "^1.0.0" supports-color "^4.0.0" time-require "^0.1.2" trim-off-newlines "^1.0.1" unique-temp-dir "^1.0.0" update-notifier "^2.1.0" aws-sign2@~0.6.0: version "0.6.0" resolved "https://registry.yarnpkg.com/aws-sign2/-/aws-sign2-0.6.0.tgz#14342dd38dbcc94d0e5b87d763cd63612c0e794f" aws4@^1.2.1: version "1.6.0" resolved "https://registry.yarnpkg.com/aws4/-/aws4-1.6.0.tgz#83ef5ca860b2b32e4a0deedee8c771b9db57471e" babel-code-frame@^6.22.0: version "6.22.0" resolved "https://registry.yarnpkg.com/babel-code-frame/-/babel-code-frame-6.22.0.tgz#027620bee567a88c32561574e7fd0801d33118e4" dependencies: chalk "^1.1.0" esutils "^2.0.2" js-tokens "^3.0.0" babel-code-frame@^6.26.0: version "6.26.0" resolved "https://registry.yarnpkg.com/babel-code-frame/-/babel-code-frame-6.26.0.tgz#63fd43f7dc1e3bb7ce35947db8fe369a3f58c74b" dependencies: chalk "^1.1.3" esutils "^2.0.2" js-tokens "^3.0.2" babel-core@^6.17.0, babel-core@^6.21.0, babel-core@^6.24.1: version "6.25.0" resolved "https://registry.yarnpkg.com/babel-core/-/babel-core-6.25.0.tgz#7dd42b0463c742e9d5296deb3ec67a9322dad729" dependencies: babel-code-frame "^6.22.0" babel-generator "^6.25.0" babel-helpers "^6.24.1" babel-messages "^6.23.0" babel-register "^6.24.1" babel-runtime "^6.22.0" babel-template "^6.25.0" babel-traverse "^6.25.0" babel-types "^6.25.0" babylon "^6.17.2" convert-source-map "^1.1.0" debug "^2.1.1" json5 "^0.5.0" lodash "^4.2.0" minimatch "^3.0.2" path-is-absolute "^1.0.0" private "^0.1.6" slash "^1.0.0" source-map "^0.5.0" babel-core@^6.26.0: version "6.26.0" resolved "https://registry.yarnpkg.com/babel-core/-/babel-core-6.26.0.tgz#af32f78b31a6fcef119c87b0fd8d9753f03a0bb8" dependencies: babel-code-frame "^6.26.0" babel-generator "^6.26.0" babel-helpers "^6.24.1" babel-messages "^6.23.0" babel-register "^6.26.0" babel-runtime "^6.26.0" babel-template "^6.26.0" babel-traverse "^6.26.0" babel-types "^6.26.0" babylon "^6.18.0" convert-source-map "^1.5.0" debug "^2.6.8" json5 "^0.5.1" lodash "^4.17.4" minimatch "^3.0.4" path-is-absolute "^1.0.1" private "^0.1.7" slash "^1.0.0" source-map "^0.5.6" babel-generator@^6.1.0, babel-generator@^6.18.0, babel-generator@^6.25.0: version "6.25.0" resolved "https://registry.yarnpkg.com/babel-generator/-/babel-generator-6.25.0.tgz#33a1af70d5f2890aeb465a4a7793c1df6a9ea9fc" dependencies: babel-messages "^6.23.0" babel-runtime "^6.22.0" babel-types "^6.25.0" detect-indent "^4.0.0" jsesc "^1.3.0" lodash "^4.2.0" source-map "^0.5.0" trim-right "^1.0.1" babel-generator@^6.26.0: version "6.26.0" resolved "https://registry.yarnpkg.com/babel-generator/-/babel-generator-6.26.0.tgz#ac1ae20070b79f6e3ca1d3269613053774f20dc5" dependencies: babel-messages "^6.23.0" babel-runtime "^6.26.0" babel-types "^6.26.0" detect-indent "^4.0.0" jsesc "^1.3.0" lodash "^4.17.4" source-map "^0.5.6" trim-right "^1.0.1" babel-helper-builder-binary-assignment-operator-visitor@^6.24.1: version "6.24.1" resolved "https://registry.yarnpkg.com/babel-helper-builder-binary-assignment-operator-visitor/-/babel-helper-builder-binary-assignment-operator-visitor-6.24.1.tgz#cce4517ada356f4220bcae8a02c2b346f9a56664" dependencies: babel-helper-explode-assignable-expression "^6.24.1" babel-runtime "^6.22.0" babel-types "^6.24.1" babel-helper-call-delegate@^6.24.1: version "6.24.1" resolved "https://registry.yarnpkg.com/babel-helper-call-delegate/-/babel-helper-call-delegate-6.24.1.tgz#ece6aacddc76e41c3461f88bfc575bd0daa2df8d" dependencies: babel-helper-hoist-variables "^6.24.1" babel-runtime "^6.22.0" babel-traverse "^6.24.1" babel-types "^6.24.1" babel-helper-define-map@^6.24.1: version "6.24.1" resolved "https://registry.yarnpkg.com/babel-helper-define-map/-/babel-helper-define-map-6.24.1.tgz#7a9747f258d8947d32d515f6aa1c7bd02204a080" dependencies: babel-helper-function-name "^6.24.1" babel-runtime "^6.22.0" babel-types "^6.24.1" lodash "^4.2.0" babel-helper-evaluate-path@^0.2.0: version "0.2.0" resolved "https://registry.yarnpkg.com/babel-helper-evaluate-path/-/babel-helper-evaluate-path-0.2.0.tgz#0bb2eb01996c0cef53c5e8405e999fe4a0244c08" babel-helper-explode-assignable-expression@^6.24.1: version "6.24.1" resolved "https://registry.yarnpkg.com/babel-helper-explode-assignable-expression/-/babel-helper-explode-assignable-expression-6.24.1.tgz#f25b82cf7dc10433c55f70592d5746400ac22caa" dependencies: babel-runtime "^6.22.0" babel-traverse "^6.24.1" babel-types "^6.24.1" babel-helper-flip-expressions@^0.2.0: version "0.2.0" resolved "https://registry.yarnpkg.com/babel-helper-flip-expressions/-/babel-helper-flip-expressions-0.2.0.tgz#160d2090a3d9f9c64a750905321a0bc218f884ec" babel-helper-function-name@^6.24.1: version "6.24.1" resolved "https://registry.yarnpkg.com/babel-helper-function-name/-/babel-helper-function-name-6.24.1.tgz#d3475b8c03ed98242a25b48351ab18399d3580a9" dependencies: babel-helper-get-function-arity "^6.24.1" babel-runtime "^6.22.0" babel-template "^6.24.1" babel-traverse "^6.24.1" babel-types "^6.24.1" babel-helper-get-function-arity@^6.24.1: version "6.24.1" resolved "https://registry.yarnpkg.com/babel-helper-get-function-arity/-/babel-helper-get-function-arity-6.24.1.tgz#8f7782aa93407c41d3aa50908f89b031b1b6853d" dependencies: babel-runtime "^6.22.0" babel-types "^6.24.1" babel-helper-hoist-variables@^6.24.1: version "6.24.1" resolved "https://registry.yarnpkg.com/babel-helper-hoist-variables/-/babel-helper-hoist-variables-6.24.1.tgz#1ecb27689c9d25513eadbc9914a73f5408be7a76" dependencies: babel-runtime "^6.22.0" babel-types "^6.24.1" babel-helper-is-nodes-equiv@^0.0.1: version "0.0.1" resolved "https://registry.yarnpkg.com/babel-helper-is-nodes-equiv/-/babel-helper-is-nodes-equiv-0.0.1.tgz#34e9b300b1479ddd98ec77ea0bbe9342dfe39684" babel-helper-is-void-0@^0.2.0: version "0.2.0" resolved "https://registry.yarnpkg.com/babel-helper-is-void-0/-/babel-helper-is-void-0-0.2.0.tgz#6ed0ada8a9b1c5b6e88af6b47c1b3b5c080860eb" babel-helper-mark-eval-scopes@^0.2.0: version "0.2.0" resolved "https://registry.yarnpkg.com/babel-helper-mark-eval-scopes/-/babel-helper-mark-eval-scopes-0.2.0.tgz#7648aaf2ec92aae9b09a20ad91e8df5e1fcc94b2" babel-helper-optimise-call-expression@^6.24.1: version "6.24.1" resolved "https://registry.yarnpkg.com/babel-helper-optimise-call-expression/-/babel-helper-optimise-call-expression-6.24.1.tgz#f7a13427ba9f73f8f4fa993c54a97882d1244257" dependencies: babel-runtime "^6.22.0" babel-types "^6.24.1" babel-helper-regex@^6.24.1: version "6.24.1" resolved "https://registry.yarnpkg.com/babel-helper-regex/-/babel-helper-regex-6.24.1.tgz#d36e22fab1008d79d88648e32116868128456ce8" dependencies: babel-runtime "^6.22.0" babel-types "^6.24.1" lodash "^4.2.0" babel-helper-remap-async-to-generator@^6.24.1: version "6.24.1" resolved "https://registry.yarnpkg.com/babel-helper-remap-async-to-generator/-/babel-helper-remap-async-to-generator-6.24.1.tgz#5ec581827ad723fecdd381f1c928390676e4551b" dependencies: babel-helper-function-name "^6.24.1" babel-runtime "^6.22.0" babel-template "^6.24.1" babel-traverse "^6.24.1" babel-types "^6.24.1" babel-helper-remove-or-void@^0.2.0: version "0.2.0" resolved "https://registry.yarnpkg.com/babel-helper-remove-or-void/-/babel-helper-remove-or-void-0.2.0.tgz#8e46ad5b30560d57d7510b3fd93f332ee7c67386" babel-helper-replace-supers@^6.24.1: version "6.24.1" resolved "https://registry.yarnpkg.com/babel-helper-replace-supers/-/babel-helper-replace-supers-6.24.1.tgz#bf6dbfe43938d17369a213ca8a8bf74b6a90ab1a" dependencies: babel-helper-optimise-call-expression "^6.24.1" babel-messages "^6.23.0" babel-runtime "^6.22.0" babel-template "^6.24.1" babel-traverse "^6.24.1" babel-types "^6.24.1" babel-helper-to-multiple-sequence-expressions@^0.2.0: version "0.2.0" resolved "https://registry.yarnpkg.com/babel-helper-to-multiple-sequence-expressions/-/babel-helper-to-multiple-sequence-expressions-0.2.0.tgz#d1a419634c6cb301f27858c659167cfee0a9d318" babel-helpers@^6.24.1: version "6.24.1" resolved "https://registry.yarnpkg.com/babel-helpers/-/babel-helpers-6.24.1.tgz#3471de9caec388e5c850e597e58a26ddf37602b2" dependencies: babel-runtime "^6.22.0" babel-template "^6.24.1" babel-messages@^6.23.0: version "6.23.0" resolved "https://registry.yarnpkg.com/babel-messages/-/babel-messages-6.23.0.tgz#f3cdf4703858035b2a2951c6ec5edf6c62f2630e" dependencies: babel-runtime "^6.22.0" babel-plugin-check-es2015-constants@^6.22.0, babel-plugin-check-es2015-constants@^6.8.0: version "6.22.0" resolved "https://registry.yarnpkg.com/babel-plugin-check-es2015-constants/-/babel-plugin-check-es2015-constants-6.22.0.tgz#35157b101426fd2ffd3da3f75c7d1e91835bbf8a" dependencies: babel-runtime "^6.22.0" babel-plugin-espower@^2.3.2: version "2.3.2" resolved "https://registry.yarnpkg.com/babel-plugin-espower/-/babel-plugin-espower-2.3.2.tgz#5516b8fcdb26c9f0e1d8160749f6e4c65e71271e" dependencies: babel-generator "^6.1.0" babylon "^6.1.0" call-matcher "^1.0.0" core-js "^2.0.0" espower-location-detector "^1.0.0" espurify "^1.6.0" estraverse "^4.1.1" babel-plugin-minify-builtins@^0.2.0: version "0.2.0" resolved "https://registry.yarnpkg.com/babel-plugin-minify-builtins/-/babel-plugin-minify-builtins-0.2.0.tgz#317f824b0907210b6348671bb040ca072e2e0c82" dependencies: babel-helper-evaluate-path "^0.2.0" babel-plugin-minify-constant-folding@^0.2.0: version "0.2.0" resolved "https://registry.yarnpkg.com/babel-plugin-minify-constant-folding/-/babel-plugin-minify-constant-folding-0.2.0.tgz#8c70b528b2eb7c13e94d95c8789077d4cdbc3970" dependencies: babel-helper-evaluate-path "^0.2.0" babel-plugin-minify-dead-code-elimination@^0.2.0: version "0.2.0" resolved "https://registry.yarnpkg.com/babel-plugin-minify-dead-code-elimination/-/babel-plugin-minify-dead-code-elimination-0.2.0.tgz#e8025ee10a1e5e4f202633a6928ce892c33747e3" dependencies: babel-helper-evaluate-path "^0.2.0" babel-helper-mark-eval-scopes "^0.2.0" babel-helper-remove-or-void "^0.2.0" lodash.some "^4.6.0" babel-plugin-minify-flip-comparisons@^0.2.0: version "0.2.0" resolved "https://registry.yarnpkg.com/babel-plugin-minify-flip-comparisons/-/babel-plugin-minify-flip-comparisons-0.2.0.tgz#0c9c8e93155c8f09dedad8118b634c259f709ef5" dependencies: babel-helper-is-void-0 "^0.2.0" babel-plugin-minify-guarded-expressions@^0.2.0: version "0.2.0" resolved "https://registry.yarnpkg.com/babel-plugin-minify-guarded-expressions/-/babel-plugin-minify-guarded-expressions-0.2.0.tgz#8a8c950040fce3e258a12e6eb21eab94ad7235ab" dependencies: babel-helper-flip-expressions "^0.2.0" babel-plugin-minify-infinity@^0.2.0: version "0.2.0" resolved "https://registry.yarnpkg.com/babel-plugin-minify-infinity/-/babel-plugin-minify-infinity-0.2.0.tgz#30960c615ddbc657c045bb00a1d8eb4af257cf03" babel-plugin-minify-mangle-names@^0.2.0: version "0.2.0" resolved "https://registry.yarnpkg.com/babel-plugin-minify-mangle-names/-/babel-plugin-minify-mangle-names-0.2.0.tgz#719892297ff0106a6ec1a4b0fc062f1f8b6a8529" dependencies: babel-helper-mark-eval-scopes "^0.2.0" babel-plugin-minify-numeric-literals@^0.2.0: version "0.2.0" resolved "https://registry.yarnpkg.com/babel-plugin-minify-numeric-literals/-/babel-plugin-minify-numeric-literals-0.2.0.tgz#5746e851700167a380c05e93f289a7070459a0d1" babel-plugin-minify-replace@^0.2.0: version "0.2.0" resolved "https://registry.yarnpkg.com/babel-plugin-minify-replace/-/babel-plugin-minify-replace-0.2.0.tgz#3c1f06bc4e6d3e301eacb763edc1be611efc39b0" babel-plugin-minify-simplify@^0.2.0: version "0.2.0" resolved "https://registry.yarnpkg.com/babel-plugin-minify-simplify/-/babel-plugin-minify-simplify-0.2.0.tgz#21ceec4857100c5476d7cef121f351156e5c9bc0" dependencies: babel-helper-flip-expressions "^0.2.0" babel-helper-is-nodes-equiv "^0.0.1" babel-helper-to-multiple-sequence-expressions "^0.2.0" babel-plugin-minify-type-constructors@^0.2.0: version "0.2.0" resolved "https://registry.yarnpkg.com/babel-plugin-minify-type-constructors/-/babel-plugin-minify-type-constructors-0.2.0.tgz#7f3b6458be0863cfd59e9985bed6d134aa7a2e17" dependencies: babel-helper-is-void-0 "^0.2.0" babel-plugin-syntax-async-functions@^6.8.0: version "6.13.0" resolved "https://registry.yarnpkg.com/babel-plugin-syntax-async-functions/-/babel-plugin-syntax-async-functions-6.13.0.tgz#cad9cad1191b5ad634bf30ae0872391e0647be95" babel-plugin-syntax-exponentiation-operator@^6.8.0: version "6.13.0" resolved "https://registry.yarnpkg.com/babel-plugin-syntax-exponentiation-operator/-/babel-plugin-syntax-exponentiation-operator-6.13.0.tgz#9ee7e8337290da95288201a6a57f4170317830de" babel-plugin-syntax-trailing-function-commas@^6.20.0, babel-plugin-syntax-trailing-function-commas@^6.22.0: version "6.22.0" resolved "https://registry.yarnpkg.com/babel-plugin-syntax-trailing-function-commas/-/babel-plugin-syntax-trailing-function-commas-6.22.0.tgz#ba0360937f8d06e40180a43fe0d5616fff532cf3" babel-plugin-transform-async-to-generator@^6.16.0, babel-plugin-transform-async-to-generator@^6.22.0: version "6.24.1" resolved "https://registry.yarnpkg.com/babel-plugin-transform-async-to-generator/-/babel-plugin-transform-async-to-generator-6.24.1.tgz#6536e378aff6cb1d5517ac0e40eb3e9fc8d08761" dependencies: babel-helper-remap-async-to-generator "^6.24.1" babel-plugin-syntax-async-functions "^6.8.0" babel-runtime "^6.22.0" babel-plugin-transform-es2015-arrow-functions@^6.22.0: version "6.22.0" resolved "https://registry.yarnpkg.com/babel-plugin-transform-es2015-arrow-functions/-/babel-plugin-transform-es2015-arrow-functions-6.22.0.tgz#452692cb711d5f79dc7f85e440ce41b9f244d221" dependencies: babel-runtime "^6.22.0" babel-plugin-transform-es2015-block-scoped-functions@^6.22.0: version "6.22.0" resolved "https://registry.yarnpkg.com/babel-plugin-transform-es2015-block-scoped-functions/-/babel-plugin-transform-es2015-block-scoped-functions-6.22.0.tgz#bbc51b49f964d70cb8d8e0b94e820246ce3a6141" dependencies: babel-runtime "^6.22.0" babel-plugin-transform-es2015-block-scoping@^6.23.0: version "6.24.1" resolved "https://registry.yarnpkg.com/babel-plugin-transform-es2015-block-scoping/-/babel-plugin-transform-es2015-block-scoping-6.24.1.tgz#76c295dc3a4741b1665adfd3167215dcff32a576" dependencies: babel-runtime "^6.22.0" babel-template "^6.24.1" babel-traverse "^6.24.1" babel-types "^6.24.1" lodash "^4.2.0" babel-plugin-transform-es2015-classes@^6.23.0: version "6.24.1" resolved "https://registry.yarnpkg.com/babel-plugin-transform-es2015-classes/-/babel-plugin-transform-es2015-classes-6.24.1.tgz#5a4c58a50c9c9461e564b4b2a3bfabc97a2584db" dependencies: babel-helper-define-map "^6.24.1" babel-helper-function-name "^6.24.1" babel-helper-optimise-call-expression "^6.24.1" babel-helper-replace-supers "^6.24.1" babel-messages "^6.23.0" babel-runtime "^6.22.0" babel-template "^6.24.1" babel-traverse "^6.24.1" babel-types "^6.24.1" babel-plugin-transform-es2015-computed-properties@^6.22.0: version "6.24.1" resolved "https://registry.yarnpkg.com/babel-plugin-transform-es2015-computed-properties/-/babel-plugin-transform-es2015-computed-properties-6.24.1.tgz#6fe2a8d16895d5634f4cd999b6d3480a308159b3" dependencies: babel-runtime "^6.22.0" babel-template "^6.24.1" babel-plugin-transform-es2015-destructuring@^6.19.0, babel-plugin-transform-es2015-destructuring@^6.23.0: version "6.23.0" resolved "https://registry.yarnpkg.com/babel-plugin-transform-es2015-destructuring/-/babel-plugin-transform-es2015-destructuring-6.23.0.tgz#997bb1f1ab967f682d2b0876fe358d60e765c56d" dependencies: babel-runtime "^6.22.0" babel-plugin-transform-es2015-duplicate-keys@^6.22.0: version "6.24.1" resolved "https://registry.yarnpkg.com/babel-plugin-transform-es2015-duplicate-keys/-/babel-plugin-transform-es2015-duplicate-keys-6.24.1.tgz#73eb3d310ca969e3ef9ec91c53741a6f1576423e" dependencies: babel-runtime "^6.22.0" babel-types "^6.24.1" babel-plugin-transform-es2015-for-of@^6.23.0: version "6.23.0" resolved "https://registry.yarnpkg.com/babel-plugin-transform-es2015-for-of/-/babel-plugin-transform-es2015-for-of-6.23.0.tgz#f47c95b2b613df1d3ecc2fdb7573623c75248691" dependencies: babel-runtime "^6.22.0" babel-plugin-transform-es2015-function-name@^6.22.0, babel-plugin-transform-es2015-function-name@^6.9.0: version "6.24.1" resolved "https://registry.yarnpkg.com/babel-plugin-transform-es2015-function-name/-/babel-plugin-transform-es2015-function-name-6.24.1.tgz#834c89853bc36b1af0f3a4c5dbaa94fd8eacaa8b" dependencies: babel-helper-function-name "^6.24.1" babel-runtime "^6.22.0" babel-types "^6.24.1" babel-plugin-transform-es2015-literals@^6.22.0: version "6.22.0" resolved "https://registry.yarnpkg.com/babel-plugin-transform-es2015-literals/-/babel-plugin-transform-es2015-literals-6.22.0.tgz#4f54a02d6cd66cf915280019a31d31925377ca2e" dependencies: babel-runtime "^6.22.0" babel-plugin-transform-es2015-modules-amd@^6.22.0, babel-plugin-transform-es2015-modules-amd@^6.24.1: version "6.24.1" resolved "https://registry.yarnpkg.com/babel-plugin-transform-es2015-modules-amd/-/babel-plugin-transform-es2015-modules-amd-6.24.1.tgz#3b3e54017239842d6d19c3011c4bd2f00a00d154" dependencies: babel-plugin-transform-es2015-modules-commonjs "^6.24.1" babel-runtime "^6.22.0" babel-template "^6.24.1" babel-plugin-transform-es2015-modules-commonjs@^6.18.0, babel-plugin-transform-es2015-modules-commonjs@^6.23.0, babel-plugin-transform-es2015-modules-commonjs@^6.24.1: version "6.24.1" resolved "https://registry.yarnpkg.com/babel-plugin-transform-es2015-modules-commonjs/-/babel-plugin-transform-es2015-modules-commonjs-6.24.1.tgz#d3e310b40ef664a36622200097c6d440298f2bfe" dependencies: babel-plugin-transform-strict-mode "^6.24.1" babel-runtime "^6.22.0" babel-template "^6.24.1" babel-types "^6.24.1" babel-plugin-transform-es2015-modules-systemjs@^6.23.0: version "6.24.1" resolved "https://registry.yarnpkg.com/babel-plugin-transform-es2015-modules-systemjs/-/babel-plugin-transform-es2015-modules-systemjs-6.24.1.tgz#ff89a142b9119a906195f5f106ecf305d9407d23" dependencies: babel-helper-hoist-variables "^6.24.1" babel-runtime "^6.22.0" babel-template "^6.24.1" babel-plugin-transform-es2015-modules-umd@^6.23.0: version "6.24.1" resolved "https://registry.yarnpkg.com/babel-plugin-transform-es2015-modules-umd/-/babel-plugin-transform-es2015-modules-umd-6.24.1.tgz#ac997e6285cd18ed6176adb607d602344ad38468" dependencies: babel-plugin-transform-es2015-modules-amd "^6.24.1" babel-runtime "^6.22.0" babel-template "^6.24.1" babel-plugin-transform-es2015-object-super@^6.22.0: version "6.24.1" resolved "https://registry.yarnpkg.com/babel-plugin-transform-es2015-object-super/-/babel-plugin-transform-es2015-object-super-6.24.1.tgz#24cef69ae21cb83a7f8603dad021f572eb278f8d" dependencies: babel-helper-replace-supers "^6.24.1" babel-runtime "^6.22.0" babel-plugin-transform-es2015-parameters@^6.21.0, babel-plugin-transform-es2015-parameters@^6.23.0: version "6.24.1" resolved "https://registry.yarnpkg.com/babel-plugin-transform-es2015-parameters/-/babel-plugin-transform-es2015-parameters-6.24.1.tgz#57ac351ab49caf14a97cd13b09f66fdf0a625f2b" dependencies: babel-helper-call-delegate "^6.24.1" babel-helper-get-function-arity "^6.24.1" babel-runtime "^6.22.0" babel-template "^6.24.1" babel-traverse "^6.24.1" babel-types "^6.24.1" babel-plugin-transform-es2015-shorthand-properties@^6.22.0: version "6.24.1" resolved "https://registry.yarnpkg.com/babel-plugin-transform-es2015-shorthand-properties/-/babel-plugin-transform-es2015-shorthand-properties-6.24.1.tgz#24f875d6721c87661bbd99a4622e51f14de38aa0" dependencies: babel-runtime "^6.22.0" babel-types "^6.24.1" babel-plugin-transform-es2015-spread@^6.22.0, babel-plugin-transform-es2015-spread@^6.8.0: version "6.22.0" resolved "https://registry.yarnpkg.com/babel-plugin-transform-es2015-spread/-/babel-plugin-transform-es2015-spread-6.22.0.tgz#d6d68a99f89aedc4536c81a542e8dd9f1746f8d1" dependencies: babel-runtime "^6.22.0" babel-plugin-transform-es2015-sticky-regex@^6.22.0, babel-plugin-transform-es2015-sticky-regex@^6.8.0: version "6.24.1" resolved "https://registry.yarnpkg.com/babel-plugin-transform-es2015-sticky-regex/-/babel-plugin-transform-es2015-sticky-regex-6.24.1.tgz#00c1cdb1aca71112cdf0cf6126c2ed6b457ccdbc" dependencies: babel-helper-regex "^6.24.1" babel-runtime "^6.22.0" babel-types "^6.24.1" babel-plugin-transform-es2015-template-literals@^6.22.0: version "6.22.0" resolved "https://registry.yarnpkg.com/babel-plugin-transform-es2015-template-literals/-/babel-plugin-transform-es2015-template-literals-6.22.0.tgz#a84b3450f7e9f8f1f6839d6d687da84bb1236d8d" dependencies: babel-runtime "^6.22.0" babel-plugin-transform-es2015-typeof-symbol@^6.23.0: version "6.23.0" resolved "https://registry.yarnpkg.com/babel-plugin-transform-es2015-typeof-symbol/-/babel-plugin-transform-es2015-typeof-symbol-6.23.0.tgz#dec09f1cddff94b52ac73d505c84df59dcceb372" dependencies: babel-runtime "^6.22.0" babel-plugin-transform-es2015-unicode-regex@^6.11.0, babel-plugin-transform-es2015-unicode-regex@^6.22.0: version "6.24.1" resolved "https://registry.yarnpkg.com/babel-plugin-transform-es2015-unicode-regex/-/babel-plugin-transform-es2015-unicode-regex-6.24.1.tgz#d38b12f42ea7323f729387f18a7c5ae1faeb35e9" dependencies: babel-helper-regex "^6.24.1" babel-runtime "^6.22.0" regexpu-core "^2.0.0" babel-plugin-transform-exponentiation-operator@^6.22.0, babel-plugin-transform-exponentiation-operator@^6.8.0: version "6.24.1" resolved "https://registry.yarnpkg.com/babel-plugin-transform-exponentiation-operator/-/babel-plugin-transform-exponentiation-operator-6.24.1.tgz#2ab0c9c7f3098fa48907772bb813fe41e8de3a0e" dependencies: babel-helper-builder-binary-assignment-operator-visitor "^6.24.1" babel-plugin-syntax-exponentiation-operator "^6.8.0" babel-runtime "^6.22.0" babel-plugin-transform-inline-consecutive-adds@^0.2.0: version "0.2.0" resolved "https://registry.yarnpkg.com/babel-plugin-transform-inline-consecutive-adds/-/babel-plugin-transform-inline-consecutive-adds-0.2.0.tgz#15dae78921057f4004f8eafd79e15ddc5f12f426" babel-plugin-transform-member-expression-literals@^6.8.5: version "6.8.5" resolved "https://registry.yarnpkg.com/babel-plugin-transform-member-expression-literals/-/babel-plugin-transform-member-expression-literals-6.8.5.tgz#e06ae305cf48d819822e93a70d79269f04d89eec" babel-plugin-transform-merge-sibling-variables@^6.8.6: version "6.8.6" resolved "https://registry.yarnpkg.com/babel-plugin-transform-merge-sibling-variables/-/babel-plugin-transform-merge-sibling-variables-6.8.6.tgz#6d21efa5ee4981f71657fae716f9594bb2622aef" babel-plugin-transform-minify-booleans@^6.8.3: version "6.8.3" resolved "https://registry.yarnpkg.com/babel-plugin-transform-minify-booleans/-/babel-plugin-transform-minify-booleans-6.8.3.tgz#5906ed776d3718250519abf1bace44b0b613ddf9" babel-plugin-transform-property-literals@^6.8.5: version "6.8.5" resolved "https://registry.yarnpkg.com/babel-plugin-transform-property-literals/-/babel-plugin-transform-property-literals-6.8.5.tgz#67ed5930b34805443452c8b9690c7ebe1e206c40" dependencies: esutils "^2.0.2" babel-plugin-transform-regenerator@^6.22.0: version "6.24.1" resolved "https://registry.yarnpkg.com/babel-plugin-transform-regenerator/-/babel-plugin-transform-regenerator-6.24.1.tgz#b8da305ad43c3c99b4848e4fe4037b770d23c418" dependencies: regenerator-transform "0.9.11" babel-plugin-transform-regexp-constructors@^0.2.0: version "0.2.0" resolved "https://registry.yarnpkg.com/babel-plugin-transform-regexp-constructors/-/babel-plugin-transform-regexp-constructors-0.2.0.tgz#6aa5dd0acc515db4be929bbcec4ed4c946c534a3" babel-plugin-transform-remove-console@^6.8.5: version "6.8.5" resolved "https://registry.yarnpkg.com/babel-plugin-transform-remove-console/-/babel-plugin-transform-remove-console-6.8.5.tgz#fde9d2d3d725530b0fadd8d31078402410386810" babel-plugin-transform-remove-debugger@^6.8.5: version "6.8.5" resolved "https://registry.yarnpkg.com/babel-plugin-transform-remove-debugger/-/babel-plugin-transform-remove-debugger-6.8.5.tgz#809584d412bf918f071fdf41e1fdb15ea89cdcd5" babel-plugin-transform-remove-undefined@^0.2.0: version "0.2.0" resolved "https://registry.yarnpkg.com/babel-plugin-transform-remove-undefined/-/babel-plugin-transform-remove-undefined-0.2.0.tgz#94f052062054c707e8d094acefe79416b63452b1" dependencies: babel-helper-evaluate-path "^0.2.0" babel-plugin-transform-simplify-comparison-operators@^6.8.5: version "6.8.5" resolved "https://registry.yarnpkg.com/babel-plugin-transform-simplify-comparison-operators/-/babel-plugin-transform-simplify-comparison-operators-6.8.5.tgz#a838786baf40cc33a93b95ae09e05591227e43bf" babel-plugin-transform-strict-mode@^6.24.1: version "6.24.1" resolved "https://registry.yarnpkg.com/babel-plugin-transform-strict-mode/-/babel-plugin-transform-strict-mode-6.24.1.tgz#d5faf7aa578a65bbe591cf5edae04a0c67020758" dependencies: babel-runtime "^6.22.0" babel-types "^6.24.1" babel-plugin-transform-undefined-to-void@^6.8.3: version "6.8.3" resolved "https://registry.yarnpkg.com/babel-plugin-transform-undefined-to-void/-/babel-plugin-transform-undefined-to-void-6.8.3.tgz#fc52707f6ee1ddc71bb91b0d314fbefdeef9beb4" babel-preset-env@^1.6.0: version "1.6.0" resolved "https://registry.yarnpkg.com/babel-preset-env/-/babel-preset-env-1.6.0.tgz#2de1c782a780a0a5d605d199c957596da43c44e4" dependencies: babel-plugin-check-es2015-constants "^6.22.0" babel-plugin-syntax-trailing-function-commas "^6.22.0" babel-plugin-transform-async-to-generator "^6.22.0" babel-plugin-transform-es2015-arrow-functions "^6.22.0" babel-plugin-transform-es2015-block-scoped-functions "^6.22.0" babel-plugin-transform-es2015-block-scoping "^6.23.0" babel-plugin-transform-es2015-classes "^6.23.0" babel-plugin-transform-es2015-computed-properties "^6.22.0" babel-plugin-transform-es2015-destructuring "^6.23.0" babel-plugin-transform-es2015-duplicate-keys "^6.22.0" babel-plugin-transform-es2015-for-of "^6.23.0" babel-plugin-transform-es2015-function-name "^6.22.0" babel-plugin-transform-es2015-literals "^6.22.0" babel-plugin-transform-es2015-modules-amd "^6.22.0" babel-plugin-transform-es2015-modules-commonjs "^6.23.0" babel-plugin-transform-es2015-modules-systemjs "^6.23.0" babel-plugin-transform-es2015-modules-umd "^6.23.0" babel-plugin-transform-es2015-object-super "^6.22.0" babel-plugin-transform-es2015-parameters "^6.23.0" babel-plugin-transform-es2015-shorthand-properties "^6.22.0" babel-plugin-transform-es2015-spread "^6.22.0" babel-plugin-transform-es2015-sticky-regex "^6.22.0" babel-plugin-transform-es2015-template-literals "^6.22.0" babel-plugin-transform-es2015-typeof-symbol "^6.23.0" babel-plugin-transform-es2015-unicode-regex "^6.22.0" babel-plugin-transform-exponentiation-operator "^6.22.0" babel-plugin-transform-regenerator "^6.22.0" browserslist "^2.1.2" invariant "^2.2.2" semver "^5.3.0" babel-preset-minify@^0.2.0: version "0.2.0" resolved "https://registry.yarnpkg.com/babel-preset-minify/-/babel-preset-minify-0.2.0.tgz#006566552d9b83834472273f306c0131062a0acc" dependencies: babel-plugin-minify-builtins "^0.2.0" babel-plugin-minify-constant-folding "^0.2.0" babel-plugin-minify-dead-code-elimination "^0.2.0" babel-plugin-minify-flip-comparisons "^0.2.0" babel-plugin-minify-guarded-expressions "^0.2.0" babel-plugin-minify-infinity "^0.2.0" babel-plugin-minify-mangle-names "^0.2.0" babel-plugin-minify-numeric-literals "^0.2.0" babel-plugin-minify-replace "^0.2.0" babel-plugin-minify-simplify "^0.2.0" babel-plugin-minify-type-constructors "^0.2.0" babel-plugin-transform-inline-consecutive-adds "^0.2.0" babel-plugin-transform-member-expression-literals "^6.8.5" babel-plugin-transform-merge-sibling-variables "^6.8.6" babel-plugin-transform-minify-booleans "^6.8.3" babel-plugin-transform-property-literals "^6.8.5" babel-plugin-transform-regexp-constructors "^0.2.0" babel-plugin-transform-remove-console "^6.8.5" babel-plugin-transform-remove-debugger "^6.8.5" babel-plugin-transform-remove-undefined "^0.2.0" babel-plugin-transform-simplify-comparison-operators "^6.8.5" babel-plugin-transform-undefined-to-void "^6.8.3" lodash.isplainobject "^4.0.6" babel-register@^6.24.1: version "6.24.1" resolved "https://registry.yarnpkg.com/babel-register/-/babel-register-6.24.1.tgz#7e10e13a2f71065bdfad5a1787ba45bca6ded75f" dependencies: babel-core "^6.24.1" babel-runtime "^6.22.0" core-js "^2.4.0" home-or-tmp "^2.0.0" lodash "^4.2.0" mkdirp "^0.5.1" source-map-support "^0.4.2" babel-register@^6.26.0: version "6.26.0" resolved "https://registry.yarnpkg.com/babel-register/-/babel-register-6.26.0.tgz#6ed021173e2fcb486d7acb45c6009a856f647071" dependencies: babel-core "^6.26.0" babel-runtime "^6.26.0" core-js "^2.5.0" home-or-tmp "^2.0.0" lodash "^4.17.4" mkdirp "^0.5.1" source-map-support "^0.4.15" babel-runtime@^6.18.0, babel-runtime@^6.22.0: version "6.23.0" resolved "https://registry.yarnpkg.com/babel-runtime/-/babel-runtime-6.23.0.tgz#0a9489f144de70efb3ce4300accdb329e2fc543b" dependencies: core-js "^2.4.0" regenerator-runtime "^0.10.0" babel-runtime@^6.26.0: version "6.26.0" resolved "https://registry.yarnpkg.com/babel-runtime/-/babel-runtime-6.26.0.tgz#965c7058668e82b55d7bfe04ff2337bc8b5647fe" dependencies: core-js "^2.4.0" regenerator-runtime "^0.11.0" babel-template@^6.16.0, babel-template@^6.24.1, babel-template@^6.25.0: version "6.25.0" resolved "https://registry.yarnpkg.com/babel-template/-/babel-template-6.25.0.tgz#665241166b7c2aa4c619d71e192969552b10c071" dependencies: babel-runtime "^6.22.0" babel-traverse "^6.25.0" babel-types "^6.25.0" babylon "^6.17.2" lodash "^4.2.0" babel-template@^6.26.0: version "6.26.0" resolved "https://registry.yarnpkg.com/babel-template/-/babel-template-6.26.0.tgz#de03e2d16396b069f46dd9fff8521fb1a0e35e02" dependencies: babel-runtime "^6.26.0" babel-traverse "^6.26.0" babel-types "^6.26.0" babylon "^6.18.0" lodash "^4.17.4" babel-traverse@^6.18.0, babel-traverse@^6.24.1, babel-traverse@^6.25.0: version "6.25.0" resolved "https://registry.yarnpkg.com/babel-traverse/-/babel-traverse-6.25.0.tgz#2257497e2fcd19b89edc13c4c91381f9512496f1" dependencies: babel-code-frame "^6.22.0" babel-messages "^6.23.0" babel-runtime "^6.22.0" babel-types "^6.25.0" babylon "^6.17.2" debug "^2.2.0" globals "^9.0.0" invariant "^2.2.0" lodash "^4.2.0" babel-traverse@^6.26.0: version "6.26.0" resolved "https://registry.yarnpkg.com/babel-traverse/-/babel-traverse-6.26.0.tgz#46a9cbd7edcc62c8e5c064e2d2d8d0f4035766ee" dependencies: babel-code-frame "^6.26.0" babel-messages "^6.23.0" babel-runtime "^6.26.0" babel-types "^6.26.0" babylon "^6.18.0" debug "^2.6.8" globals "^9.18.0" invariant "^2.2.2" lodash "^4.17.4" babel-types@^6.18.0, babel-types@^6.19.0, babel-types@^6.24.1, babel-types@^6.25.0: version "6.25.0" resolved "https://registry.yarnpkg.com/babel-types/-/babel-types-6.25.0.tgz#70afb248d5660e5d18f811d91c8303b54134a18e" dependencies: babel-runtime "^6.22.0" esutils "^2.0.2" lodash "^4.2.0" to-fast-properties "^1.0.1" babel-types@^6.26.0: version "6.26.0" resolved "https://registry.yarnpkg.com/babel-types/-/babel-types-6.26.0.tgz#a3b073f94ab49eb6fa55cd65227a334380632497" dependencies: babel-runtime "^6.26.0" esutils "^2.0.2" lodash "^4.17.4" to-fast-properties "^1.0.3" babylon@^6.1.0, babylon@^6.17.2: version "6.17.4" resolved "https://registry.yarnpkg.com/babylon/-/babylon-6.17.4.tgz#3e8b7402b88d22c3423e137a1577883b15ff869a" babylon@^6.18.0: version "6.18.0" resolved "https://registry.yarnpkg.com/babylon/-/babylon-6.18.0.tgz#af2f3b88fa6f5c1e4c634d1a0f8eac4f55b395e3" balanced-match@^1.0.0: version "1.0.0" resolved "https://registry.yarnpkg.com/balanced-match/-/balanced-match-1.0.0.tgz#89b4d199ab2bee49de164ea02b89ce462d71b767" bcrypt-pbkdf@^1.0.0: version "1.0.1" resolved "https://registry.yarnpkg.com/bcrypt-pbkdf/-/bcrypt-pbkdf-1.0.1.tgz#63bc5dcb61331b92bc05fd528953c33462a06f8d" dependencies: tweetnacl "^0.14.3" binary-extensions@^1.0.0: version "1.8.0" resolved "https://registry.yarnpkg.com/binary-extensions/-/binary-extensions-1.8.0.tgz#48ec8d16df4377eae5fa5884682480af4d95c774" block-stream@*: version "0.0.9" resolved "https://registry.yarnpkg.com/block-stream/-/block-stream-0.0.9.tgz#13ebfe778a03205cfe03751481ebb4b3300c126a" dependencies: inherits "~2.0.0" bluebird@^3.0.0: version "3.5.0" resolved "https://registry.yarnpkg.com/bluebird/-/bluebird-3.5.0.tgz#791420d7f551eea2897453a8a77653f96606d67c" boom@2.x.x: version "2.10.1" resolved "https://registry.yarnpkg.com/boom/-/boom-2.10.1.tgz#39c8918ceff5799f83f9492a848f625add0c766f" dependencies: hoek "2.x.x" boxen@^1.0.0: version "1.1.0" resolved "https://registry.yarnpkg.com/boxen/-/boxen-1.1.0.tgz#b1b69dd522305e807a99deee777dbd6e5167b102" dependencies: ansi-align "^2.0.0" camelcase "^4.0.0" chalk "^1.1.1" cli-boxes "^1.0.0" string-width "^2.0.0" term-size "^0.1.0" widest-line "^1.0.0" brace-expansion@^1.1.7: version "1.1.8" resolved "https://registry.yarnpkg.com/brace-expansion/-/brace-expansion-1.1.8.tgz#c07b211c7c952ec1f8efd51a77ef0d1d3990a292" dependencies: balanced-match "^1.0.0" concat-map "0.0.1" braces@^1.8.2: version "1.8.5" resolved "https://registry.yarnpkg.com/braces/-/braces-1.8.5.tgz#ba77962e12dff969d6b76711e914b737857bf6a7" dependencies: expand-range "^1.8.1" preserve "^0.2.0" repeat-element "^1.1.2" browser-resolve@^1.11.0: version "1.11.2" resolved "https://registry.yarnpkg.com/browser-resolve/-/browser-resolve-1.11.2.tgz#8ff09b0a2c421718a1051c260b32e48f442938ce" dependencies: resolve "1.1.7" browserslist@^2.1.2: version "2.1.5" resolved "https://registry.yarnpkg.com/browserslist/-/browserslist-2.1.5.tgz#e882550df3d1cd6d481c1a3e0038f2baf13a4711" dependencies: caniuse-lite "^1.0.30000684" electron-to-chromium "^1.3.14" buf-compare@^1.0.0: version "1.0.1" resolved "https://registry.yarnpkg.com/buf-compare/-/buf-compare-1.0.1.tgz#fef28da8b8113a0a0db4430b0b6467b69730b34a" builtin-modules@^1.0.0, builtin-modules@^1.1.0, builtin-modules@^1.1.1: version "1.1.1" resolved "https://registry.yarnpkg.com/builtin-modules/-/builtin-modules-1.1.1.tgz#270f076c5a72c02f5b65a47df94c5fe3a278892f" caching-transform@^1.0.0: version "1.0.1" resolved "https://registry.yarnpkg.com/caching-transform/-/caching-transform-1.0.1.tgz#6dbdb2f20f8d8fbce79f3e94e9d1742dcdf5c0a1" dependencies: md5-hex "^1.2.0" mkdirp "^0.5.1" write-file-atomic "^1.1.4" call-matcher@^1.0.0: version "1.0.1" resolved "https://registry.yarnpkg.com/call-matcher/-/call-matcher-1.0.1.tgz#5134d077984f712a54dad3cbf62de28dce416ca8" dependencies: core-js "^2.0.0" deep-equal "^1.0.0" espurify "^1.6.0" estraverse "^4.0.0" call-signature@0.0.2: version "0.0.2" resolved "https://registry.yarnpkg.com/call-signature/-/call-signature-0.0.2.tgz#a84abc825a55ef4cb2b028bd74e205a65b9a4996" caller-path@^0.1.0: version "0.1.0" resolved "https://registry.yarnpkg.com/caller-path/-/caller-path-0.1.0.tgz#94085ef63581ecd3daa92444a8fe94e82577751f" dependencies: callsites "^0.2.0" callsites@^0.2.0: version "0.2.0" resolved "https://registry.yarnpkg.com/callsites/-/callsites-0.2.0.tgz#afab96262910a7f33c19a5775825c69f34e350ca" camelcase-keys@^2.0.0: version "2.1.0" resolved "https://registry.yarnpkg.com/camelcase-keys/-/camelcase-keys-2.1.0.tgz#308beeaffdf28119051efa1d932213c91b8f92e7" dependencies: camelcase "^2.0.0" map-obj "^1.0.0" camelcase@^1.0.2: version "1.2.1" resolved "https://registry.yarnpkg.com/camelcase/-/camelcase-1.2.1.tgz#9bb5304d2e0b56698b2c758b08a3eaa9daa58a39" camelcase@^2.0.0: version "2.1.1" resolved "https://registry.yarnpkg.com/camelcase/-/camelcase-2.1.1.tgz#7c1d16d679a1bbe59ca02cacecfb011e201f5a1f" camelcase@^3.0.0: version "3.0.0" resolved "https://registry.yarnpkg.com/camelcase/-/camelcase-3.0.0.tgz#32fc4b9fcdaf845fcdf7e73bb97cac2261f0ab0a" camelcase@^4.0.0, camelcase@^4.1.0: version "4.1.0" resolved "https://registry.yarnpkg.com/camelcase/-/camelcase-4.1.0.tgz#d545635be1e33c542649c69173e5de6acfae34dd" caniuse-lite@^1.0.30000684: version "1.0.30000693" resolved "https://registry.yarnpkg.com/caniuse-lite/-/caniuse-lite-1.0.30000693.tgz#c9c6298697c71fdf6cb13eefe8aa93926f2f8613" capture-stack-trace@^1.0.0: version "1.0.0" resolved "https://registry.yarnpkg.com/capture-stack-trace/-/capture-stack-trace-1.0.0.tgz#4a6fa07399c26bba47f0b2496b4d0fb408c5550d" caseless@~0.12.0: version "0.12.0" resolved "https://registry.yarnpkg.com/caseless/-/caseless-0.12.0.tgz#1b681c21ff84033c826543090689420d187151dc" center-align@^0.1.1: version "0.1.3" resolved "https://registry.yarnpkg.com/center-align/-/center-align-0.1.3.tgz#aa0d32629b6ee972200411cbd4461c907bc2b7ad" dependencies: align-text "^0.1.3" lazy-cache "^1.0.3" chalk@^0.4.0: version "0.4.0" resolved "https://registry.yarnpkg.com/chalk/-/chalk-0.4.0.tgz#5199a3ddcd0c1efe23bc08c1b027b06176e0c64f" dependencies: ansi-styles "~1.0.0" has-color "~0.1.0" strip-ansi "~0.1.0" chalk@^1.0.0, chalk@^1.1.0, chalk@^1.1.1, chalk@^1.1.3: version "1.1.3" resolved "https://registry.yarnpkg.com/chalk/-/chalk-1.1.3.tgz#a8115c55e4a702fe4d150abd3872822a7e09fc98" dependencies: ansi-styles "^2.2.1" escape-string-regexp "^1.0.2" has-ansi "^2.0.0" strip-ansi "^3.0.0" supports-color "^2.0.0" chalk@^2.0.0, chalk@^2.0.1: version "2.0.1" resolved "https://registry.yarnpkg.com/chalk/-/chalk-2.0.1.tgz#dbec49436d2ae15f536114e76d14656cdbc0f44d" dependencies: ansi-styles "^3.1.0" escape-string-regexp "^1.0.5" supports-color "^4.0.0" chalk@^2.1.0: version "2.1.0" resolved "https://registry.yarnpkg.com/chalk/-/chalk-2.1.0.tgz#ac5becf14fa21b99c6c92ca7a7d7cfd5b17e743e" dependencies: ansi-styles "^3.1.0" escape-string-regexp "^1.0.5" supports-color "^4.0.0" chokidar@^1.4.2: version "1.7.0" resolved "https://registry.yarnpkg.com/chokidar/-/chokidar-1.7.0.tgz#798e689778151c8076b4b360e5edd28cda2bb468" dependencies: anymatch "^1.3.0" async-each "^1.0.0" glob-parent "^2.0.0" inherits "^2.0.1" is-binary-path "^1.0.0" is-glob "^2.0.0" path-is-absolute "^1.0.0" readdirp "^2.0.0" optionalDependencies: fsevents "^1.0.0" ci-info@^1.0.0: version "1.0.0" resolved "https://registry.yarnpkg.com/ci-info/-/ci-info-1.0.0.tgz#dc5285f2b4e251821683681c381c3388f46ec534" circular-json@^0.3.1: version "0.3.1" resolved "https://registry.yarnpkg.com/circular-json/-/circular-json-0.3.1.tgz#be8b36aefccde8b3ca7aa2d6afc07a37242c0d2d" clean-stack@^1.1.1: version "1.3.0" resolved "https://registry.yarnpkg.com/clean-stack/-/clean-stack-1.3.0.tgz#9e821501ae979986c46b1d66d2d432db2fd4ae31" clean-yaml-object@^0.1.0: version "0.1.0" resolved "https://registry.yarnpkg.com/clean-yaml-object/-/clean-yaml-object-0.1.0.tgz#63fb110dc2ce1a84dc21f6d9334876d010ae8b68" cli-boxes@^1.0.0: version "1.0.0" resolved "https://registry.yarnpkg.com/cli-boxes/-/cli-boxes-1.0.0.tgz#4fa917c3e59c94a004cd61f8ee509da651687143" cli-cursor@^2.1.0: version "2.1.0" resolved "https://registry.yarnpkg.com/cli-cursor/-/cli-cursor-2.1.0.tgz#b35dac376479facc3e94747d41d0d0f5238ffcb5" dependencies: restore-cursor "^2.0.0" cli-spinners@^1.0.0: version "1.0.0" resolved "https://registry.yarnpkg.com/cli-spinners/-/cli-spinners-1.0.0.tgz#ef987ed3d48391ac3dab9180b406a742180d6e6a" cli-truncate@^1.0.0: version "1.0.0" resolved "https://registry.yarnpkg.com/cli-truncate/-/cli-truncate-1.0.0.tgz#21eb91f47b3f6560f004db77a769b4668d9c5518" dependencies: slice-ansi "0.0.4" string-width "^2.0.0" cli-width@^2.0.0: version "2.1.0" resolved "https://registry.yarnpkg.com/cli-width/-/cli-width-2.1.0.tgz#b234ca209b29ef66fc518d9b98d5847b00edf00a" cliui@^2.1.0: version "2.1.0" resolved "https://registry.yarnpkg.com/cliui/-/cliui-2.1.0.tgz#4b475760ff80264c762c3a1719032e91c7fea0d1" dependencies: center-align "^0.1.1" right-align "^0.1.1" wordwrap "0.0.2" cliui@^3.2.0: version "3.2.0" resolved "https://registry.yarnpkg.com/cliui/-/cliui-3.2.0.tgz#120601537a916d29940f934da3b48d585a39213d" dependencies: string-width "^1.0.1" strip-ansi "^3.0.1" wrap-ansi "^2.0.0" co-with-promise@^4.6.0: version "4.6.0" resolved "https://registry.yarnpkg.com/co-with-promise/-/co-with-promise-4.6.0.tgz#413e7db6f5893a60b942cf492c4bec93db415ab7" dependencies: pinkie-promise "^1.0.0" co@^4.6.0: version "4.6.0" resolved "https://registry.yarnpkg.com/co/-/co-4.6.0.tgz#6ea6bdf3d853ae54ccb8e47bfa0bf3f9031fb184" code-excerpt@^2.1.0: version "2.1.0" resolved "https://registry.yarnpkg.com/code-excerpt/-/code-excerpt-2.1.0.tgz#5dcc081e88f4a7e3b554e9e35d7ef232d47f8147" dependencies: convert-to-spaces "^1.0.1" code-point-at@^1.0.0: version "1.1.0" resolved "https://registry.yarnpkg.com/code-point-at/-/code-point-at-1.1.0.tgz#0d070b4d043a5bea33a2f1a40e2edb3d9a4ccf77" color-convert@^1.0.0: version "1.9.0" resolved "https://registry.yarnpkg.com/color-convert/-/color-convert-1.9.0.tgz#1accf97dd739b983bf994d56fec8f95853641b7a" dependencies: color-name "^1.1.1" color-name@^1.1.1: version "1.1.2" resolved "https://registry.yarnpkg.com/color-name/-/color-name-1.1.2.tgz#5c8ab72b64bd2215d617ae9559ebb148475cf98d" combined-stream@^1.0.5, combined-stream@~1.0.5: version "1.0.5" resolved "https://registry.yarnpkg.com/combined-stream/-/combined-stream-1.0.5.tgz#938370a57b4a51dea2c77c15d5c5fdf895164009" dependencies: delayed-stream "~1.0.0" common-path-prefix@^1.0.0: version "1.0.0" resolved "https://registry.yarnpkg.com/common-path-prefix/-/common-path-prefix-1.0.0.tgz#cd52f6f0712e0baab97d6f9732874f22f47752c0" commondir@^1.0.1: version "1.0.1" resolved "https://registry.yarnpkg.com/commondir/-/commondir-1.0.1.tgz#ddd800da0c66127393cca5950ea968a3aaf1253b" concat-map@0.0.1: version "0.0.1" resolved "https://registry.yarnpkg.com/concat-map/-/concat-map-0.0.1.tgz#d8a96bd77fd68df7793a73036a3ba0d5405d477b" concat-stream@^1.6.0: version "1.6.0" resolved "https://registry.yarnpkg.com/concat-stream/-/concat-stream-1.6.0.tgz#0aac662fd52be78964d5532f694784e70110acf7" dependencies: inherits "^2.0.3" readable-stream "^2.2.2" typedarray "^0.0.6" concordance@^3.0.0: version "3.0.0" resolved "https://registry.yarnpkg.com/concordance/-/concordance-3.0.0.tgz#b2286af54405fc995fc7345b0b106d8dd073cb29" dependencies: date-time "^2.1.0" esutils "^2.0.2" fast-diff "^1.1.1" function-name-support "^0.2.0" js-string-escape "^1.0.1" lodash.clonedeep "^4.5.0" lodash.flattendeep "^4.4.0" lodash.merge "^4.6.0" md5-hex "^2.0.0" semver "^5.3.0" well-known-symbols "^1.0.0" configstore@^3.0.0: version "3.1.0" resolved "https://registry.yarnpkg.com/configstore/-/configstore-3.1.0.tgz#45df907073e26dfa1cf4b2d52f5b60545eaa11d1" dependencies: dot-prop "^4.1.0" graceful-fs "^4.1.2" make-dir "^1.0.0" unique-string "^1.0.0" write-file-atomic "^2.0.0" xdg-basedir "^3.0.0" console-control-strings@^1.0.0, console-control-strings@~1.1.0: version "1.1.0" resolved "https://registry.yarnpkg.com/console-control-strings/-/console-control-strings-1.1.0.tgz#3d7cf4464db6446ea644bf4b39507f9851008e8e" contains-path@^0.1.0: version "0.1.0" resolved "https://registry.yarnpkg.com/contains-path/-/contains-path-0.1.0.tgz#fe8cf184ff6670b6baef01a9d4861a5cbec4120a" convert-source-map@^1.1.0, convert-source-map@^1.2.0, convert-source-map@^1.3.0, convert-source-map@^1.5.0: version "1.5.0" resolved "https://registry.yarnpkg.com/convert-source-map/-/convert-source-map-1.5.0.tgz#9acd70851c6d5dfdd93d9282e5edf94a03ff46b5" convert-to-spaces@^1.0.1: version "1.0.2" resolved "https://registry.yarnpkg.com/convert-to-spaces/-/convert-to-spaces-1.0.2.tgz#7e3e48bbe6d997b1417ddca2868204b4d3d85715" core-assert@^0.2.0: version "0.2.1" resolved "https://registry.yarnpkg.com/core-assert/-/core-assert-0.2.1.tgz#f85e2cf9bfed28f773cc8b3fa5c5b69bdc02fe3f" dependencies: buf-compare "^1.0.0" is-error "^2.2.0" core-js@^2.0.0, core-js@^2.4.0: version "2.4.1" resolved "https://registry.yarnpkg.com/core-js/-/core-js-2.4.1.tgz#4de911e667b0eae9124e34254b53aea6fc618d3e" core-js@^2.5.0: version "2.5.1" resolved "https://registry.yarnpkg.com/core-js/-/core-js-2.5.1.tgz#ae6874dc66937789b80754ff5428df66819ca50b" core-util-is@~1.0.0: version "1.0.2" resolved "https://registry.yarnpkg.com/core-util-is/-/core-util-is-1.0.2.tgz#b5fd54220aa2bc5ab57aab7140c940754503c1a7" create-error-class@^3.0.0: version "3.0.2" resolved "https://registry.yarnpkg.com/create-error-class/-/create-error-class-3.0.2.tgz#06be7abef947a3f14a30fd610671d401bca8b7b6" dependencies: capture-stack-trace "^1.0.0" cross-spawn-async@^2.1.1: version "2.2.5" resolved "https://registry.yarnpkg.com/cross-spawn-async/-/cross-spawn-async-2.2.5.tgz#845ff0c0834a3ded9d160daca6d390906bb288cc" dependencies: lru-cache "^4.0.0" which "^1.2.8" cross-spawn@^4, cross-spawn@^4.0.0: version "4.0.2" resolved "https://registry.yarnpkg.com/cross-spawn/-/cross-spawn-4.0.2.tgz#7b9247621c23adfdd3856004a823cbe397424d41" dependencies: lru-cache "^4.0.1" which "^1.2.9" cross-spawn@^5.1.0: version "5.1.0" resolved "https://registry.yarnpkg.com/cross-spawn/-/cross-spawn-5.1.0.tgz#e8bd0efee58fcff6f8f94510a0a554bbfa235449" dependencies: lru-cache "^4.0.1" shebang-command "^1.2.0" which "^1.2.9" cryptiles@2.x.x: version "2.0.5" resolved "https://registry.yarnpkg.com/cryptiles/-/cryptiles-2.0.5.tgz#3bdfecdc608147c1c67202fa291e7dca59eaa3b8" dependencies: boom "2.x.x" crypto-random-string@^1.0.0: version "1.0.0" resolved "https://registry.yarnpkg.com/crypto-random-string/-/crypto-random-string-1.0.0.tgz#a230f64f568310e1498009940790ec99545bca7e" currently-unhandled@^0.4.1: version "0.4.1" resolved "https://registry.yarnpkg.com/currently-unhandled/-/currently-unhandled-0.4.1.tgz#988df33feab191ef799a61369dd76c17adf957ea" dependencies: array-find-index "^1.0.1" dashdash@^1.12.0: version "1.14.1" resolved "https://registry.yarnpkg.com/dashdash/-/dashdash-1.14.1.tgz#853cfa0f7cbe2fed5de20326b8dd581035f6e2f0" dependencies: assert-plus "^1.0.0" date-time@^0.1.1: version "0.1.1" resolved "https://registry.yarnpkg.com/date-time/-/date-time-0.1.1.tgz#ed2f6d93d9790ce2fd66d5b5ff3edd5bbcbf3b07" date-time@^2.1.0: version "2.1.0" resolved "https://registry.yarnpkg.com/date-time/-/date-time-2.1.0.tgz#0286d1b4c769633b3ca13e1e62558d2dbdc2eba2" dependencies: time-zone "^1.0.0" debug-log@^1.0.1: version "1.0.1" resolved "https://registry.yarnpkg.com/debug-log/-/debug-log-1.0.1.tgz#2307632d4c04382b8df8a32f70b895046d52745f" debug@^2.1.1, debug@^2.2.0, debug@^2.6.3, debug@^2.6.8: version "2.6.8" resolved "https://registry.yarnpkg.com/debug/-/debug-2.6.8.tgz#e731531ca2ede27d188222427da17821d68ff4fc" dependencies: ms "2.0.0" decamelize@^1.0.0, decamelize@^1.1.1, decamelize@^1.1.2: version "1.2.0" resolved "https://registry.yarnpkg.com/decamelize/-/decamelize-1.2.0.tgz#f6534d15148269b20352e7bee26f501f9a191290" deep-equal@^1.0.0: version "1.0.1" resolved "https://registry.yarnpkg.com/deep-equal/-/deep-equal-1.0.1.tgz#f5d260292b660e084eff4cdbc9f08ad3247448b5" deep-extend@~0.4.0: version "0.4.2" resolved "https://registry.yarnpkg.com/deep-extend/-/deep-extend-0.4.2.tgz#48b699c27e334bf89f10892be432f6e4c7d34a7f" deep-is@~0.1.3: version "0.1.3" resolved "https://registry.yarnpkg.com/deep-is/-/deep-is-0.1.3.tgz#b369d6fb5dbc13eecf524f91b070feedc357cf34" default-require-extensions@^1.0.0: version "1.0.0" resolved "https://registry.yarnpkg.com/default-require-extensions/-/default-require-extensions-1.0.0.tgz#f37ea15d3e13ffd9b437d33e1a75b5fb97874cb8" dependencies: strip-bom "^2.0.0" del@^2.0.2: version "2.2.2" resolved "https://registry.yarnpkg.com/del/-/del-2.2.2.tgz#c12c981d067846c84bcaf862cff930d907ffd1a8" dependencies: globby "^5.0.0" is-path-cwd "^1.0.0" is-path-in-cwd "^1.0.0" object-assign "^4.0.1" pify "^2.0.0" pinkie-promise "^2.0.0" rimraf "^2.2.8" delayed-stream@~1.0.0: version "1.0.0" resolved "https://registry.yarnpkg.com/delayed-stream/-/delayed-stream-1.0.0.tgz#df3ae199acadfb7d440aaae0b29e2272b24ec619" delegates@^1.0.0: version "1.0.0" resolved "https://registry.yarnpkg.com/delegates/-/delegates-1.0.0.tgz#84c6e159b81904fdca59a0ef44cd870d31250f9a" detect-indent@^4.0.0: version "4.0.0" resolved "https://registry.yarnpkg.com/detect-indent/-/detect-indent-4.0.0.tgz#f76d064352cdf43a1cb6ce619c4ee3a9475de208" dependencies: repeating "^2.0.0" detect-indent@^5.0.0: version "5.0.0" resolved "https://registry.yarnpkg.com/detect-indent/-/detect-indent-5.0.0.tgz#3871cc0a6a002e8c3e5b3cf7f336264675f06b9d" doctrine@1.5.0: version "1.5.0" resolved "https://registry.yarnpkg.com/doctrine/-/doctrine-1.5.0.tgz#379dce730f6166f76cefa4e6707a159b02c5a6fa" dependencies: esutils "^2.0.2" isarray "^1.0.0" doctrine@^2.0.0: version "2.0.0" resolved "https://registry.yarnpkg.com/doctrine/-/doctrine-2.0.0.tgz#c73d8d2909d22291e1a007a395804da8b665fe63" dependencies: esutils "^2.0.2" isarray "^1.0.0" dot-prop@^4.1.0: version "4.1.1" resolved "https://registry.yarnpkg.com/dot-prop/-/dot-prop-4.1.1.tgz#a8493f0b7b5eeec82525b5c7587fa7de7ca859c1" dependencies: is-obj "^1.0.0" duplexer3@^0.1.4: version "0.1.4" resolved "https://registry.yarnpkg.com/duplexer3/-/duplexer3-0.1.4.tgz#ee01dd1cac0ed3cbc7fdbea37dc0a8f1ce002ce2" ecc-jsbn@~0.1.1: version "0.1.1" resolved "https://registry.yarnpkg.com/ecc-jsbn/-/ecc-jsbn-0.1.1.tgz#0fc73a9ed5f0d53c38193398523ef7e543777505" dependencies: jsbn "~0.1.0" electron-to-chromium@^1.3.14: version "1.3.14" resolved "https://registry.yarnpkg.com/electron-to-chromium/-/electron-to-chromium-1.3.14.tgz#64af0f9efd3c3c6acd57d71f83b49ca7ee9c4b43" empower-core@^0.6.1: version "0.6.2" resolved "https://registry.yarnpkg.com/empower-core/-/empower-core-0.6.2.tgz#5adef566088e31fba80ba0a36df47d7094169144" dependencies: call-signature "0.0.2" core-js "^2.0.0" equal-length@^1.0.0: version "1.0.1" resolved "https://registry.yarnpkg.com/equal-length/-/equal-length-1.0.1.tgz#21ca112d48ab24b4e1e7ffc0e5339d31fdfc274c" erlang-types@^1.0.1: version "1.0.1" resolved "https://registry.yarnpkg.com/erlang-types/-/erlang-types-1.0.1.tgz#943a57a9324e0d0edc0273690a8c702686d9b780" error-ex@^1.2.0: version "1.3.1" resolved "https://registry.yarnpkg.com/error-ex/-/error-ex-1.3.1.tgz#f855a86ce61adc4e8621c3cda21e7a7612c3a8dc" dependencies: is-arrayish "^0.2.1" es6-error@^4.0.1, es6-error@^4.0.2: version "4.0.2" resolved "https://registry.yarnpkg.com/es6-error/-/es6-error-4.0.2.tgz#eec5c726eacef51b7f6b73c20db6e1b13b069c98" escape-string-regexp@^1.0.2, escape-string-regexp@^1.0.4, escape-string-regexp@^1.0.5: version "1.0.5" resolved "https://registry.yarnpkg.com/escape-string-regexp/-/escape-string-regexp-1.0.5.tgz#1b61c0562190a8dff6ae3bb2cf0200ca130b86d4" eslint-config-airbnb-base@^12.0.0: version "12.0.0" resolved "https://registry.yarnpkg.com/eslint-config-airbnb-base/-/eslint-config-airbnb-base-12.0.0.tgz#99063aaef4b8698083481a00e165cbe15e82d615" dependencies: eslint-restricted-globals "^0.1.1" eslint-import-resolver-node@^0.3.1: version "0.3.1" resolved "https://registry.yarnpkg.com/eslint-import-resolver-node/-/eslint-import-resolver-node-0.3.1.tgz#4422574cde66a9a7b099938ee4d508a199e0e3cc" dependencies: debug "^2.6.8" resolve "^1.2.0" eslint-module-utils@^2.1.1: version "2.1.1" resolved "https://registry.yarnpkg.com/eslint-module-utils/-/eslint-module-utils-2.1.1.tgz#abaec824177613b8a95b299639e1b6facf473449" dependencies: debug "^2.6.8" pkg-dir "^1.0.0" eslint-plugin-import@^2.7.0: version "2.7.0" resolved "https://registry.yarnpkg.com/eslint-plugin-import/-/eslint-plugin-import-2.7.0.tgz#21de33380b9efb55f5ef6d2e210ec0e07e7fa69f" dependencies: builtin-modules "^1.1.1" contains-path "^0.1.0" debug "^2.6.8" doctrine "1.5.0" eslint-import-resolver-node "^0.3.1" eslint-module-utils "^2.1.1" has "^1.0.1" lodash.cond "^4.3.0" minimatch "^3.0.3" read-pkg-up "^2.0.0" eslint-restricted-globals@^0.1.1: version "0.1.1" resolved "https://registry.yarnpkg.com/eslint-restricted-globals/-/eslint-restricted-globals-0.1.1.tgz#35f0d5cbc64c2e3ed62e93b4b1a7af05ba7ed4d7" eslint-scope@^3.7.1: version "3.7.1" resolved "https://registry.yarnpkg.com/eslint-scope/-/eslint-scope-3.7.1.tgz#3d63c3edfda02e06e01a452ad88caacc7cdcb6e8" dependencies: esrecurse "^4.1.0" estraverse "^4.1.1" eslint@^4.6.1: version "4.6.1" resolved "https://registry.yarnpkg.com/eslint/-/eslint-4.6.1.tgz#ddc7fc7fd70bf93205b0b3449bb16a1e9e7d4950" dependencies: ajv "^5.2.0" babel-code-frame "^6.22.0" chalk "^2.1.0" concat-stream "^1.6.0" cross-spawn "^5.1.0" debug "^2.6.8" doctrine "^2.0.0" eslint-scope "^3.7.1" espree "^3.5.0" esquery "^1.0.0" estraverse "^4.2.0" esutils "^2.0.2" file-entry-cache "^2.0.0" functional-red-black-tree "^1.0.1" glob "^7.1.2" globals "^9.17.0" ignore "^3.3.3" imurmurhash "^0.1.4" inquirer "^3.0.6" is-resolvable "^1.0.0" js-yaml "^3.9.1" json-stable-stringify "^1.0.1" levn "^0.3.0" lodash "^4.17.4" minimatch "^3.0.2" mkdirp "^0.5.1" natural-compare "^1.4.0" optionator "^0.8.2" path-is-inside "^1.0.2" pluralize "^4.0.0" progress "^2.0.0" require-uncached "^1.0.3" semver "^5.3.0" strip-ansi "^4.0.0" strip-json-comments "~2.0.1" table "^4.0.1" text-table "~0.2.0" espower-location-detector@^1.0.0: version "1.0.0" resolved "https://registry.yarnpkg.com/espower-location-detector/-/espower-location-detector-1.0.0.tgz#a17b7ecc59d30e179e2bef73fb4137704cb331b5" dependencies: is-url "^1.2.1" path-is-absolute "^1.0.0" source-map "^0.5.0" xtend "^4.0.0" espree@^3.5.0: version "3.5.0" resolved "https://registry.yarnpkg.com/espree/-/espree-3.5.0.tgz#98358625bdd055861ea27e2867ea729faf463d8d" dependencies: acorn "^5.1.1" acorn-jsx "^3.0.0" esprima@^3.1.1: version "3.1.3" resolved "https://registry.yarnpkg.com/esprima/-/esprima-3.1.3.tgz#fdca51cee6133895e3c88d535ce49dbff62a4633" esprima@^4.0.0: version "4.0.0" resolved "https://registry.yarnpkg.com/esprima/-/esprima-4.0.0.tgz#4499eddcd1110e0b218bacf2fa7f7f59f55ca804" espurify@^1.6.0: version "1.7.0" resolved "https://registry.yarnpkg.com/espurify/-/espurify-1.7.0.tgz#1c5cf6cbccc32e6f639380bd4f991fab9ba9d226" dependencies: core-js "^2.0.0" esquery@^1.0.0: version "1.0.0" resolved "https://registry.yarnpkg.com/esquery/-/esquery-1.0.0.tgz#cfba8b57d7fba93f17298a8a006a04cda13d80fa" dependencies: estraverse "^4.0.0" esrecurse@^4.1.0: version "4.2.0" resolved "https://registry.yarnpkg.com/esrecurse/-/esrecurse-4.2.0.tgz#fa9568d98d3823f9a41d91e902dcab9ea6e5b163" dependencies: estraverse "^4.1.0" object-assign "^4.0.1" estraverse@^4.0.0, estraverse@^4.1.0, estraverse@^4.1.1, estraverse@^4.2.0: version "4.2.0" resolved "https://registry.yarnpkg.com/estraverse/-/estraverse-4.2.0.tgz#0dee3fed31fcd469618ce7342099fc1afa0bdb13" estree-walker@^0.2.1: version "0.2.1" resolved "https://registry.yarnpkg.com/estree-walker/-/estree-walker-0.2.1.tgz#bdafe8095383d8414d5dc2ecf4c9173b6db9412e" estree-walker@^0.3.0: version "0.3.1" resolved "https://registry.yarnpkg.com/estree-walker/-/estree-walker-0.3.1.tgz#e6b1a51cf7292524e7237c312e5fe6660c1ce1aa" estree-walker@^0.5.0: version "0.5.0" resolved "https://registry.yarnpkg.com/estree-walker/-/estree-walker-0.5.0.tgz#aae3b57c42deb8010e349c892462f0e71c5dd1aa" esutils@^2.0.2: version "2.0.2" resolved "https://registry.yarnpkg.com/esutils/-/esutils-2.0.2.tgz#0abf4f1caa5bcb1f7a9d8acc6dea4faaa04bac9b" execa@^0.4.0: version "0.4.0" resolved "https://registry.yarnpkg.com/execa/-/execa-0.4.0.tgz#4eb6467a36a095fabb2970ff9d5e3fb7bce6ebc3" dependencies: cross-spawn-async "^2.1.1" is-stream "^1.1.0" npm-run-path "^1.0.0" object-assign "^4.0.1" path-key "^1.0.0" strip-eof "^1.0.0" execa@^0.5.0: version "0.5.1" resolved "https://registry.yarnpkg.com/execa/-/execa-0.5.1.tgz#de3fb85cb8d6e91c85bcbceb164581785cb57b36" dependencies: cross-spawn "^4.0.0" get-stream "^2.2.0" is-stream "^1.1.0" npm-run-path "^2.0.0" p-finally "^1.0.0" signal-exit "^3.0.0" strip-eof "^1.0.0" expand-brackets@^0.1.4: version "0.1.5" resolved "https://registry.yarnpkg.com/expand-brackets/-/expand-brackets-0.1.5.tgz#df07284e342a807cd733ac5af72411e581d1177b" dependencies: is-posix-bracket "^0.1.0" expand-range@^1.8.1: version "1.8.2" resolved "https://registry.yarnpkg.com/expand-range/-/expand-range-1.8.2.tgz#a299effd335fe2721ebae8e257ec79644fc85337" dependencies: fill-range "^2.1.0" extend@~3.0.0: version "3.0.1" resolved "https://registry.yarnpkg.com/extend/-/extend-3.0.1.tgz#a755ea7bc1adfcc5a31ce7e762dbaadc5e636444" external-editor@^2.0.4: version "2.0.4" resolved "https://registry.yarnpkg.com/external-editor/-/external-editor-2.0.4.tgz#1ed9199da9cbfe2ef2f7a31b2fde8b0d12368972" dependencies: iconv-lite "^0.4.17" jschardet "^1.4.2" tmp "^0.0.31" extglob@^0.3.1: version "0.3.2" resolved "https://registry.yarnpkg.com/extglob/-/extglob-0.3.2.tgz#2e18ff3d2f49ab2765cec9023f011daa8d8349a1" dependencies: is-extglob "^1.0.0" extsprintf@1.0.2: version "1.0.2" resolved "https://registry.yarnpkg.com/extsprintf/-/extsprintf-1.0.2.tgz#e1080e0658e300b06294990cc70e1502235fd550" fast-deep-equal@^1.0.0: version "1.0.0" resolved "https://registry.yarnpkg.com/fast-deep-equal/-/fast-deep-equal-1.0.0.tgz#96256a3bc975595eb36d82e9929d060d893439ff" fast-diff@^1.1.1: version "1.1.1" resolved "https://registry.yarnpkg.com/fast-diff/-/fast-diff-1.1.1.tgz#0aea0e4e605b6a2189f0e936d4b7fbaf1b7cfd9b" fast-levenshtein@~2.0.4: version "2.0.6" resolved "https://registry.yarnpkg.com/fast-levenshtein/-/fast-levenshtein-2.0.6.tgz#3d8a5c66883a16a30ca8643e851f19baa7797917" figures@^2.0.0: version "2.0.0" resolved "https://registry.yarnpkg.com/figures/-/figures-2.0.0.tgz#3ab1a2d2a62c8bfb431a0c94cb797a2fce27c962" dependencies: escape-string-regexp "^1.0.5" file-entry-cache@^2.0.0: version "2.0.0" resolved "https://registry.yarnpkg.com/file-entry-cache/-/file-entry-cache-2.0.0.tgz#c392990c3e684783d838b8c84a45d8a048458361" dependencies: flat-cache "^1.2.1" object-assign "^4.0.1" filename-regex@^2.0.0: version "2.0.1" resolved "https://registry.yarnpkg.com/filename-regex/-/filename-regex-2.0.1.tgz#c1c4b9bee3e09725ddb106b75c1e301fe2f18b26" fill-range@^2.1.0: version "2.2.3" resolved "https://registry.yarnpkg.com/fill-range/-/fill-range-2.2.3.tgz#50b77dfd7e469bc7492470963699fe7a8485a723" dependencies: is-number "^2.1.0" isobject "^2.0.0" randomatic "^1.1.3" repeat-element "^1.1.2" repeat-string "^1.5.2" find-cache-dir@^0.1.1: version "0.1.1" resolved "https://registry.yarnpkg.com/find-cache-dir/-/find-cache-dir-0.1.1.tgz#c8defae57c8a52a8a784f9e31c57c742e993a0b9" dependencies: commondir "^1.0.1" mkdirp "^0.5.1" pkg-dir "^1.0.0" find-cache-dir@^1.0.0: version "1.0.0" resolved "https://registry.yarnpkg.com/find-cache-dir/-/find-cache-dir-1.0.0.tgz#9288e3e9e3cc3748717d39eade17cf71fc30ee6f" dependencies: commondir "^1.0.1" make-dir "^1.0.0" pkg-dir "^2.0.0" find-up@^1.0.0: version "1.1.2" resolved "https://registry.yarnpkg.com/find-up/-/find-up-1.1.2.tgz#6b2e9822b1a2ce0a60ab64d610eccad53cb24d0f" dependencies: path-exists "^2.0.0" pinkie-promise "^2.0.0" find-up@^2.0.0, find-up@^2.1.0: version "2.1.0" resolved "https://registry.yarnpkg.com/find-up/-/find-up-2.1.0.tgz#45d1b7e506c717ddd482775a2b77920a3c0c57a7" dependencies: locate-path "^2.0.0" flat-cache@^1.2.1: version "1.2.2" resolved "https://registry.yarnpkg.com/flat-cache/-/flat-cache-1.2.2.tgz#fa86714e72c21db88601761ecf2f555d1abc6b96" dependencies: circular-json "^0.3.1" del "^2.0.2" graceful-fs "^4.1.2" write "^0.2.1" fn-name@^2.0.0: version "2.0.1" resolved "https://registry.yarnpkg.com/fn-name/-/fn-name-2.0.1.tgz#5214d7537a4d06a4a301c0cc262feb84188002e7" for-in@^1.0.1: version "1.0.2" resolved "https://registry.yarnpkg.com/for-in/-/for-in-1.0.2.tgz#81068d295a8142ec0ac726c6e2200c30fb6d5e80" for-own@^0.1.4: version "0.1.5" resolved "https://registry.yarnpkg.com/for-own/-/for-own-0.1.5.tgz#5265c681a4f294dabbf17c9509b6763aa84510ce" dependencies: for-in "^1.0.1" foreground-child@^1.5.3, foreground-child@^1.5.6: version "1.5.6" resolved "https://registry.yarnpkg.com/foreground-child/-/foreground-child-1.5.6.tgz#4fd71ad2dfde96789b980a5c0a295937cb2f5ce9" dependencies: cross-spawn "^4" signal-exit "^3.0.0" forever-agent@~0.6.1: version "0.6.1" resolved "https://registry.yarnpkg.com/forever-agent/-/forever-agent-0.6.1.tgz#fbc71f0c41adeb37f96c577ad1ed42d8fdacca91" form-data@~2.1.1: version "2.1.4" resolved "https://registry.yarnpkg.com/form-data/-/form-data-2.1.4.tgz#33c183acf193276ecaa98143a69e94bfee1750d1" dependencies: asynckit "^0.4.0" combined-stream "^1.0.5" mime-types "^2.1.12" fs.realpath@^1.0.0: version "1.0.0" resolved "https://registry.yarnpkg.com/fs.realpath/-/fs.realpath-1.0.0.tgz#1504ad2523158caa40db4a2787cb01411994ea4f" fsevents@^1.0.0: version "1.1.2" resolved "https://registry.yarnpkg.com/fsevents/-/fsevents-1.1.2.tgz#3282b713fb3ad80ede0e9fcf4611b5aa6fc033f4" dependencies: nan "^2.3.0" node-pre-gyp "^0.6.36" fstream-ignore@^1.0.5: version "1.0.5" resolved "https://registry.yarnpkg.com/fstream-ignore/-/fstream-ignore-1.0.5.tgz#9c31dae34767018fe1d249b24dada67d092da105" dependencies: fstream "^1.0.0" inherits "2" minimatch "^3.0.0" fstream@^1.0.0, fstream@^1.0.10, fstream@^1.0.2: version "1.0.11" resolved "https://registry.yarnpkg.com/fstream/-/fstream-1.0.11.tgz#5c1fb1f117477114f0632a0eb4b71b3cb0fd3171" dependencies: graceful-fs "^4.1.2" inherits "~2.0.0" mkdirp ">=0.5 0" rimraf "2" function-bind@^1.0.2: version "1.1.0" resolved "https://registry.yarnpkg.com/function-bind/-/function-bind-1.1.0.tgz#16176714c801798e4e8f2cf7f7529467bb4a5771" function-name-support@^0.2.0: version "0.2.0" resolved "https://registry.yarnpkg.com/function-name-support/-/function-name-support-0.2.0.tgz#55d3bfaa6eafd505a50f9bc81fdf57564a0bb071" functional-red-black-tree@^1.0.1: version "1.0.1" resolved "https://registry.yarnpkg.com/functional-red-black-tree/-/functional-red-black-tree-1.0.1.tgz#1b0ab3bd553b2a0d6399d29c0e3ea0b252078327" gauge@~2.7.3: version "2.7.4" resolved "https://registry.yarnpkg.com/gauge/-/gauge-2.7.4.tgz#2c03405c7538c39d7eb37b317022e325fb018bf7" dependencies: aproba "^1.0.3" console-control-strings "^1.0.0" has-unicode "^2.0.0" object-assign "^4.1.0" signal-exit "^3.0.0" string-width "^1.0.1" strip-ansi "^3.0.1" wide-align "^1.1.0" get-caller-file@^1.0.1: version "1.0.2" resolved "https://registry.yarnpkg.com/get-caller-file/-/get-caller-file-1.0.2.tgz#f702e63127e7e231c160a80c1554acb70d5047e5" get-port@^3.0.0: version "3.1.0" resolved "https://registry.yarnpkg.com/get-port/-/get-port-3.1.0.tgz#ef01b18a84ca6486970ff99e54446141a73ffd3e" get-stdin@^4.0.1: version "4.0.1" resolved "https://registry.yarnpkg.com/get-stdin/-/get-stdin-4.0.1.tgz#b968c6b0a04384324902e8bf1a5df32579a450fe" get-stream@^2.2.0: version "2.3.1" resolved "https://registry.yarnpkg.com/get-stream/-/get-stream-2.3.1.tgz#5f38f93f346009666ee0150a054167f91bdd95de" dependencies: object-assign "^4.0.1" pinkie-promise "^2.0.0" get-stream@^3.0.0: version "3.0.0" resolved "https://registry.yarnpkg.com/get-stream/-/get-stream-3.0.0.tgz#8e943d1358dc37555054ecbe2edb05aa174ede14" getpass@^0.1.1: version "0.1.7" resolved "https://registry.yarnpkg.com/getpass/-/getpass-0.1.7.tgz#5eff8e3e684d569ae4cb2b1282604e8ba62149fa" dependencies: assert-plus "^1.0.0" glob-base@^0.3.0: version "0.3.0" resolved "https://registry.yarnpkg.com/glob-base/-/glob-base-0.3.0.tgz#dbb164f6221b1c0b1ccf82aea328b497df0ea3c4" dependencies: glob-parent "^2.0.0" is-glob "^2.0.0" glob-parent@^2.0.0: version "2.0.0" resolved "https://registry.yarnpkg.com/glob-parent/-/glob-parent-2.0.0.tgz#81383d72db054fcccf5336daa902f182f6edbb28" dependencies: is-glob "^2.0.0" glob@^7.0.3, glob@^7.0.5, glob@^7.0.6, glob@^7.1.2: version "7.1.2" resolved "https://registry.yarnpkg.com/glob/-/glob-7.1.2.tgz#c19c9df9a028702d678612384a6552404c636d15" dependencies: fs.realpath "^1.0.0" inflight "^1.0.4" inherits "2" minimatch "^3.0.4" once "^1.3.0" path-is-absolute "^1.0.0" globals@^9.0.0, globals@^9.17.0, globals@^9.18.0: version "9.18.0" resolved "https://registry.yarnpkg.com/globals/-/globals-9.18.0.tgz#aa3896b3e69b487f17e31ed2143d69a8e30c2d8a" globby@^5.0.0: version "5.0.0" resolved "https://registry.yarnpkg.com/globby/-/globby-5.0.0.tgz#ebd84667ca0dbb330b99bcfc68eac2bc54370e0d" dependencies: array-union "^1.0.1" arrify "^1.0.0" glob "^7.0.3" object-assign "^4.0.1" pify "^2.0.0" pinkie-promise "^2.0.0" globby@^6.0.0: version "6.1.0" resolved "https://registry.yarnpkg.com/globby/-/globby-6.1.0.tgz#f5a6d70e8395e21c858fb0489d64df02424d506c" dependencies: array-union "^1.0.1" glob "^7.0.3" object-assign "^4.0.1" pify "^2.0.0" pinkie-promise "^2.0.0" got@^6.7.1: version "6.7.1" resolved "https://registry.yarnpkg.com/got/-/got-6.7.1.tgz#240cd05785a9a18e561dc1b44b41c763ef1e8db0" dependencies: create-error-class "^3.0.0" duplexer3 "^0.1.4" get-stream "^3.0.0" is-redirect "^1.0.0" is-retry-allowed "^1.0.0" is-stream "^1.0.0" lowercase-keys "^1.0.0" safe-buffer "^5.0.1" timed-out "^4.0.0" unzip-response "^2.0.1" url-parse-lax "^1.0.0" graceful-fs@^4.1.11, graceful-fs@^4.1.2: version "4.1.11" resolved "https://registry.yarnpkg.com/graceful-fs/-/graceful-fs-4.1.11.tgz#0e8bdfe4d1ddb8854d64e04ea7c00e2a026e5658" grapheme-splitter@^1.0.2: version "1.0.2" resolved "https://registry.yarnpkg.com/grapheme-splitter/-/grapheme-splitter-1.0.2.tgz#639e9dc1bf065892c643de31daa27cf58b1068e2" handlebars@^4.0.3: version "4.0.10" resolved "https://registry.yarnpkg.com/handlebars/-/handlebars-4.0.10.tgz#3d30c718b09a3d96f23ea4cc1f403c4d3ba9ff4f" dependencies: async "^1.4.0" optimist "^0.6.1" source-map "^0.4.4" optionalDependencies: uglify-js "^2.6" har-schema@^1.0.5: version "1.0.5" resolved "https://registry.yarnpkg.com/har-schema/-/har-schema-1.0.5.tgz#d263135f43307c02c602afc8fe95970c0151369e" har-validator@~4.2.1: version "4.2.1" resolved "https://registry.yarnpkg.com/har-validator/-/har-validator-4.2.1.tgz#33481d0f1bbff600dd203d75812a6a5fba002e2a" dependencies: ajv "^4.9.1" har-schema "^1.0.5" has-ansi@^2.0.0: version "2.0.0" resolved "https://registry.yarnpkg.com/has-ansi/-/has-ansi-2.0.0.tgz#34f5049ce1ecdf2b0649af3ef24e45ed35416d91" dependencies: ansi-regex "^2.0.0" has-color@~0.1.0: version "0.1.7" resolved "https://registry.yarnpkg.com/has-color/-/has-color-0.1.7.tgz#67144a5260c34fc3cca677d041daf52fe7b78b2f" has-flag@^1.0.0: version "1.0.0" resolved "https://registry.yarnpkg.com/has-flag/-/has-flag-1.0.0.tgz#9d9e793165ce017a00f00418c43f942a7b1d11fa" has-flag@^2.0.0: version "2.0.0" resolved "https://registry.yarnpkg.com/has-flag/-/has-flag-2.0.0.tgz#e8207af1cc7b30d446cc70b734b5e8be18f88d51" has-unicode@^2.0.0: version "2.0.1" resolved "https://registry.yarnpkg.com/has-unicode/-/has-unicode-2.0.1.tgz#e0e6fe6a28cf51138855e086d1691e771de2a8b9" has-yarn@^1.0.0: version "1.0.0" resolved "https://registry.yarnpkg.com/has-yarn/-/has-yarn-1.0.0.tgz#89e25db604b725c8f5976fff0addc921b828a5a7" has@^1.0.1: version "1.0.1" resolved "https://registry.yarnpkg.com/has/-/has-1.0.1.tgz#8461733f538b0837c9361e39a9ab9e9704dc2f28" dependencies: function-bind "^1.0.2" hawk@~3.1.3: version "3.1.3" resolved "https://registry.yarnpkg.com/hawk/-/hawk-3.1.3.tgz#078444bd7c1640b0fe540d2c9b73d59678e8e1c4" dependencies: boom "2.x.x" cryptiles "2.x.x" hoek "2.x.x" sntp "1.x.x" hoek@2.x.x: version "2.16.3" resolved "https://registry.yarnpkg.com/hoek/-/hoek-2.16.3.tgz#20bb7403d3cea398e91dc4710a8ff1b8274a25ed" home-or-tmp@^2.0.0: version "2.0.0" resolved "https://registry.yarnpkg.com/home-or-tmp/-/home-or-tmp-2.0.0.tgz#e36c3f2d2cae7d746a857e38d18d5f32a7882db8" dependencies: os-homedir "^1.0.0" os-tmpdir "^1.0.1" hosted-git-info@^2.1.4: version "2.4.2" resolved "https://registry.yarnpkg.com/hosted-git-info/-/hosted-git-info-2.4.2.tgz#0076b9f46a270506ddbaaea56496897460612a67" http-signature@~1.1.0: version "1.1.1" resolved "https://registry.yarnpkg.com/http-signature/-/http-signature-1.1.1.tgz#df72e267066cd0ac67fb76adf8e134a8fbcf91bf" dependencies: assert-plus "^0.2.0" jsprim "^1.2.2" sshpk "^1.7.0" hullabaloo-config-manager@^1.1.0: version "1.1.1" resolved "https://registry.yarnpkg.com/hullabaloo-config-manager/-/hullabaloo-config-manager-1.1.1.tgz#1d9117813129ad035fd9e8477eaf066911269fe3" dependencies: dot-prop "^4.1.0" es6-error "^4.0.2" graceful-fs "^4.1.11" indent-string "^3.1.0" json5 "^0.5.1" lodash.clonedeep "^4.5.0" lodash.clonedeepwith "^4.5.0" lodash.isequal "^4.5.0" lodash.merge "^4.6.0" md5-hex "^2.0.0" package-hash "^2.0.0" pkg-dir "^2.0.0" resolve-from "^3.0.0" safe-buffer "^5.0.1" iconv-lite@^0.4.17: version "0.4.18" resolved "https://registry.yarnpkg.com/iconv-lite/-/iconv-lite-0.4.18.tgz#23d8656b16aae6742ac29732ea8f0336a4789cf2" ignore-by-default@^1.0.0: version "1.0.1" resolved "https://registry.yarnpkg.com/ignore-by-default/-/ignore-by-default-1.0.1.tgz#48ca6d72f6c6a3af00a9ad4ae6876be3889e2b09" ignore@^3.3.3: version "3.3.3" resolved "https://registry.yarnpkg.com/ignore/-/ignore-3.3.3.tgz#432352e57accd87ab3110e82d3fea0e47812156d" import-lazy@^2.1.0: version "2.1.0" resolved "https://registry.yarnpkg.com/import-lazy/-/import-lazy-2.1.0.tgz#05698e3d45c88e8d7e9d92cb0584e77f096f3e43" import-local@^0.1.1: version "0.1.1" resolved "https://registry.yarnpkg.com/import-local/-/import-local-0.1.1.tgz#b1179572aacdc11c6a91009fb430dbcab5f668a8" dependencies: pkg-dir "^2.0.0" resolve-cwd "^2.0.0" imurmurhash@^0.1.4: version "0.1.4" resolved "https://registry.yarnpkg.com/imurmurhash/-/imurmurhash-0.1.4.tgz#9218b9b2b928a238b13dc4fb6b6d576f231453ea" indent-string@^2.1.0: version "2.1.0" resolved "https://registry.yarnpkg.com/indent-string/-/indent-string-2.1.0.tgz#8e2d48348742121b4a8218b7a137e9a52049dc80" dependencies: repeating "^2.0.0" indent-string@^3.0.0, indent-string@^3.1.0: version "3.1.0" resolved "https://registry.yarnpkg.com/indent-string/-/indent-string-3.1.0.tgz#08ff4334603388399b329e6b9538dc7a3cf5de7d" inflight@^1.0.4: version "1.0.6" resolved "https://registry.yarnpkg.com/inflight/-/inflight-1.0.6.tgz#49bd6331d7d02d0c09bc910a1075ba8165b56df9" dependencies: once "^1.3.0" wrappy "1" inherits@2, inherits@^2.0.1, inherits@^2.0.3, inherits@~2.0.0, inherits@~2.0.3: version "2.0.3" resolved "https://registry.yarnpkg.com/inherits/-/inherits-2.0.3.tgz#633c2c83e3da42a502f52466022480f4208261de" ini@~1.3.0: version "1.3.4" resolved "https://registry.yarnpkg.com/ini/-/ini-1.3.4.tgz#0537cb79daf59b59a1a517dff706c86ec039162e" inquirer@^3.0.6: version "3.2.0" resolved "https://registry.yarnpkg.com/inquirer/-/inquirer-3.2.0.tgz#45b44c2160c729d7578c54060b3eed94487bb42b" dependencies: ansi-escapes "^2.0.0" chalk "^2.0.0" cli-cursor "^2.1.0" cli-width "^2.0.0" external-editor "^2.0.4" figures "^2.0.0" lodash "^4.3.0" mute-stream "0.0.7" run-async "^2.2.0" rx-lite "^4.0.8" rx-lite-aggregates "^4.0.8" string-width "^2.1.0" strip-ansi "^4.0.0" through "^2.3.6" invariant@^2.2.0, invariant@^2.2.2: version "2.2.2" resolved "https://registry.yarnpkg.com/invariant/-/invariant-2.2.2.tgz#9e1f56ac0acdb6bf303306f338be3b204ae60360" dependencies: loose-envify "^1.0.0" invert-kv@^1.0.0: version "1.0.0" resolved "https://registry.yarnpkg.com/invert-kv/-/invert-kv-1.0.0.tgz#104a8e4aaca6d3d8cd157a8ef8bfab2d7a3ffdb6" irregular-plurals@^1.0.0: version "1.2.0" resolved "https://registry.yarnpkg.com/irregular-plurals/-/irregular-plurals-1.2.0.tgz#38f299834ba8c00c30be9c554e137269752ff3ac" is-arrayish@^0.2.1: version "0.2.1" resolved "https://registry.yarnpkg.com/is-arrayish/-/is-arrayish-0.2.1.tgz#77c99840527aa8ecb1a8ba697b80645a7a926a9d" is-binary-path@^1.0.0: version "1.0.1" resolved "https://registry.yarnpkg.com/is-binary-path/-/is-binary-path-1.0.1.tgz#75f16642b480f187a711c814161fd3a4a7655898" dependencies: binary-extensions "^1.0.0" is-buffer@^1.1.5: version "1.1.5" resolved "https://registry.yarnpkg.com/is-buffer/-/is-buffer-1.1.5.tgz#1f3b26ef613b214b88cbca23cc6c01d87961eecc" is-builtin-module@^1.0.0: version "1.0.0" resolved "https://registry.yarnpkg.com/is-builtin-module/-/is-builtin-module-1.0.0.tgz#540572d34f7ac3119f8f76c30cbc1b1e037affbe" dependencies: builtin-modules "^1.0.0" is-ci@^1.0.7: version "1.0.10" resolved "https://registry.yarnpkg.com/is-ci/-/is-ci-1.0.10.tgz#f739336b2632365061a9d48270cd56ae3369318e" dependencies: ci-info "^1.0.0" is-dotfile@^1.0.0: version "1.0.3" resolved "https://registry.yarnpkg.com/is-dotfile/-/is-dotfile-1.0.3.tgz#a6a2f32ffd2dfb04f5ca25ecd0f6b83cf798a1e1" is-equal-shallow@^0.1.3: version "0.1.3" resolved "https://registry.yarnpkg.com/is-equal-shallow/-/is-equal-shallow-0.1.3.tgz#2238098fc221de0bcfa5d9eac4c45d638aa1c534" dependencies: is-primitive "^2.0.0" is-error@^2.2.0: version "2.2.1" resolved "https://registry.yarnpkg.com/is-error/-/is-error-2.2.1.tgz#684a96d84076577c98f4cdb40c6d26a5123bf19c" is-extendable@^0.1.1: version "0.1.1" resolved "https://registry.yarnpkg.com/is-extendable/-/is-extendable-0.1.1.tgz#62b110e289a471418e3ec36a617d472e301dfc89" is-extglob@^1.0.0: version "1.0.0" resolved "https://registry.yarnpkg.com/is-extglob/-/is-extglob-1.0.0.tgz#ac468177c4943405a092fc8f29760c6ffc6206c0" is-finite@^1.0.0, is-finite@^1.0.1: version "1.0.2" resolved "https://registry.yarnpkg.com/is-finite/-/is-finite-1.0.2.tgz#cc6677695602be550ef11e8b4aa6305342b6d0aa" dependencies: number-is-nan "^1.0.0" is-fullwidth-code-point@^1.0.0: version "1.0.0" resolved "https://registry.yarnpkg.com/is-fullwidth-code-point/-/is-fullwidth-code-point-1.0.0.tgz#ef9e31386f031a7f0d643af82fde50c457ef00cb" dependencies: number-is-nan "^1.0.0" is-fullwidth-code-point@^2.0.0: version "2.0.0" resolved "https://registry.yarnpkg.com/is-fullwidth-code-point/-/is-fullwidth-code-point-2.0.0.tgz#a3b30a5c4f199183167aaab93beefae3ddfb654f" is-generator-fn@^1.0.0: version "1.0.0" resolved "https://registry.yarnpkg.com/is-generator-fn/-/is-generator-fn-1.0.0.tgz#969d49e1bb3329f6bb7f09089be26578b2ddd46a" is-glob@^2.0.0, is-glob@^2.0.1: version "2.0.1" resolved "https://registry.yarnpkg.com/is-glob/-/is-glob-2.0.1.tgz#d096f926a3ded5600f3fdfd91198cb0888c2d863" dependencies: is-extglob "^1.0.0" is-module@^1.0.0: version "1.0.0" resolved "https://registry.yarnpkg.com/is-module/-/is-module-1.0.0.tgz#3258fb69f78c14d5b815d664336b4cffb6441591" is-npm@^1.0.0: version "1.0.0" resolved "https://registry.yarnpkg.com/is-npm/-/is-npm-1.0.0.tgz#f2fb63a65e4905b406c86072765a1a4dc793b9f4" is-number@^2.1.0: version "2.1.0" resolved "https://registry.yarnpkg.com/is-number/-/is-number-2.1.0.tgz#01fcbbb393463a548f2f466cce16dece49db908f" dependencies: kind-of "^3.0.2" is-number@^3.0.0: version "3.0.0" resolved "https://registry.yarnpkg.com/is-number/-/is-number-3.0.0.tgz#24fd6201a4782cf50561c810276afc7d12d71195" dependencies: kind-of "^3.0.2" is-obj@^1.0.0: version "1.0.1" resolved "https://registry.yarnpkg.com/is-obj/-/is-obj-1.0.1.tgz#3e4729ac1f5fde025cd7d83a896dab9f4f67db0f" is-observable@^0.2.0: version "0.2.0" resolved "https://registry.yarnpkg.com/is-observable/-/is-observable-0.2.0.tgz#b361311d83c6e5d726cabf5e250b0237106f5ae2" dependencies: symbol-observable "^0.2.2" is-path-cwd@^1.0.0: version "1.0.0" resolved "https://registry.yarnpkg.com/is-path-cwd/-/is-path-cwd-1.0.0.tgz#d225ec23132e89edd38fda767472e62e65f1106d" is-path-in-cwd@^1.0.0: version "1.0.0" resolved "https://registry.yarnpkg.com/is-path-in-cwd/-/is-path-in-cwd-1.0.0.tgz#6477582b8214d602346094567003be8a9eac04dc" dependencies: is-path-inside "^1.0.0" is-path-inside@^1.0.0: version "1.0.0" resolved "https://registry.yarnpkg.com/is-path-inside/-/is-path-inside-1.0.0.tgz#fc06e5a1683fbda13de667aff717bbc10a48f37f" dependencies: path-is-inside "^1.0.1" is-plain-obj@^1.0.0: version "1.1.0" resolved "https://registry.yarnpkg.com/is-plain-obj/-/is-plain-obj-1.1.0.tgz#71a50c8429dfca773c92a390a4a03b39fcd51d3e" is-posix-bracket@^0.1.0: version "0.1.1" resolved "https://registry.yarnpkg.com/is-posix-bracket/-/is-posix-bracket-0.1.1.tgz#3334dc79774368e92f016e6fbc0a88f5cd6e6bc4" is-primitive@^2.0.0: version "2.0.0" resolved "https://registry.yarnpkg.com/is-primitive/-/is-primitive-2.0.0.tgz#207bab91638499c07b2adf240a41a87210034575" is-promise@^2.1.0: version "2.1.0" resolved "https://registry.yarnpkg.com/is-promise/-/is-promise-2.1.0.tgz#79a2a9ece7f096e80f36d2b2f3bc16c1ff4bf3fa" is-redirect@^1.0.0: version "1.0.0" resolved "https://registry.yarnpkg.com/is-redirect/-/is-redirect-1.0.0.tgz#1d03dded53bd8db0f30c26e4f95d36fc7c87dc24" is-resolvable@^1.0.0: version "1.0.0" resolved "https://registry.yarnpkg.com/is-resolvable/-/is-resolvable-1.0.0.tgz#8df57c61ea2e3c501408d100fb013cf8d6e0cc62" dependencies: tryit "^1.0.1" is-retry-allowed@^1.0.0: version "1.1.0" resolved "https://registry.yarnpkg.com/is-retry-allowed/-/is-retry-allowed-1.1.0.tgz#11a060568b67339444033d0125a61a20d564fb34" is-stream@^1.0.0, is-stream@^1.1.0: version "1.1.0" resolved "https://registry.yarnpkg.com/is-stream/-/is-stream-1.1.0.tgz#12d4a3dd4e68e0b79ceb8dbc84173ae80d91ca44" is-typedarray@~1.0.0: version "1.0.0" resolved "https://registry.yarnpkg.com/is-typedarray/-/is-typedarray-1.0.0.tgz#e479c80858df0c1b11ddda6940f96011fcda4a9a" is-url@^1.2.1: version "1.2.2" resolved "https://registry.yarnpkg.com/is-url/-/is-url-1.2.2.tgz#498905a593bf47cc2d9e7f738372bbf7696c7f26" is-utf8@^0.2.0, is-utf8@^0.2.1: version "0.2.1" resolved "https://registry.yarnpkg.com/is-utf8/-/is-utf8-0.2.1.tgz#4b0da1442104d1b336340e80797e865cf39f7d72" isarray@1.0.0, isarray@^1.0.0, isarray@~1.0.0: version "1.0.0" resolved "https://registry.yarnpkg.com/isarray/-/isarray-1.0.0.tgz#bb935d48582cba168c06834957a54a3e07124f11" isexe@^2.0.0: version "2.0.0" resolved "https://registry.yarnpkg.com/isexe/-/isexe-2.0.0.tgz#e8fbf374dc556ff8947a10dcb0572d633f2cfa10" isobject@^2.0.0: version "2.1.0" resolved "https://registry.yarnpkg.com/isobject/-/isobject-2.1.0.tgz#f065561096a3f1da2ef46272f815c840d87e0c89" dependencies: isarray "1.0.0" isstream@~0.1.2: version "0.1.2" resolved "https://registry.yarnpkg.com/isstream/-/isstream-0.1.2.tgz#47e63f7af55afa6f92e1500e690eb8b8529c099a" istanbul-lib-coverage@^1.1.1: version "1.1.1" resolved "https://registry.yarnpkg.com/istanbul-lib-coverage/-/istanbul-lib-coverage-1.1.1.tgz#73bfb998885299415c93d38a3e9adf784a77a9da" istanbul-lib-hook@^1.0.7: version "1.0.7" resolved "https://registry.yarnpkg.com/istanbul-lib-hook/-/istanbul-lib-hook-1.0.7.tgz#dd6607f03076578fe7d6f2a630cf143b49bacddc" dependencies: append-transform "^0.4.0" istanbul-lib-instrument@^1.8.0: version "1.8.0" resolved "https://registry.yarnpkg.com/istanbul-lib-instrument/-/istanbul-lib-instrument-1.8.0.tgz#66f6c9421cc9ec4704f76f2db084ba9078a2b532" dependencies: babel-generator "^6.18.0" babel-template "^6.16.0" babel-traverse "^6.18.0" babel-types "^6.18.0" babylon "^6.18.0" istanbul-lib-coverage "^1.1.1" semver "^5.3.0" istanbul-lib-report@^1.1.1: version "1.1.1" resolved "https://registry.yarnpkg.com/istanbul-lib-report/-/istanbul-lib-report-1.1.1.tgz#f0e55f56655ffa34222080b7a0cd4760e1405fc9" dependencies: istanbul-lib-coverage "^1.1.1" mkdirp "^0.5.1" path-parse "^1.0.5" supports-color "^3.1.2" istanbul-lib-source-maps@^1.2.1: version "1.2.1" resolved "https://registry.yarnpkg.com/istanbul-lib-source-maps/-/istanbul-lib-source-maps-1.2.1.tgz#a6fe1acba8ce08eebc638e572e294d267008aa0c" dependencies: debug "^2.6.3" istanbul-lib-coverage "^1.1.1" mkdirp "^0.5.1" rimraf "^2.6.1" source-map "^0.5.3" istanbul-reports@^1.1.1: version "1.1.1" resolved "https://registry.yarnpkg.com/istanbul-reports/-/istanbul-reports-1.1.1.tgz#042be5c89e175bc3f86523caab29c014e77fee4e" dependencies: handlebars "^4.0.3" js-string-escape@^1.0.1: version "1.0.1" resolved "https://registry.yarnpkg.com/js-string-escape/-/js-string-escape-1.0.1.tgz#e2625badbc0d67c7533e9edc1068c587ae4137ef" js-tokens@^3.0.0: version "3.0.1" resolved "https://registry.yarnpkg.com/js-tokens/-/js-tokens-3.0.1.tgz#08e9f132484a2c45a30907e9dc4d5567b7f114d7" js-tokens@^3.0.2: version "3.0.2" resolved "https://registry.yarnpkg.com/js-tokens/-/js-tokens-3.0.2.tgz#9866df395102130e38f7f996bceb65443209c25b" js-yaml@^3.8.2: version "3.8.4" resolved "https://registry.yarnpkg.com/js-yaml/-/js-yaml-3.8.4.tgz#520b4564f86573ba96662af85a8cafa7b4b5a6f6" dependencies: argparse "^1.0.7" esprima "^3.1.1" js-yaml@^3.9.1: version "3.9.1" resolved "https://registry.yarnpkg.com/js-yaml/-/js-yaml-3.9.1.tgz#08775cebdfdd359209f0d2acd383c8f86a6904a0" dependencies: argparse "^1.0.7" esprima "^4.0.0" jsbn@~0.1.0: version "0.1.1" resolved "https://registry.yarnpkg.com/jsbn/-/jsbn-0.1.1.tgz#a5e654c2e5a2deb5f201d96cefbca80c0ef2f513" jschardet@^1.4.2: version "1.5.0" resolved "https://registry.yarnpkg.com/jschardet/-/jschardet-1.5.0.tgz#a61f310306a5a71188e1b1acd08add3cfbb08b1e" jsesc@^1.3.0: version "1.3.0" resolved "https://registry.yarnpkg.com/jsesc/-/jsesc-1.3.0.tgz#46c3fec8c1892b12b0833db9bc7622176dbab34b" jsesc@~0.5.0: version "0.5.0" resolved "https://registry.yarnpkg.com/jsesc/-/jsesc-0.5.0.tgz#e7dee66e35d6fc16f710fe91d5cf69f70f08911d" json-schema-traverse@^0.3.0: version "0.3.1" resolved "https://registry.yarnpkg.com/json-schema-traverse/-/json-schema-traverse-0.3.1.tgz#349a6d44c53a51de89b40805c5d5e59b417d3340" json-schema@0.2.3: version "0.2.3" resolved "https://registry.yarnpkg.com/json-schema/-/json-schema-0.2.3.tgz#b480c892e59a2f05954ce727bd3f2a4e882f9e13" json-stable-stringify@^1.0.1: version "1.0.1" resolved "https://registry.yarnpkg.com/json-stable-stringify/-/json-stable-stringify-1.0.1.tgz#9a759d39c5f2ff503fd5300646ed445f88c4f9af" dependencies: jsonify "~0.0.0" json-stringify-safe@~5.0.1: version "5.0.1" resolved "https://registry.yarnpkg.com/json-stringify-safe/-/json-stringify-safe-5.0.1.tgz#1296a2d58fd45f19a0f6ce01d65701e2c735b6eb" json5@^0.5.0, json5@^0.5.1: version "0.5.1" resolved "https://registry.yarnpkg.com/json5/-/json5-0.5.1.tgz#1eade7acc012034ad84e2396767ead9fa5495821" jsonify@~0.0.0: version "0.0.0" resolved "https://registry.yarnpkg.com/jsonify/-/jsonify-0.0.0.tgz#2c74b6ee41d93ca51b7b5aaee8f503631d252a73" jsprim@^1.2.2: version "1.4.0" resolved "https://registry.yarnpkg.com/jsprim/-/jsprim-1.4.0.tgz#a3b87e40298d8c380552d8cc7628a0bb95a22918" dependencies: assert-plus "1.0.0" extsprintf "1.0.2" json-schema "0.2.3" verror "1.3.6" kind-of@^3.0.2: version "3.2.2" resolved "https://registry.yarnpkg.com/kind-of/-/kind-of-3.2.2.tgz#31ea21a734bab9bbb0f32466d893aea51e4a3c64" dependencies: is-buffer "^1.1.5" kind-of@^4.0.0: version "4.0.0" resolved "https://registry.yarnpkg.com/kind-of/-/kind-of-4.0.0.tgz#20813df3d712928b207378691a45066fae72dd57" dependencies: is-buffer "^1.1.5" last-line-stream@^1.0.0: version "1.0.0" resolved "https://registry.yarnpkg.com/last-line-stream/-/last-line-stream-1.0.0.tgz#d1b64d69f86ff24af2d04883a2ceee14520a5600" dependencies: through2 "^2.0.0" latest-version@^3.0.0: version "3.1.0" resolved "https://registry.yarnpkg.com/latest-version/-/latest-version-3.1.0.tgz#a205383fea322b33b5ae3b18abee0dc2f356ee15" dependencies: package-json "^4.0.0" lazy-cache@^1.0.3: version "1.0.4" resolved "https://registry.yarnpkg.com/lazy-cache/-/lazy-cache-1.0.4.tgz#a1d78fc3a50474cb80845d3b3b6e1da49a446e8e" lcid@^1.0.0: version "1.0.0" resolved "https://registry.yarnpkg.com/lcid/-/lcid-1.0.0.tgz#308accafa0bc483a3867b4b6f2b9506251d1b835" dependencies: invert-kv "^1.0.0" levn@^0.3.0, levn@~0.3.0: version "0.3.0" resolved "https://registry.yarnpkg.com/levn/-/levn-0.3.0.tgz#3b09924edf9f083c0490fdd4c0bc4421e04764ee" dependencies: prelude-ls "~1.1.2" type-check "~0.3.2" load-json-file@^1.0.0: version "1.1.0" resolved "https://registry.yarnpkg.com/load-json-file/-/load-json-file-1.1.0.tgz#956905708d58b4bab4c2261b04f59f31c99374c0" dependencies: graceful-fs "^4.1.2" parse-json "^2.2.0" pify "^2.0.0" pinkie-promise "^2.0.0" strip-bom "^2.0.0" load-json-file@^2.0.0: version "2.0.0" resolved "https://registry.yarnpkg.com/load-json-file/-/load-json-file-2.0.0.tgz#7947e42149af80d696cbf797bcaabcfe1fe29ca8" dependencies: graceful-fs "^4.1.2" parse-json "^2.2.0" pify "^2.0.0" strip-bom "^3.0.0" locate-path@^2.0.0: version "2.0.0" resolved "https://registry.yarnpkg.com/locate-path/-/locate-path-2.0.0.tgz#2b568b265eec944c6d9c0de9c3dbbbca0354cd8e" dependencies: p-locate "^2.0.0" path-exists "^3.0.0" lodash.clonedeep@^4.5.0: version "4.5.0" resolved "https://registry.yarnpkg.com/lodash.clonedeep/-/lodash.clonedeep-4.5.0.tgz#e23f3f9c4f8fbdde872529c1071857a086e5ccef" lodash.clonedeepwith@^4.5.0: version "4.5.0" resolved "https://registry.yarnpkg.com/lodash.clonedeepwith/-/lodash.clonedeepwith-4.5.0.tgz#6ee30573a03a1a60d670a62ef33c10cf1afdbdd4" lodash.cond@^4.3.0: version "4.5.2" resolved "https://registry.yarnpkg.com/lodash.cond/-/lodash.cond-4.5.2.tgz#f471a1da486be60f6ab955d17115523dd1d255d5" lodash.debounce@^4.0.3: version "4.0.8" resolved "https://registry.yarnpkg.com/lodash.debounce/-/lodash.debounce-4.0.8.tgz#82d79bff30a67c4005ffd5e2515300ad9ca4d7af" lodash.difference@^4.3.0: version "4.5.0" resolved "https://registry.yarnpkg.com/lodash.difference/-/lodash.difference-4.5.0.tgz#9ccb4e505d486b91651345772885a2df27fd017c" lodash.flatten@^4.2.0: version "4.4.0" resolved "https://registry.yarnpkg.com/lodash.flatten/-/lodash.flatten-4.4.0.tgz#f31c22225a9632d2bbf8e4addbef240aa765a61f" lodash.flattendeep@^4.4.0: version "4.4.0" resolved "https://registry.yarnpkg.com/lodash.flattendeep/-/lodash.flattendeep-4.4.0.tgz#fb030917f86a3134e5bc9bec0d69e0013ddfedb2" lodash.isequal@^4.5.0: version "4.5.0" resolved "https://registry.yarnpkg.com/lodash.isequal/-/lodash.isequal-4.5.0.tgz#415c4478f2bcc30120c22ce10ed3226f7d3e18e0" lodash.isplainobject@^4.0.6: version "4.0.6" resolved "https://registry.yarnpkg.com/lodash.isplainobject/-/lodash.isplainobject-4.0.6.tgz#7c526a52d89b45c45cc690b88163be0497f550cb" lodash.merge@^4.6.0: version "4.6.0" resolved "https://registry.yarnpkg.com/lodash.merge/-/lodash.merge-4.6.0.tgz#69884ba144ac33fe699737a6086deffadd0f89c5" lodash.some@^4.6.0: version "4.6.0" resolved "https://registry.yarnpkg.com/lodash.some/-/lodash.some-4.6.0.tgz#1bb9f314ef6b8baded13b549169b2a945eb68e4d" lodash@^4.0.0, lodash@^4.17.4, lodash@^4.2.0, lodash@^4.3.0: version "4.17.4" resolved "https://registry.yarnpkg.com/lodash/-/lodash-4.17.4.tgz#78203a4d1c328ae1d86dca6460e369b57f4055ae" longest@^1.0.1: version "1.0.1" resolved "https://registry.yarnpkg.com/longest/-/longest-1.0.1.tgz#30a0b2da38f73770e8294a0d22e6625ed77d0097" loose-envify@^1.0.0: version "1.3.1" resolved "https://registry.yarnpkg.com/loose-envify/-/loose-envify-1.3.1.tgz#d1a8ad33fa9ce0e713d65fdd0ac8b748d478c848" dependencies: js-tokens "^3.0.0" loud-rejection@^1.0.0, loud-rejection@^1.2.0: version "1.6.0" resolved "https://registry.yarnpkg.com/loud-rejection/-/loud-rejection-1.6.0.tgz#5b46f80147edee578870f086d04821cf998e551f" dependencies: currently-unhandled "^0.4.1" signal-exit "^3.0.0" lowercase-keys@^1.0.0: version "1.0.0" resolved "https://registry.yarnpkg.com/lowercase-keys/-/lowercase-keys-1.0.0.tgz#4e3366b39e7f5457e35f1324bdf6f88d0bfc7306" lru-cache@^4.0.0, lru-cache@^4.0.1: version "4.1.1" resolved "https://registry.yarnpkg.com/lru-cache/-/lru-cache-4.1.1.tgz#622e32e82488b49279114a4f9ecf45e7cd6bba55" dependencies: pseudomap "^1.0.2" yallist "^2.1.2" magic-string@^0.22.4: version "0.22.4" resolved "https://registry.yarnpkg.com/magic-string/-/magic-string-0.22.4.tgz#31039b4e40366395618c1d6cf8193c53917475ff" dependencies: vlq "^0.2.1" make-dir@^1.0.0: version "1.0.0" resolved "https://registry.yarnpkg.com/make-dir/-/make-dir-1.0.0.tgz#97a011751e91dd87cfadef58832ebb04936de978" dependencies: pify "^2.3.0" map-obj@^1.0.0, map-obj@^1.0.1: version "1.0.1" resolved "https://registry.yarnpkg.com/map-obj/-/map-obj-1.0.1.tgz#d933ceb9205d82bdcf4886f6742bdc2b4dea146d" matcher@^1.0.0: version "1.0.0" resolved "https://registry.yarnpkg.com/matcher/-/matcher-1.0.0.tgz#aaf0c4816eb69b92094674175625f3466b0e3e19" dependencies: escape-string-regexp "^1.0.4" md5-hex@^1.2.0, md5-hex@^1.3.0: version "1.3.0" resolved "https://registry.yarnpkg.com/md5-hex/-/md5-hex-1.3.0.tgz#d2c4afe983c4370662179b8cad145219135046c4" dependencies: md5-o-matic "^0.1.1" md5-hex@^2.0.0: version "2.0.0" resolved "https://registry.yarnpkg.com/md5-hex/-/md5-hex-2.0.0.tgz#d0588e9f1c74954492ecd24ac0ac6ce997d92e33" dependencies: md5-o-matic "^0.1.1" md5-o-matic@^0.1.1: version "0.1.1" resolved "https://registry.yarnpkg.com/md5-o-matic/-/md5-o-matic-0.1.1.tgz#822bccd65e117c514fab176b25945d54100a03c3" mem@^1.1.0: version "1.1.0" resolved "https://registry.yarnpkg.com/mem/-/mem-1.1.0.tgz#5edd52b485ca1d900fe64895505399a0dfa45f76" dependencies: mimic-fn "^1.0.0" meow@^3.7.0: version "3.7.0" resolved "https://registry.yarnpkg.com/meow/-/meow-3.7.0.tgz#72cb668b425228290abbfa856892587308a801fb" dependencies: camelcase-keys "^2.0.0" decamelize "^1.1.2" loud-rejection "^1.0.0" map-obj "^1.0.1" minimist "^1.1.3" normalize-package-data "^2.3.4" object-assign "^4.0.1" read-pkg-up "^1.0.1" redent "^1.0.0" trim-newlines "^1.0.0" merge-source-map@^1.0.2: version "1.0.4" resolved "https://registry.yarnpkg.com/merge-source-map/-/merge-source-map-1.0.4.tgz#a5de46538dae84d4114cc5ea02b4772a6346701f" dependencies: source-map "^0.5.6" micromatch@^2.1.5, micromatch@^2.3.11: version "2.3.11" resolved "https://registry.yarnpkg.com/micromatch/-/micromatch-2.3.11.tgz#86677c97d1720b363431d04d0d15293bd38c1565" dependencies: arr-diff "^2.0.0" array-unique "^0.2.1" braces "^1.8.2" expand-brackets "^0.1.4" extglob "^0.3.1" filename-regex "^2.0.0" is-extglob "^1.0.0" is-glob "^2.0.1" kind-of "^3.0.2" normalize-path "^2.0.1" object.omit "^2.0.0" parse-glob "^3.0.4" regex-cache "^0.4.2" mime-db@~1.27.0: version "1.27.0" resolved "https://registry.yarnpkg.com/mime-db/-/mime-db-1.27.0.tgz#820f572296bbd20ec25ed55e5b5de869e5436eb1" mime-types@^2.1.12, mime-types@~2.1.7: version "2.1.15" resolved "https://registry.yarnpkg.com/mime-types/-/mime-types-2.1.15.tgz#a4ebf5064094569237b8cf70046776d09fc92aed" dependencies: mime-db "~1.27.0" mimic-fn@^1.0.0: version "1.1.0" resolved "https://registry.yarnpkg.com/mimic-fn/-/mimic-fn-1.1.0.tgz#e667783d92e89dbd342818b5230b9d62a672ad18" minimatch@^3.0.0, minimatch@^3.0.2, minimatch@^3.0.3, minimatch@^3.0.4: version "3.0.4" resolved "https://registry.yarnpkg.com/minimatch/-/minimatch-3.0.4.tgz#5166e286457f03306064be5497e8dbb0c3d32083" dependencies: brace-expansion "^1.1.7" minimist@0.0.8, minimist@~0.0.1: version "0.0.8" resolved "https://registry.yarnpkg.com/minimist/-/minimist-0.0.8.tgz#857fcabfc3397d2625b8228262e86aa7a011b05d" minimist@^1.1.3, minimist@^1.2.0: version "1.2.0" resolved "https://registry.yarnpkg.com/minimist/-/minimist-1.2.0.tgz#a35008b20f41383eec1fb914f4cd5df79a264284" "mkdirp@>=0.5 0", mkdirp@^0.5.0, mkdirp@^0.5.1: version "0.5.1" resolved "https://registry.yarnpkg.com/mkdirp/-/mkdirp-0.5.1.tgz#30057438eac6cf7f8c4767f38648d6697d75c903" dependencies: minimist "0.0.8" ms@2.0.0, ms@^2.0.0: version "2.0.0" resolved "https://registry.yarnpkg.com/ms/-/ms-2.0.0.tgz#5608aeadfc00be6c2901df5f9861788de0d597c8" multimatch@^2.1.0: version "2.1.0" resolved "https://registry.yarnpkg.com/multimatch/-/multimatch-2.1.0.tgz#9c7906a22fb4c02919e2f5f75161b4cdbd4b2a2b" dependencies: array-differ "^1.0.0" array-union "^1.0.1" arrify "^1.0.0" minimatch "^3.0.0" mute-stream@0.0.7: version "0.0.7" resolved "https://registry.yarnpkg.com/mute-stream/-/mute-stream-0.0.7.tgz#3075ce93bc21b8fab43e1bc4da7e8115ed1e7bab" nan@^2.3.0: version "2.6.2" resolved "https://registry.yarnpkg.com/nan/-/nan-2.6.2.tgz#e4ff34e6c95fdfb5aecc08de6596f43605a7db45" natural-compare@^1.4.0: version "1.4.0" resolved "https://registry.yarnpkg.com/natural-compare/-/natural-compare-1.4.0.tgz#4abebfeed7541f2c27acfb29bdbbd15c8d5ba4f7" node-pre-gyp@^0.6.36: version "0.6.36" resolved "https://registry.yarnpkg.com/node-pre-gyp/-/node-pre-gyp-0.6.36.tgz#db604112cb74e0d477554e9b505b17abddfab786" dependencies: mkdirp "^0.5.1" nopt "^4.0.1" npmlog "^4.0.2" rc "^1.1.7" request "^2.81.0" rimraf "^2.6.1" semver "^5.3.0" tar "^2.2.1" tar-pack "^3.4.0" nopt@^4.0.1: version "4.0.1" resolved "https://registry.yarnpkg.com/nopt/-/nopt-4.0.1.tgz#d0d4685afd5415193c8c7505602d0d17cd64474d" dependencies: abbrev "1" osenv "^0.1.4" normalize-package-data@^2.3.2, normalize-package-data@^2.3.4: version "2.3.8" resolved "https://registry.yarnpkg.com/normalize-package-data/-/normalize-package-data-2.3.8.tgz#d819eda2a9dedbd1ffa563ea4071d936782295bb" dependencies: hosted-git-info "^2.1.4" is-builtin-module "^1.0.0" semver "2 || 3 || 4 || 5" validate-npm-package-license "^3.0.1" normalize-path@^2.0.1: version "2.1.1" resolved "https://registry.yarnpkg.com/normalize-path/-/normalize-path-2.1.1.tgz#1ab28b556e198363a8c1a6f7e6fa20137fe6aed9" dependencies: remove-trailing-separator "^1.0.1" npm-run-path@^1.0.0: version "1.0.0" resolved "https://registry.yarnpkg.com/npm-run-path/-/npm-run-path-1.0.0.tgz#f5c32bf595fe81ae927daec52e82f8b000ac3c8f" dependencies: path-key "^1.0.0" npm-run-path@^2.0.0: version "2.0.2" resolved "https://registry.yarnpkg.com/npm-run-path/-/npm-run-path-2.0.2.tgz#35a9232dfa35d7067b4cb2ddf2357b1871536c5f" dependencies: path-key "^2.0.0" npmlog@^4.0.2: version "4.1.0" resolved "https://registry.yarnpkg.com/npmlog/-/npmlog-4.1.0.tgz#dc59bee85f64f00ed424efb2af0783df25d1c0b5" dependencies: are-we-there-yet "~1.1.2" console-control-strings "~1.1.0" gauge "~2.7.3" set-blocking "~2.0.0" number-is-nan@^1.0.0: version "1.0.1" resolved "https://registry.yarnpkg.com/number-is-nan/-/number-is-nan-1.0.1.tgz#097b602b53422a522c1afb8790318336941a011d" nyc@^11.2.1: version "11.2.1" resolved "https://registry.yarnpkg.com/nyc/-/nyc-11.2.1.tgz#ad850afe9dbad7f4970728b4b2e47fed1c38721c" dependencies: archy "^1.0.0" arrify "^1.0.1" caching-transform "^1.0.0" convert-source-map "^1.3.0" debug-log "^1.0.1" default-require-extensions "^1.0.0" find-cache-dir "^0.1.1" find-up "^2.1.0" foreground-child "^1.5.3" glob "^7.0.6" istanbul-lib-coverage "^1.1.1" istanbul-lib-hook "^1.0.7" istanbul-lib-instrument "^1.8.0" istanbul-lib-report "^1.1.1" istanbul-lib-source-maps "^1.2.1" istanbul-reports "^1.1.1" md5-hex "^1.2.0" merge-source-map "^1.0.2" micromatch "^2.3.11" mkdirp "^0.5.0" resolve-from "^2.0.0" rimraf "^2.5.4" signal-exit "^3.0.1" spawn-wrap "^1.3.8" test-exclude "^4.1.1" yargs "^8.0.1" yargs-parser "^5.0.0" oauth-sign@~0.8.1: version "0.8.2" resolved "https://registry.yarnpkg.com/oauth-sign/-/oauth-sign-0.8.2.tgz#46a6ab7f0aead8deae9ec0565780b7d4efeb9d43" object-assign@^4.0.1, object-assign@^4.1.0: version "4.1.1" resolved "https://registry.yarnpkg.com/object-assign/-/object-assign-4.1.1.tgz#2109adc7965887cfc05cbbd442cac8bfbb360863" object.omit@^2.0.0: version "2.0.1" resolved "https://registry.yarnpkg.com/object.omit/-/object.omit-2.0.1.tgz#1a9c744829f39dbb858c76ca3579ae2a54ebd1fa" dependencies: for-own "^0.1.4" is-extendable "^0.1.1" observable-to-promise@^0.5.0: version "0.5.0" resolved "https://registry.yarnpkg.com/observable-to-promise/-/observable-to-promise-0.5.0.tgz#c828f0f0dc47e9f86af8a4977c5d55076ce7a91f" dependencies: is-observable "^0.2.0" symbol-observable "^1.0.4" once@^1.3.0, once@^1.3.3: version "1.4.0" resolved "https://registry.yarnpkg.com/once/-/once-1.4.0.tgz#583b1aa775961d4b113ac17d9c50baef9dd76bd1" dependencies: wrappy "1" onetime@^2.0.0: version "2.0.1" resolved "https://registry.yarnpkg.com/onetime/-/onetime-2.0.1.tgz#067428230fd67443b2794b22bba528b6867962d4" dependencies: mimic-fn "^1.0.0" optimist@^0.6.1: version "0.6.1" resolved "https://registry.yarnpkg.com/optimist/-/optimist-0.6.1.tgz#da3ea74686fa21a19a111c326e90eb15a0196686" dependencies: minimist "~0.0.1" wordwrap "~0.0.2" option-chain@^1.0.0: version "1.0.0" resolved "https://registry.yarnpkg.com/option-chain/-/option-chain-1.0.0.tgz#938d73bd4e1783f948d34023644ada23669e30f2" optionator@^0.8.2: version "0.8.2" resolved "https://registry.yarnpkg.com/optionator/-/optionator-0.8.2.tgz#364c5e409d3f4d6301d6c0b4c05bba50180aeb64" dependencies: deep-is "~0.1.3" fast-levenshtein "~2.0.4" levn "~0.3.0" prelude-ls "~1.1.2" type-check "~0.3.2" wordwrap "~1.0.0" os-homedir@^1.0.0, os-homedir@^1.0.1: version "1.0.2" resolved "https://registry.yarnpkg.com/os-homedir/-/os-homedir-1.0.2.tgz#ffbc4988336e0e833de0c168c7ef152121aa7fb3" os-locale@^2.0.0: version "2.0.0" resolved "https://registry.yarnpkg.com/os-locale/-/os-locale-2.0.0.tgz#15918ded510522b81ee7ae5a309d54f639fc39a4" dependencies: execa "^0.5.0" lcid "^1.0.0" mem "^1.1.0" os-tmpdir@^1.0.0, os-tmpdir@^1.0.1, os-tmpdir@~1.0.1: version "1.0.2" resolved "https://registry.yarnpkg.com/os-tmpdir/-/os-tmpdir-1.0.2.tgz#bbe67406c79aa85c5cfec766fe5734555dfa1274" osenv@^0.1.4: version "0.1.4" resolved "https://registry.yarnpkg.com/osenv/-/osenv-0.1.4.tgz#42fe6d5953df06c8064be6f176c3d05aaaa34644" dependencies: os-homedir "^1.0.0" os-tmpdir "^1.0.0" p-finally@^1.0.0: version "1.0.0" resolved "https://registry.yarnpkg.com/p-finally/-/p-finally-1.0.0.tgz#3fbcfb15b899a44123b34b6dcc18b724336a2cae" p-limit@^1.1.0: version "1.1.0" resolved "https://registry.yarnpkg.com/p-limit/-/p-limit-1.1.0.tgz#b07ff2d9a5d88bec806035895a2bab66a27988bc" p-locate@^2.0.0: version "2.0.0" resolved "https://registry.yarnpkg.com/p-locate/-/p-locate-2.0.0.tgz#20a0103b222a70c8fd39cc2e580680f3dde5ec43" dependencies: p-limit "^1.1.0" package-hash@^1.2.0: version "1.2.0" resolved "https://registry.yarnpkg.com/package-hash/-/package-hash-1.2.0.tgz#003e56cd57b736a6ed6114cc2b81542672770e44" dependencies: md5-hex "^1.3.0" package-hash@^2.0.0: version "2.0.0" resolved "https://registry.yarnpkg.com/package-hash/-/package-hash-2.0.0.tgz#78ae326c89e05a4d813b68601977af05c00d2a0d" dependencies: graceful-fs "^4.1.11" lodash.flattendeep "^4.4.0" md5-hex "^2.0.0" release-zalgo "^1.0.0" package-json@^4.0.0: version "4.0.1" resolved "https://registry.yarnpkg.com/package-json/-/package-json-4.0.1.tgz#8869a0401253661c4c4ca3da6c2121ed555f5eed" dependencies: got "^6.7.1" registry-auth-token "^3.0.1" registry-url "^3.0.3" semver "^5.1.0" parse-glob@^3.0.4: version "3.0.4" resolved "https://registry.yarnpkg.com/parse-glob/-/parse-glob-3.0.4.tgz#b2c376cfb11f35513badd173ef0bb6e3a388391c" dependencies: glob-base "^0.3.0" is-dotfile "^1.0.0" is-extglob "^1.0.0" is-glob "^2.0.0" parse-json@^2.2.0: version "2.2.0" resolved "https://registry.yarnpkg.com/parse-json/-/parse-json-2.2.0.tgz#f480f40434ef80741f8469099f8dea18f55a4dc9" dependencies: error-ex "^1.2.0" parse-ms@^0.1.0: version "0.1.2" resolved "https://registry.yarnpkg.com/parse-ms/-/parse-ms-0.1.2.tgz#dd3fa25ed6c2efc7bdde12ad9b46c163aa29224e" parse-ms@^1.0.0: version "1.0.1" resolved "https://registry.yarnpkg.com/parse-ms/-/parse-ms-1.0.1.tgz#56346d4749d78f23430ca0c713850aef91aa361d" path-exists@^2.0.0: version "2.1.0" resolved "https://registry.yarnpkg.com/path-exists/-/path-exists-2.1.0.tgz#0feb6c64f0fc518d9a754dd5efb62c7022761f4b" dependencies: pinkie-promise "^2.0.0" path-exists@^3.0.0: version "3.0.0" resolved "https://registry.yarnpkg.com/path-exists/-/path-exists-3.0.0.tgz#ce0ebeaa5f78cb18925ea7d810d7b59b010fd515" path-is-absolute@^1.0.0, path-is-absolute@^1.0.1: version "1.0.1" resolved "https://registry.yarnpkg.com/path-is-absolute/-/path-is-absolute-1.0.1.tgz#174b9268735534ffbc7ace6bf53a5a9e1b5c5f5f" path-is-inside@^1.0.1, path-is-inside@^1.0.2: version "1.0.2" resolved "https://registry.yarnpkg.com/path-is-inside/-/path-is-inside-1.0.2.tgz#365417dede44430d1c11af61027facf074bdfc53" path-key@^1.0.0: version "1.0.0" resolved "https://registry.yarnpkg.com/path-key/-/path-key-1.0.0.tgz#5d53d578019646c0d68800db4e146e6bdc2ac7af" path-key@^2.0.0: version "2.0.1" resolved "https://registry.yarnpkg.com/path-key/-/path-key-2.0.1.tgz#411cadb574c5a140d3a4b1910d40d80cc9f40b40" path-parse@^1.0.5: version "1.0.5" resolved "https://registry.yarnpkg.com/path-parse/-/path-parse-1.0.5.tgz#3c1adf871ea9cd6c9431b6ea2bd74a0ff055c4c1" path-type@^1.0.0: version "1.1.0" resolved "https://registry.yarnpkg.com/path-type/-/path-type-1.1.0.tgz#59c44f7ee491da704da415da5a4070ba4f8fe441" dependencies: graceful-fs "^4.1.2" pify "^2.0.0" pinkie-promise "^2.0.0" path-type@^2.0.0: version "2.0.0" resolved "https://registry.yarnpkg.com/path-type/-/path-type-2.0.0.tgz#f012ccb8415b7096fc2daa1054c3d72389594c73" dependencies: pify "^2.0.0" performance-now@^0.2.0: version "0.2.0" resolved "https://registry.yarnpkg.com/performance-now/-/performance-now-0.2.0.tgz#33ef30c5c77d4ea21c5a53869d91b56d8f2555e5" pify@^2.0.0, pify@^2.3.0: version "2.3.0" resolved "https://registry.yarnpkg.com/pify/-/pify-2.3.0.tgz#ed141a6ac043a849ea588498e7dca8b15330e90c" pinkie-promise@^1.0.0: version "1.0.0" resolved "https://registry.yarnpkg.com/pinkie-promise/-/pinkie-promise-1.0.0.tgz#d1da67f5482563bb7cf57f286ae2822ecfbf3670" dependencies: pinkie "^1.0.0" pinkie-promise@^2.0.0: version "2.0.1" resolved "https://registry.yarnpkg.com/pinkie-promise/-/pinkie-promise-2.0.1.tgz#2135d6dfa7a358c069ac9b178776288228450ffa" dependencies: pinkie "^2.0.0" pinkie@^1.0.0: version "1.0.0" resolved "https://registry.yarnpkg.com/pinkie/-/pinkie-1.0.0.tgz#5a47f28ba1015d0201bda7bf0f358e47bec8c7e4" pinkie@^2.0.0: version "2.0.4" resolved "https://registry.yarnpkg.com/pinkie/-/pinkie-2.0.4.tgz#72556b80cfa0d48a974e80e77248e80ed4f7f870" pkg-conf@^2.0.0: version "2.0.0" resolved "https://registry.yarnpkg.com/pkg-conf/-/pkg-conf-2.0.0.tgz#071c87650403bccfb9c627f58751bfe47c067279" dependencies: find-up "^2.0.0" load-json-file "^2.0.0" pkg-dir@^1.0.0: version "1.0.0" resolved "https://registry.yarnpkg.com/pkg-dir/-/pkg-dir-1.0.0.tgz#7a4b508a8d5bb2d629d447056ff4e9c9314cf3d4" dependencies: find-up "^1.0.0" pkg-dir@^2.0.0: version "2.0.0" resolved "https://registry.yarnpkg.com/pkg-dir/-/pkg-dir-2.0.0.tgz#f6d5d1109e19d63edf428e0bd57e12777615334b" dependencies: find-up "^2.1.0" plur@^1.0.0: version "1.0.0" resolved "https://registry.yarnpkg.com/plur/-/plur-1.0.0.tgz#db85c6814f5e5e5a3b49efc28d604fec62975156" plur@^2.0.0: version "2.1.2" resolved "https://registry.yarnpkg.com/plur/-/plur-2.1.2.tgz#7482452c1a0f508e3e344eaec312c91c29dc655a" dependencies: irregular-plurals "^1.0.0" pluralize@^4.0.0: version "4.0.0" resolved "https://registry.yarnpkg.com/pluralize/-/pluralize-4.0.0.tgz#59b708c1c0190a2f692f1c7618c446b052fd1762" prelude-ls@~1.1.2: version "1.1.2" resolved "https://registry.yarnpkg.com/prelude-ls/-/prelude-ls-1.1.2.tgz#21932a549f5e52ffd9a827f570e04be62a97da54" prepend-http@^1.0.1: version "1.0.4" resolved "https://registry.yarnpkg.com/prepend-http/-/prepend-http-1.0.4.tgz#d4f4562b0ce3696e41ac52d0e002e57a635dc6dc" preserve@^0.2.0: version "0.2.0" resolved "https://registry.yarnpkg.com/preserve/-/preserve-0.2.0.tgz#815ed1f6ebc65926f865b310c0713bcb3315ce4b" pretty-ms@^0.2.1: version "0.2.2" resolved "https://registry.yarnpkg.com/pretty-ms/-/pretty-ms-0.2.2.tgz#da879a682ff33a37011046f13d627f67c73b84f6" dependencies: parse-ms "^0.1.0" pretty-ms@^2.0.0: version "2.1.0" resolved "https://registry.yarnpkg.com/pretty-ms/-/pretty-ms-2.1.0.tgz#4257c256df3fb0b451d6affaab021884126981dc" dependencies: is-finite "^1.0.1" parse-ms "^1.0.0" plur "^1.0.0" private@^0.1.6, private@^0.1.7: version "0.1.7" resolved "https://registry.yarnpkg.com/private/-/private-0.1.7.tgz#68ce5e8a1ef0a23bb570cc28537b5332aba63ef1" process-nextick-args@~1.0.6: version "1.0.7" resolved "https://registry.yarnpkg.com/process-nextick-args/-/process-nextick-args-1.0.7.tgz#150e20b756590ad3f91093f25a4f2ad8bff30ba3" progress@^2.0.0: version "2.0.0" resolved "https://registry.yarnpkg.com/progress/-/progress-2.0.0.tgz#8a1be366bf8fc23db2bd23f10c6fe920b4389d1f" pseudomap@^1.0.2: version "1.0.2" resolved "https://registry.yarnpkg.com/pseudomap/-/pseudomap-1.0.2.tgz#f052a28da70e618917ef0a8ac34c1ae5a68286b3" punycode@^1.4.1: version "1.4.1" resolved "https://registry.yarnpkg.com/punycode/-/punycode-1.4.1.tgz#c0d5a63b2718800ad8e1eb0fa5269c84dd41845e" qs@~6.4.0: version "6.4.0" resolved "https://registry.yarnpkg.com/qs/-/qs-6.4.0.tgz#13e26d28ad6b0ffaa91312cd3bf708ed351e7233" randomatic@^1.1.3: version "1.1.7" resolved "https://registry.yarnpkg.com/randomatic/-/randomatic-1.1.7.tgz#c7abe9cc8b87c0baa876b19fde83fd464797e38c" dependencies: is-number "^3.0.0" kind-of "^4.0.0" rc@^1.0.1, rc@^1.1.6, rc@^1.1.7: version "1.2.1" resolved "https://registry.yarnpkg.com/rc/-/rc-1.2.1.tgz#2e03e8e42ee450b8cb3dce65be1bf8974e1dfd95" dependencies: deep-extend "~0.4.0" ini "~1.3.0" minimist "^1.2.0" strip-json-comments "~2.0.1" read-pkg-up@^1.0.1: version "1.0.1" resolved "https://registry.yarnpkg.com/read-pkg-up/-/read-pkg-up-1.0.1.tgz#9d63c13276c065918d57f002a57f40a1b643fb02" dependencies: find-up "^1.0.0" read-pkg "^1.0.0" read-pkg-up@^2.0.0: version "2.0.0" resolved "https://registry.yarnpkg.com/read-pkg-up/-/read-pkg-up-2.0.0.tgz#6b72a8048984e0c41e79510fd5e9fa99b3b549be" dependencies: find-up "^2.0.0" read-pkg "^2.0.0" read-pkg@^1.0.0: version "1.1.0" resolved "https://registry.yarnpkg.com/read-pkg/-/read-pkg-1.1.0.tgz#f5ffaa5ecd29cb31c0474bca7d756b6bb29e3f28" dependencies: load-json-file "^1.0.0" normalize-package-data "^2.3.2" path-type "^1.0.0" read-pkg@^2.0.0: version "2.0.0" resolved "https://registry.yarnpkg.com/read-pkg/-/read-pkg-2.0.0.tgz#8ef1c0623c6a6db0dc6713c4bfac46332b2368f8" dependencies: load-json-file "^2.0.0" normalize-package-data "^2.3.2" path-type "^2.0.0" readable-stream@^2.0.2, readable-stream@^2.0.6, readable-stream@^2.1.4, readable-stream@^2.1.5, readable-stream@^2.2.2: version "2.3.2" resolved "https://registry.yarnpkg.com/readable-stream/-/readable-stream-2.3.2.tgz#5a04df05e4f57fe3f0dc68fdd11dc5c97c7e6f4d" dependencies: core-util-is "~1.0.0" inherits "~2.0.3" isarray "~1.0.0" process-nextick-args "~1.0.6" safe-buffer "~5.1.0" string_decoder "~1.0.0" util-deprecate "~1.0.1" readdirp@^2.0.0: version "2.1.0" resolved "https://registry.yarnpkg.com/readdirp/-/readdirp-2.1.0.tgz#4ed0ad060df3073300c48440373f72d1cc642d78" dependencies: graceful-fs "^4.1.2" minimatch "^3.0.2" readable-stream "^2.0.2" set-immediate-shim "^1.0.1" redent@^1.0.0: version "1.0.0" resolved "https://registry.yarnpkg.com/redent/-/redent-1.0.0.tgz#cf916ab1fd5f1f16dfb20822dd6ec7f730c2afde" dependencies: indent-string "^2.1.0" strip-indent "^1.0.1" regenerate@^1.2.1: version "1.3.2" resolved "https://registry.yarnpkg.com/regenerate/-/regenerate-1.3.2.tgz#d1941c67bad437e1be76433add5b385f95b19260" regenerator-runtime@^0.10.0: version "0.10.5" resolved "https://registry.yarnpkg.com/regenerator-runtime/-/regenerator-runtime-0.10.5.tgz#336c3efc1220adcedda2c9fab67b5a7955a33658" regenerator-runtime@^0.11.0: version "0.11.0" resolved "https://registry.yarnpkg.com/regenerator-runtime/-/regenerator-runtime-0.11.0.tgz#7e54fe5b5ccd5d6624ea6255c3473be090b802e1" regenerator-transform@0.9.11: version "0.9.11" resolved "https://registry.yarnpkg.com/regenerator-transform/-/regenerator-transform-0.9.11.tgz#3a7d067520cb7b7176769eb5ff868691befe1283" dependencies: babel-runtime "^6.18.0" babel-types "^6.19.0" private "^0.1.6" regex-cache@^0.4.2: version "0.4.3" resolved "https://registry.yarnpkg.com/regex-cache/-/regex-cache-0.4.3.tgz#9b1a6c35d4d0dfcef5711ae651e8e9d3d7114145" dependencies: is-equal-shallow "^0.1.3" is-primitive "^2.0.0" regexpu-core@^2.0.0: version "2.0.0" resolved "https://registry.yarnpkg.com/regexpu-core/-/regexpu-core-2.0.0.tgz#49d038837b8dcf8bfa5b9a42139938e6ea2ae240" dependencies: regenerate "^1.2.1" regjsgen "^0.2.0" regjsparser "^0.1.4" registry-auth-token@^3.0.1: version "3.3.1" resolved "https://registry.yarnpkg.com/registry-auth-token/-/registry-auth-token-3.3.1.tgz#fb0d3289ee0d9ada2cbb52af5dfe66cb070d3006" dependencies: rc "^1.1.6" safe-buffer "^5.0.1" registry-url@^3.0.3: version "3.1.0" resolved "https://registry.yarnpkg.com/registry-url/-/registry-url-3.1.0.tgz#3d4ef870f73dde1d77f0cf9a381432444e174942" dependencies: rc "^1.0.1" regjsgen@^0.2.0: version "0.2.0" resolved "https://registry.yarnpkg.com/regjsgen/-/regjsgen-0.2.0.tgz#6c016adeac554f75823fe37ac05b92d5a4edb1f7" regjsparser@^0.1.4: version "0.1.5" resolved "https://registry.yarnpkg.com/regjsparser/-/regjsparser-0.1.5.tgz#7ee8f84dc6fa792d3fd0ae228d24bd949ead205c" dependencies: jsesc "~0.5.0" release-zalgo@^1.0.0: version "1.0.0" resolved "https://registry.yarnpkg.com/release-zalgo/-/release-zalgo-1.0.0.tgz#09700b7e5074329739330e535c5a90fb67851730" dependencies: es6-error "^4.0.1" remove-trailing-separator@^1.0.1: version "1.0.2" resolved "https://registry.yarnpkg.com/remove-trailing-separator/-/remove-trailing-separator-1.0.2.tgz#69b062d978727ad14dc6b56ba4ab772fd8d70511" repeat-element@^1.1.2: version "1.1.2" resolved "https://registry.yarnpkg.com/repeat-element/-/repeat-element-1.1.2.tgz#ef089a178d1483baae4d93eb98b4f9e4e11d990a" repeat-string@^1.5.2: version "1.6.1" resolved "https://registry.yarnpkg.com/repeat-string/-/repeat-string-1.6.1.tgz#8dcae470e1c88abc2d600fff4a776286da75e637" repeating@^2.0.0: version "2.0.1" resolved "https://registry.yarnpkg.com/repeating/-/repeating-2.0.1.tgz#5214c53a926d3552707527fbab415dbc08d06dda" dependencies: is-finite "^1.0.0" request@^2.81.0: version "2.81.0" resolved "https://registry.yarnpkg.com/request/-/request-2.81.0.tgz#c6928946a0e06c5f8d6f8a9333469ffda46298a0" dependencies: aws-sign2 "~0.6.0" aws4 "^1.2.1" caseless "~0.12.0" combined-stream "~1.0.5" extend "~3.0.0" forever-agent "~0.6.1" form-data "~2.1.1" har-validator "~4.2.1" hawk "~3.1.3" http-signature "~1.1.0" is-typedarray "~1.0.0" isstream "~0.1.2" json-stringify-safe "~5.0.1" mime-types "~2.1.7" oauth-sign "~0.8.1" performance-now "^0.2.0" qs "~6.4.0" safe-buffer "^5.0.1" stringstream "~0.0.4" tough-cookie "~2.3.0" tunnel-agent "^0.6.0" uuid "^3.0.0" require-directory@^2.1.1: version "2.1.1" resolved "https://registry.yarnpkg.com/require-directory/-/require-directory-2.1.1.tgz#8c64ad5fd30dab1c976e2344ffe7f792a6a6df42" require-main-filename@^1.0.1: version "1.0.1" resolved "https://registry.yarnpkg.com/require-main-filename/-/require-main-filename-1.0.1.tgz#97f717b69d48784f5f526a6c5aa8ffdda055a4d1" require-precompiled@^0.1.0: version "0.1.0" resolved "https://registry.yarnpkg.com/require-precompiled/-/require-precompiled-0.1.0.tgz#5a1b52eb70ebed43eb982e974c85ab59571e56fa" require-uncached@^1.0.3: version "1.0.3" resolved "https://registry.yarnpkg.com/require-uncached/-/require-uncached-1.0.3.tgz#4e0d56d6c9662fd31e43011c4b95aa49955421d3" dependencies: caller-path "^0.1.0" resolve-from "^1.0.0" resolve-cwd@^2.0.0: version "2.0.0" resolved "https://registry.yarnpkg.com/resolve-cwd/-/resolve-cwd-2.0.0.tgz#00a9f7387556e27038eae232caa372a6a59b665a" dependencies: resolve-from "^3.0.0" resolve-from@^1.0.0: version "1.0.1" resolved "https://registry.yarnpkg.com/resolve-from/-/resolve-from-1.0.1.tgz#26cbfe935d1aeeeabb29bc3fe5aeb01e93d44226" resolve-from@^2.0.0: version "2.0.0" resolved "https://registry.yarnpkg.com/resolve-from/-/resolve-from-2.0.0.tgz#9480ab20e94ffa1d9e80a804c7ea147611966b57" resolve-from@^3.0.0: version "3.0.0" resolved "https://registry.yarnpkg.com/resolve-from/-/resolve-from-3.0.0.tgz#b22c7af7d9d6881bc8b6e653335eebcb0a188748" resolve@1.1.7: version "1.1.7" resolved "https://registry.yarnpkg.com/resolve/-/resolve-1.1.7.tgz#203114d82ad2c5ed9e8e0411b3932875e889e97b" resolve@^1.1.6, resolve@^1.2.0: version "1.3.3" resolved "https://registry.yarnpkg.com/resolve/-/resolve-1.3.3.tgz#655907c3469a8680dc2de3a275a8fdd69691f0e5" dependencies: path-parse "^1.0.5" resolve@^1.4.0: version "1.4.0" resolved "https://registry.yarnpkg.com/resolve/-/resolve-1.4.0.tgz#a75be01c53da25d934a98ebd0e4c4a7312f92a86" dependencies: path-parse "^1.0.5" restore-cursor@^2.0.0: version "2.0.0" resolved "https://registry.yarnpkg.com/restore-cursor/-/restore-cursor-2.0.0.tgz#9f7ee287f82fd326d4fd162923d62129eee0dfaf" dependencies: onetime "^2.0.0" signal-exit "^3.0.2" right-align@^0.1.1: version "0.1.3" resolved "https://registry.yarnpkg.com/right-align/-/right-align-0.1.3.tgz#61339b722fe6a3515689210d24e14c96148613ef" dependencies: align-text "^0.1.1" rimraf@2, rimraf@^2.2.8, rimraf@^2.3.3, rimraf@^2.5.1, rimraf@^2.5.4, rimraf@^2.6.1: version "2.6.1" resolved "https://registry.yarnpkg.com/rimraf/-/rimraf-2.6.1.tgz#c2338ec643df7a1b7fe5c54fa86f57428a55f33d" dependencies: glob "^7.0.5" rollup-plugin-babel-minify@^3.1.2: version "3.1.2" resolved "https://registry.yarnpkg.com/rollup-plugin-babel-minify/-/rollup-plugin-babel-minify-3.1.2.tgz#86a99d00b3d60984281baaeff4eb1f0eb509b053" dependencies: "@comandeer/babel-plugin-banner" "^1.0.0" babel-core "^6.21.0" babel-preset-minify "^0.2.0" rollup-plugin-babel@^3.0.2: version "3.0.2" resolved "https://registry.yarnpkg.com/rollup-plugin-babel/-/rollup-plugin-babel-3.0.2.tgz#a2765dea0eaa8aece351c983573300d17497495b" dependencies: rollup-pluginutils "^1.5.0" rollup-plugin-commonjs@^8.2.1: version "8.2.1" resolved "https://registry.yarnpkg.com/rollup-plugin-commonjs/-/rollup-plugin-commonjs-8.2.1.tgz#5e40c78375eb163c14c76bce69da1750e5905a2e" dependencies: acorn "^5.1.1" estree-walker "^0.5.0" magic-string "^0.22.4" resolve "^1.4.0" rollup-pluginutils "^2.0.1" rollup-plugin-node-resolve@^3.0.0: version "3.0.0" resolved "https://registry.yarnpkg.com/rollup-plugin-node-resolve/-/rollup-plugin-node-resolve-3.0.0.tgz#8b897c4c3030d5001277b0514b25d2ca09683ee0" dependencies: browser-resolve "^1.11.0" builtin-modules "^1.1.0" is-module "^1.0.0" resolve "^1.1.6" rollup-pluginutils@^1.5.0: version "1.5.2" resolved "https://registry.yarnpkg.com/rollup-pluginutils/-/rollup-pluginutils-1.5.2.tgz#1e156e778f94b7255bfa1b3d0178be8f5c552408" dependencies: estree-walker "^0.2.1" minimatch "^3.0.2" rollup-pluginutils@^2.0.1: version "2.0.1" resolved "https://registry.yarnpkg.com/rollup-pluginutils/-/rollup-pluginutils-2.0.1.tgz#7ec95b3573f6543a46a6461bd9a7c544525d0fc0" dependencies: estree-walker "^0.3.0" micromatch "^2.3.11" rollup@^0.49.3: version "0.49.3" resolved "https://registry.yarnpkg.com/rollup/-/rollup-0.49.3.tgz#4cce32643dd8cf2154c69ff0e43470067db0adbf" run-async@^2.2.0: version "2.3.0" resolved "https://registry.yarnpkg.com/run-async/-/run-async-2.3.0.tgz#0371ab4ae0bdd720d4166d7dfda64ff7a445a6c0" dependencies: is-promise "^2.1.0" rx-lite-aggregates@^4.0.8: version "4.0.8" resolved "https://registry.yarnpkg.com/rx-lite-aggregates/-/rx-lite-aggregates-4.0.8.tgz#753b87a89a11c95467c4ac1626c4efc4e05c67be" dependencies: rx-lite "*" rx-lite@*, rx-lite@^4.0.8: version "4.0.8" resolved "https://registry.yarnpkg.com/rx-lite/-/rx-lite-4.0.8.tgz#0b1e11af8bc44836f04a6407e92da42467b79444" safe-buffer@^5.0.1, safe-buffer@^5.1.1, safe-buffer@~5.1.0: version "5.1.1" resolved "https://registry.yarnpkg.com/safe-buffer/-/safe-buffer-5.1.1.tgz#893312af69b2123def71f57889001671eeb2c853" semver-diff@^2.0.0: version "2.1.0" resolved "https://registry.yarnpkg.com/semver-diff/-/semver-diff-2.1.0.tgz#4bbb8437c8d37e4b0cf1a68fd726ec6d645d6d36" dependencies: semver "^5.0.3" "semver@2 || 3 || 4 || 5", semver@^5.0.3, semver@^5.1.0, semver@^5.3.0: version "5.3.0" resolved "https://registry.yarnpkg.com/semver/-/semver-5.3.0.tgz#9b2ce5d3de02d17c6012ad326aa6b4d0cf54f94f" set-blocking@^2.0.0, set-blocking@~2.0.0: version "2.0.0" resolved "https://registry.yarnpkg.com/set-blocking/-/set-blocking-2.0.0.tgz#045f9782d011ae9a6803ddd382b24392b3d890f7" set-immediate-shim@^1.0.1: version "1.0.1" resolved "https://registry.yarnpkg.com/set-immediate-shim/-/set-immediate-shim-1.0.1.tgz#4b2b1b27eb808a9f8dcc481a58e5e56f599f3f61" shebang-command@^1.2.0: version "1.2.0" resolved "https://registry.yarnpkg.com/shebang-command/-/shebang-command-1.2.0.tgz#44aac65b695b03398968c39f363fee5deafdf1ea" dependencies: shebang-regex "^1.0.0" shebang-regex@^1.0.0: version "1.0.0" resolved "https://registry.yarnpkg.com/shebang-regex/-/shebang-regex-1.0.0.tgz#da42f49740c0b42db2ca9728571cb190c98efea3" signal-exit@^3.0.0, signal-exit@^3.0.1, signal-exit@^3.0.2: version "3.0.2" resolved "https://registry.yarnpkg.com/signal-exit/-/signal-exit-3.0.2.tgz#b5fdc08f1287ea1178628e415e25132b73646c6d" slash@^1.0.0: version "1.0.0" resolved "https://registry.yarnpkg.com/slash/-/slash-1.0.0.tgz#c41f2f6c39fc16d1cd17ad4b5d896114ae470d55" slice-ansi@0.0.4: version "0.0.4" resolved "https://registry.yarnpkg.com/slice-ansi/-/slice-ansi-0.0.4.tgz#edbf8903f66f7ce2f8eafd6ceed65e264c831b35" slide@^1.1.5: version "1.1.6" resolved "https://registry.yarnpkg.com/slide/-/slide-1.1.6.tgz#56eb027d65b4d2dce6cb2e2d32c4d4afc9e1d707" sntp@1.x.x: version "1.0.9" resolved "https://registry.yarnpkg.com/sntp/-/sntp-1.0.9.tgz#6541184cc90aeea6c6e7b35e2659082443c66198" dependencies: hoek "2.x.x" sort-keys@^1.1.1, sort-keys@^1.1.2: version "1.1.2" resolved "https://registry.yarnpkg.com/sort-keys/-/sort-keys-1.1.2.tgz#441b6d4d346798f1b4e49e8920adfba0e543f9ad" dependencies: is-plain-obj "^1.0.0" source-map-support@^0.4.0, source-map-support@^0.4.2: version "0.4.15" resolved "https://registry.yarnpkg.com/source-map-support/-/source-map-support-0.4.15.tgz#03202df65c06d2bd8c7ec2362a193056fef8d3b1" dependencies: source-map "^0.5.6" source-map-support@^0.4.15: version "0.4.17" resolved "https://registry.yarnpkg.com/source-map-support/-/source-map-support-0.4.17.tgz#6f2150553e6375375d0ccb3180502b78c18ba430" dependencies: source-map "^0.5.6" source-map@^0.4.4: version "0.4.4" resolved "https://registry.yarnpkg.com/source-map/-/source-map-0.4.4.tgz#eba4f5da9c0dc999de68032d8b4f76173652036b" dependencies: amdefine ">=0.0.4" source-map@^0.5.0, source-map@^0.5.3, source-map@^0.5.6, source-map@~0.5.1: version "0.5.6" resolved "https://registry.yarnpkg.com/source-map/-/source-map-0.5.6.tgz#75ce38f52bf0733c5a7f0c118d81334a2bb5f412" spawn-wrap@^1.3.8: version "1.3.8" resolved "https://registry.yarnpkg.com/spawn-wrap/-/spawn-wrap-1.3.8.tgz#fa2a79b990cbb0bb0018dca6748d88367b19ec31" dependencies: foreground-child "^1.5.6" mkdirp "^0.5.0" os-homedir "^1.0.1" rimraf "^2.3.3" signal-exit "^3.0.2" which "^1.2.4" spdx-correct@~1.0.0: version "1.0.2" resolved "https://registry.yarnpkg.com/spdx-correct/-/spdx-correct-1.0.2.tgz#4b3073d933ff51f3912f03ac5519498a4150db40" dependencies: spdx-license-ids "^1.0.2" spdx-expression-parse@~1.0.0: version "1.0.4" resolved "https://registry.yarnpkg.com/spdx-expression-parse/-/spdx-expression-parse-1.0.4.tgz#9bdf2f20e1f40ed447fbe273266191fced51626c" spdx-license-ids@^1.0.2: version "1.2.2" resolved "https://registry.yarnpkg.com/spdx-license-ids/-/spdx-license-ids-1.2.2.tgz#c9df7a3424594ade6bd11900d596696dc06bac57" sprintf-js@~1.0.2: version "1.0.3" resolved "https://registry.yarnpkg.com/sprintf-js/-/sprintf-js-1.0.3.tgz#04e6926f662895354f3dd015203633b857297e2c" sshpk@^1.7.0: version "1.13.1" resolved "https://registry.yarnpkg.com/sshpk/-/sshpk-1.13.1.tgz#512df6da6287144316dc4c18fe1cf1d940739be3" dependencies: asn1 "~0.2.3" assert-plus "^1.0.0" dashdash "^1.12.0" getpass "^0.1.1" optionalDependencies: bcrypt-pbkdf "^1.0.0" ecc-jsbn "~0.1.1" jsbn "~0.1.0" tweetnacl "~0.14.0" stack-utils@^1.0.0: version "1.0.1" resolved "https://registry.yarnpkg.com/stack-utils/-/stack-utils-1.0.1.tgz#d4f33ab54e8e38778b0ca5cfd3b3afb12db68620" string-width@^1.0.1, string-width@^1.0.2: version "1.0.2" resolved "https://registry.yarnpkg.com/string-width/-/string-width-1.0.2.tgz#118bdf5b8cdc51a2a7e70d211e07e2b0b9b107d3" dependencies: code-point-at "^1.0.0" is-fullwidth-code-point "^1.0.0" strip-ansi "^3.0.0" string-width@^2.0.0: version "2.0.0" resolved "https://registry.yarnpkg.com/string-width/-/string-width-2.0.0.tgz#635c5436cc72a6e0c387ceca278d4e2eec52687e" dependencies: is-fullwidth-code-point "^2.0.0" strip-ansi "^3.0.0" string-width@^2.1.0: version "2.1.0" resolved "https://registry.yarnpkg.com/string-width/-/string-width-2.1.0.tgz#030664561fc146c9423ec7d978fe2457437fe6d0" dependencies: is-fullwidth-code-point "^2.0.0" strip-ansi "^4.0.0" string_decoder@~1.0.0: version "1.0.3" resolved "https://registry.yarnpkg.com/string_decoder/-/string_decoder-1.0.3.tgz#0fc67d7c141825de94282dd536bec6b9bce860ab" dependencies: safe-buffer "~5.1.0" stringstream@~0.0.4: version "0.0.5" resolved "https://registry.yarnpkg.com/stringstream/-/stringstream-0.0.5.tgz#4e484cd4de5a0bbbee18e46307710a8a81621878" strip-ansi@^3.0.0, strip-ansi@^3.0.1: version "3.0.1" resolved "https://registry.yarnpkg.com/strip-ansi/-/strip-ansi-3.0.1.tgz#6a385fb8853d952d5ff05d0e8aaf94278dc63dcf" dependencies: ansi-regex "^2.0.0" strip-ansi@^4.0.0: version "4.0.0" resolved "https://registry.yarnpkg.com/strip-ansi/-/strip-ansi-4.0.0.tgz#a8479022eb1ac368a871389b635262c505ee368f" dependencies: ansi-regex "^3.0.0" strip-ansi@~0.1.0: version "0.1.1" resolved "https://registry.yarnpkg.com/strip-ansi/-/strip-ansi-0.1.1.tgz#39e8a98d044d150660abe4a6808acf70bb7bc991" strip-bom-buf@^1.0.0: version "1.0.0" resolved "https://registry.yarnpkg.com/strip-bom-buf/-/strip-bom-buf-1.0.0.tgz#1cb45aaf57530f4caf86c7f75179d2c9a51dd572" dependencies: is-utf8 "^0.2.1" strip-bom@^2.0.0: version "2.0.0" resolved "https://registry.yarnpkg.com/strip-bom/-/strip-bom-2.0.0.tgz#6219a85616520491f35788bdbf1447a99c7e6b0e" dependencies: is-utf8 "^0.2.0" strip-bom@^3.0.0: version "3.0.0" resolved "https://registry.yarnpkg.com/strip-bom/-/strip-bom-3.0.0.tgz#2334c18e9c759f7bdd56fdef7e9ae3d588e68ed3" strip-eof@^1.0.0: version "1.0.0" resolved "https://registry.yarnpkg.com/strip-eof/-/strip-eof-1.0.0.tgz#bb43ff5598a6eb05d89b59fcd129c983313606bf" strip-indent@^1.0.1: version "1.0.1" resolved "https://registry.yarnpkg.com/strip-indent/-/strip-indent-1.0.1.tgz#0c7962a6adefa7bbd4ac366460a638552ae1a0a2" dependencies: get-stdin "^4.0.1" strip-json-comments@~2.0.1: version "2.0.1" resolved "https://registry.yarnpkg.com/strip-json-comments/-/strip-json-comments-2.0.1.tgz#3c531942e908c2697c0ec344858c286c7ca0a60a" supports-color@^2.0.0: version "2.0.0" resolved "https://registry.yarnpkg.com/supports-color/-/supports-color-2.0.0.tgz#535d045ce6b6363fa40117084629995e9df324c7" supports-color@^3.1.2: version "3.2.3" resolved "https://registry.yarnpkg.com/supports-color/-/supports-color-3.2.3.tgz#65ac0504b3954171d8a64946b2ae3cbb8a5f54f6" dependencies: has-flag "^1.0.0" supports-color@^4.0.0: version "4.2.0" resolved "https://registry.yarnpkg.com/supports-color/-/supports-color-4.2.0.tgz#ad986dc7eb2315d009b4d77c8169c2231a684037" dependencies: has-flag "^2.0.0" symbol-observable@^0.2.2: version "0.2.4" resolved "https://registry.yarnpkg.com/symbol-observable/-/symbol-observable-0.2.4.tgz#95a83db26186d6af7e7a18dbd9760a2f86d08f40" symbol-observable@^1.0.4: version "1.0.4" resolved "https://registry.yarnpkg.com/symbol-observable/-/symbol-observable-1.0.4.tgz#29bf615d4aa7121bdd898b22d4b3f9bc4e2aa03d" table@^4.0.1: version "4.0.1" resolved "https://registry.yarnpkg.com/table/-/table-4.0.1.tgz#a8116c133fac2c61f4a420ab6cdf5c4d61f0e435" dependencies: ajv "^4.7.0" ajv-keywords "^1.0.0" chalk "^1.1.1" lodash "^4.0.0" slice-ansi "0.0.4" string-width "^2.0.0" tailored@^2.7.4: version "2.7.4" resolved "https://registry.yarnpkg.com/tailored/-/tailored-2.7.4.tgz#473c6c91fcaeb2c8e4ddd5c2bddb33190ac21780" dependencies: erlang-types "^1.0.1" tar-pack@^3.4.0: version "3.4.0" resolved "https://registry.yarnpkg.com/tar-pack/-/tar-pack-3.4.0.tgz#23be2d7f671a8339376cbdb0b8fe3fdebf317984" dependencies: debug "^2.2.0" fstream "^1.0.10" fstream-ignore "^1.0.5" once "^1.3.3" readable-stream "^2.1.4" rimraf "^2.5.1" tar "^2.2.1" uid-number "^0.0.6" tar@^2.2.1: version "2.2.1" resolved "https://registry.yarnpkg.com/tar/-/tar-2.2.1.tgz#8e4d2a256c0e2185c6b18ad694aec968b83cb1d1" dependencies: block-stream "*" fstream "^1.0.2" inherits "2" term-size@^0.1.0: version "0.1.1" resolved "https://registry.yarnpkg.com/term-size/-/term-size-0.1.1.tgz#87360b96396cab5760963714cda0d0cbeecad9ca" dependencies: execa "^0.4.0" test-exclude@^4.1.1: version "4.1.1" resolved "https://registry.yarnpkg.com/test-exclude/-/test-exclude-4.1.1.tgz#4d84964b0966b0087ecc334a2ce002d3d9341e26" dependencies: arrify "^1.0.1" micromatch "^2.3.11" object-assign "^4.1.0" read-pkg-up "^1.0.1" require-main-filename "^1.0.1" text-table@^0.2.0, text-table@~0.2.0: version "0.2.0" resolved "https://registry.yarnpkg.com/text-table/-/text-table-0.2.0.tgz#7f5ee823ae805207c00af2df4a84ec3fcfa570b4" through2@^2.0.0: version "2.0.3" resolved "https://registry.yarnpkg.com/through2/-/through2-2.0.3.tgz#0004569b37c7c74ba39c43f3ced78d1ad94140be" dependencies: readable-stream "^2.1.5" xtend "~4.0.1" through@^2.3.6: version "2.3.8" resolved "https://registry.yarnpkg.com/through/-/through-2.3.8.tgz#0dd4c9ffaabc357960b1b724115d7e0e86a2e1f5" time-require@^0.1.2: version "0.1.2" resolved "https://registry.yarnpkg.com/time-require/-/time-require-0.1.2.tgz#f9e12cb370fc2605e11404582ba54ef5ca2b2d98" dependencies: chalk "^0.4.0" date-time "^0.1.1" pretty-ms "^0.2.1" text-table "^0.2.0" time-zone@^1.0.0: version "1.0.0" resolved "https://registry.yarnpkg.com/time-zone/-/time-zone-1.0.0.tgz#99c5bf55958966af6d06d83bdf3800dc82faec5d" timed-out@^4.0.0: version "4.0.1" resolved "https://registry.yarnpkg.com/timed-out/-/timed-out-4.0.1.tgz#f32eacac5a175bea25d7fab565ab3ed8741ef56f" tmp@^0.0.31: version "0.0.31" resolved "https://registry.yarnpkg.com/tmp/-/tmp-0.0.31.tgz#8f38ab9438e17315e5dbd8b3657e8bfb277ae4a7" dependencies: os-tmpdir "~1.0.1" to-fast-properties@^1.0.1, to-fast-properties@^1.0.3: version "1.0.3" resolved "https://registry.yarnpkg.com/to-fast-properties/-/to-fast-properties-1.0.3.tgz#b83571fa4d8c25b82e231b06e3a3055de4ca1a47" tough-cookie@~2.3.0: version "2.3.2" resolved "https://registry.yarnpkg.com/tough-cookie/-/tough-cookie-2.3.2.tgz#f081f76e4c85720e6c37a5faced737150d84072a" dependencies: punycode "^1.4.1" trim-newlines@^1.0.0: version "1.0.0" resolved "https://registry.yarnpkg.com/trim-newlines/-/trim-newlines-1.0.0.tgz#5887966bb582a4503a41eb524f7d35011815a613" trim-off-newlines@^1.0.1: version "1.0.1" resolved "https://registry.yarnpkg.com/trim-off-newlines/-/trim-off-newlines-1.0.1.tgz#9f9ba9d9efa8764c387698bcbfeb2c848f11adb3" trim-right@^1.0.1: version "1.0.1" resolved "https://registry.yarnpkg.com/trim-right/-/trim-right-1.0.1.tgz#cb2e1203067e0c8de1f614094b9fe45704ea6003" tryit@^1.0.1: version "1.0.3" resolved "https://registry.yarnpkg.com/tryit/-/tryit-1.0.3.tgz#393be730a9446fd1ead6da59a014308f36c289cb" tunnel-agent@^0.6.0: version "0.6.0" resolved "https://registry.yarnpkg.com/tunnel-agent/-/tunnel-agent-0.6.0.tgz#27a5dea06b36b04a0a9966774b290868f0fc40fd" dependencies: safe-buffer "^5.0.1" tweetnacl@^0.14.3, tweetnacl@~0.14.0: version "0.14.5" resolved "https://registry.yarnpkg.com/tweetnacl/-/tweetnacl-0.14.5.tgz#5ae68177f192d4456269d108afa93ff8743f4f64" type-check@~0.3.2: version "0.3.2" resolved "https://registry.yarnpkg.com/type-check/-/type-check-0.3.2.tgz#5884cab512cf1d355e3fb784f30804b2b520db72" dependencies: prelude-ls "~1.1.2" typedarray@^0.0.6: version "0.0.6" resolved "https://registry.yarnpkg.com/typedarray/-/typedarray-0.0.6.tgz#867ac74e3864187b1d3d47d996a78ec5c8830777" uglify-js@^2.6: version "2.8.29" resolved "https://registry.yarnpkg.com/uglify-js/-/uglify-js-2.8.29.tgz#29c5733148057bb4e1f75df35b7a9cb72e6a59dd" dependencies: source-map "~0.5.1" yargs "~3.10.0" optionalDependencies: uglify-to-browserify "~1.0.0" uglify-to-browserify@~1.0.0: version "1.0.2" resolved "https://registry.yarnpkg.com/uglify-to-browserify/-/uglify-to-browserify-1.0.2.tgz#6e0924d6bda6b5afe349e39a6d632850a0f882b7" uid-number@^0.0.6: version "0.0.6" resolved "https://registry.yarnpkg.com/uid-number/-/uid-number-0.0.6.tgz#0ea10e8035e8eb5b8e4449f06da1c730663baa81" uid2@0.0.3: version "0.0.3" resolved "https://registry.yarnpkg.com/uid2/-/uid2-0.0.3.tgz#483126e11774df2f71b8b639dcd799c376162b82" unique-string@^1.0.0: version "1.0.0" resolved "https://registry.yarnpkg.com/unique-string/-/unique-string-1.0.0.tgz#9e1057cca851abb93398f8b33ae187b99caec11a" dependencies: crypto-random-string "^1.0.0" unique-temp-dir@^1.0.0: version "1.0.0" resolved "https://registry.yarnpkg.com/unique-temp-dir/-/unique-temp-dir-1.0.0.tgz#6dce95b2681ca003eebfb304a415f9cbabcc5385" dependencies: mkdirp "^0.5.1" os-tmpdir "^1.0.1" uid2 "0.0.3" unzip-response@^2.0.1: version "2.0.1" resolved "https://registry.yarnpkg.com/unzip-response/-/unzip-response-2.0.1.tgz#d2f0f737d16b0615e72a6935ed04214572d56f97" update-notifier@^2.1.0: version "2.2.0" resolved "https://registry.yarnpkg.com/update-notifier/-/update-notifier-2.2.0.tgz#1b5837cf90c0736d88627732b661c138f86de72f" dependencies: boxen "^1.0.0" chalk "^1.0.0" configstore "^3.0.0" import-lazy "^2.1.0" is-npm "^1.0.0" latest-version "^3.0.0" semver-diff "^2.0.0" xdg-basedir "^3.0.0" url-parse-lax@^1.0.0: version "1.0.0" resolved "https://registry.yarnpkg.com/url-parse-lax/-/url-parse-lax-1.0.0.tgz#7af8f303645e9bd79a272e7a14ac68bc0609da73" dependencies: prepend-http "^1.0.1" util-deprecate@~1.0.1: version "1.0.2" resolved "https://registry.yarnpkg.com/util-deprecate/-/util-deprecate-1.0.2.tgz#450d4dc9fa70de732762fbd2d4a28981419a0ccf" uuid@^3.0.0: version "3.1.0" resolved "https://registry.yarnpkg.com/uuid/-/uuid-3.1.0.tgz#3dd3d3e790abc24d7b0d3a034ffababe28ebbc04" validate-npm-package-license@^3.0.1: version "3.0.1" resolved "https://registry.yarnpkg.com/validate-npm-package-license/-/validate-npm-package-license-3.0.1.tgz#2804babe712ad3379459acfbe24746ab2c303fbc" dependencies: spdx-correct "~1.0.0" spdx-expression-parse "~1.0.0" verror@1.3.6: version "1.3.6" resolved "https://registry.yarnpkg.com/verror/-/verror-1.3.6.tgz#cff5df12946d297d2baaefaa2689e25be01c005c" dependencies: extsprintf "1.0.2" vlq@^0.2.1: version "0.2.2" resolved "https://registry.yarnpkg.com/vlq/-/vlq-0.2.2.tgz#e316d5257b40b86bb43cb8d5fea5d7f54d6b0ca1" well-known-symbols@^1.0.0: version "1.0.0" resolved "https://registry.yarnpkg.com/well-known-symbols/-/well-known-symbols-1.0.0.tgz#73c78ae81a7726a8fa598e2880801c8b16225518" which-module@^2.0.0: version "2.0.0" resolved "https://registry.yarnpkg.com/which-module/-/which-module-2.0.0.tgz#d9ef07dce77b9902b8a3a8fa4b31c3e3f7e6e87a" which@^1.2.4, which@^1.2.8, which@^1.2.9: version "1.2.14" resolved "https://registry.yarnpkg.com/which/-/which-1.2.14.tgz#9a87c4378f03e827cecaf1acdf56c736c01c14e5" dependencies: isexe "^2.0.0" wide-align@^1.1.0: version "1.1.2" resolved "https://registry.yarnpkg.com/wide-align/-/wide-align-1.1.2.tgz#571e0f1b0604636ebc0dfc21b0339bbe31341710" dependencies: string-width "^1.0.2" widest-line@^1.0.0: version "1.0.0" resolved "https://registry.yarnpkg.com/widest-line/-/widest-line-1.0.0.tgz#0c09c85c2a94683d0d7eaf8ee097d564bf0e105c" dependencies: string-width "^1.0.1" window-size@0.1.0: version "0.1.0" resolved "https://registry.yarnpkg.com/window-size/-/window-size-0.1.0.tgz#5438cd2ea93b202efa3a19fe8887aee7c94f9c9d" wordwrap@0.0.2: version "0.0.2" resolved "https://registry.yarnpkg.com/wordwrap/-/wordwrap-0.0.2.tgz#b79669bb42ecb409f83d583cad52ca17eaa1643f" wordwrap@~0.0.2: version "0.0.3" resolved "https://registry.yarnpkg.com/wordwrap/-/wordwrap-0.0.3.tgz#a3d5da6cd5c0bc0008d37234bbaf1bed63059107" wordwrap@~1.0.0: version "1.0.0" resolved "https://registry.yarnpkg.com/wordwrap/-/wordwrap-1.0.0.tgz#27584810891456a4171c8d0226441ade90cbcaeb" wrap-ansi@^2.0.0: version "2.1.0" resolved "https://registry.yarnpkg.com/wrap-ansi/-/wrap-ansi-2.1.0.tgz#d8fc3d284dd05794fe84973caecdd1cf824fdd85" dependencies: string-width "^1.0.1" strip-ansi "^3.0.1" wrappy@1: version "1.0.2" resolved "https://registry.yarnpkg.com/wrappy/-/wrappy-1.0.2.tgz#b5243d8f3ec1aa35f1364605bc0d1036e30ab69f" write-file-atomic@^1.1.4: version "1.3.4" resolved "https://registry.yarnpkg.com/write-file-atomic/-/write-file-atomic-1.3.4.tgz#f807a4f0b1d9e913ae7a48112e6cc3af1991b45f" dependencies: graceful-fs "^4.1.11" imurmurhash "^0.1.4" slide "^1.1.5" write-file-atomic@^2.0.0: version "2.1.0" resolved "https://registry.yarnpkg.com/write-file-atomic/-/write-file-atomic-2.1.0.tgz#1769f4b551eedce419f0505deae2e26763542d37" dependencies: graceful-fs "^4.1.11" imurmurhash "^0.1.4" slide "^1.1.5" write-json-file@^2.0.0: version "2.2.0" resolved "https://registry.yarnpkg.com/write-json-file/-/write-json-file-2.2.0.tgz#51862506bbb3b619eefab7859f1fd6c6d0530876" dependencies: detect-indent "^5.0.0" graceful-fs "^4.1.2" make-dir "^1.0.0" pify "^2.0.0" sort-keys "^1.1.1" write-file-atomic "^2.0.0" write-pkg@^2.0.0: version "2.1.0" resolved "https://registry.yarnpkg.com/write-pkg/-/write-pkg-2.1.0.tgz#353aa44c39c48c21440f5c08ce6abd46141c9c08" dependencies: sort-keys "^1.1.2" write-json-file "^2.0.0" write@^0.2.1: version "0.2.1" resolved "https://registry.yarnpkg.com/write/-/write-0.2.1.tgz#5fc03828e264cea3fe91455476f7a3c566cb0757" dependencies: mkdirp "^0.5.1" xdg-basedir@^3.0.0: version "3.0.0" resolved "https://registry.yarnpkg.com/xdg-basedir/-/xdg-basedir-3.0.0.tgz#496b2cc109eca8dbacfe2dc72b603c17c5870ad4" xtend@^4.0.0, xtend@~4.0.1: version "4.0.1" resolved "https://registry.yarnpkg.com/xtend/-/xtend-4.0.1.tgz#a5c6d532be656e23db820efb943a1f04998d63af" y18n@^3.2.1: version "3.2.1" resolved "https://registry.yarnpkg.com/y18n/-/y18n-3.2.1.tgz#6d15fba884c08679c0d77e88e7759e811e07fa41" yallist@^2.1.2: version "2.1.2" resolved "https://registry.yarnpkg.com/yallist/-/yallist-2.1.2.tgz#1c11f9218f076089a47dd512f93c6699a6a81d52" yargs-parser@^5.0.0: version "5.0.0" resolved "https://registry.yarnpkg.com/yargs-parser/-/yargs-parser-5.0.0.tgz#275ecf0d7ffe05c77e64e7c86e4cd94bf0e1228a" dependencies: camelcase "^3.0.0" yargs-parser@^7.0.0: version "7.0.0" resolved "https://registry.yarnpkg.com/yargs-parser/-/yargs-parser-7.0.0.tgz#8d0ac42f16ea55debd332caf4c4038b3e3f5dfd9" dependencies: camelcase "^4.1.0" yargs@^8.0.1: version "8.0.2" resolved "https://registry.yarnpkg.com/yargs/-/yargs-8.0.2.tgz#6299a9055b1cefc969ff7e79c1d918dceb22c360" dependencies: camelcase "^4.1.0" cliui "^3.2.0" decamelize "^1.1.1" get-caller-file "^1.0.1" os-locale "^2.0.0" read-pkg-up "^2.0.0" require-directory "^2.1.1" require-main-filename "^1.0.1" set-blocking "^2.0.0" string-width "^2.0.0" which-module "^2.0.0" y18n "^3.2.1" yargs-parser "^7.0.0" yargs@~3.10.0: version "3.10.0" resolved "https://registry.yarnpkg.com/yargs/-/yargs-3.10.0.tgz#f7ee7bd857dd7c1d2d38c0e74efbd681d1431fd1" dependencies: camelcase "^1.0.2" cliui "^2.1.0" decamelize "^1.0.0" window-size "0.1.0"