pax_global_header00006660000000000000000000000064132532733420014516gustar00rootroot0000000000000052 comment=95e3c30eb8457b7d100b5a1be9cf8c90a478f098 elixirscript-0.32.1/000077500000000000000000000000001325327334200143225ustar00rootroot00000000000000elixirscript-0.32.1/.babelrc000066400000000000000000000001731325327334200157160ustar00rootroot00000000000000{ "presets": [ [ "env", { "targets": { "node": "current" } } ] ] } elixirscript-0.32.1/.credo.exs000066400000000000000000000111631325327334200162170ustar00rootroot00000000000000# 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, ignore_specs: true }, {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, false}, {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.32.1/.ebert.yml000066400000000000000000000003711325327334200162250ustar00rootroot00000000000000styleguide: elixirscript/elixirscript engines: credo: enabled: true fixme: enabled: true eslint: enabled: true remark-lint: enabled: true exclude_paths: - config - test - priv/testrunner/vendor.build.js - priv/testrunner/esm elixirscript-0.32.1/.eslintrc.js000066400000000000000000000006271325327334200165660ustar00rootroot00000000000000module.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.32.1/.gitignore000066400000000000000000000004531325327334200163140ustar00rootroot00000000000000/_build /deps erl_crash.dump *.ez ex2js elixirscript node_modules /dist deploy.sh .DS_Store sample/dest fprof.trace /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/build /tmp .esm-cache .elixir_ls elixirscript-0.32.1/.tool-versions000066400000000000000000000000551325327334200171460ustar00rootroot00000000000000erlang 20.1 elixir 1.6.0-otp-20 nodejs 8.9.1 elixirscript-0.32.1/.travis.yml000066400000000000000000000013701325327334200164340ustar00rootroot00000000000000sudo: false language: elixir elixir: - 1.6.0 otp_release: - 20.2 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 - mix local.hex --force - mix local.rebar --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.32.1/CHANGELOG.md000066400000000000000000000556561325327334200161540ustar00rootroot00000000000000# 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.32.1] - 2018-03-17 ### Fixed * Global JavaScript modules not compiling correctly ## [0.32.0] - 2018-02-10 ### Added * `ElixirScript.Test` for testing ElixirScript modules in JavaScript. ElixirScript.Test is for unit testing modules that interact with JavaScript in some way. For modules that are can be used in both Elixir and ElixirScript, ExUnit is still preferred. Tests that use ElixirScript.Test must be placed in a `test_elixir_script` folder in the root of your project. These tests are run using node.js. The API for ElixirScript.Test is meant to be as close to ExUnit as possible. ### Changed * ElixirScript now requires Elixir 1.6. This is so that ElixirScript can use the new `Mix.Task.Compiler` behaviour. * `mix clean` will now correctly clean up ElixirScript output. * Compiler will now output a JavaScript file per Elixir module. * Modules with a start function **must** be started directly. ```elixir # Before ElixirScript 0.32.0: import Elixir from './elixirscript.build.js' Elixir.start(Elixir.Main, [1, 2, 3]) # ElixirScript 0.32.0 and later: import Main from './Elixir.Main.js' Main.start(Symbol.for('normal'), [1, 2, 3]) ``` ## [0.31.1] - 2017-09-27 ### Fixed * Compiler error when `receive` is used as variable name ## [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.32.1/CONTRIBUTING.md000066400000000000000000000133531325327334200165600ustar00rootroot00000000000000# 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.32.1/JavascriptInterop.md000066400000000000000000000051041325327334200203130ustar00rootroot00000000000000# 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 Main from './Elixir.Main.js' Main.start(Symbol.for('normal'), [1, 2, 3]) ``` In the above example, we have an ElixirScript module, `Main` with a `start/2` function. If you want to use an ElixirScript module inside of your JavaScript code, you can do so like below. ```Elixir # Our ElixirScript module defmodule MyModule do def hi() do "hello" end end ``` ```javascript import MyModule from './Elixir.MyModule.js' MyModule.hi() ``` elixirscript-0.32.1/LICENSE000066400000000000000000000020661325327334200153330ustar00rootroot00000000000000The 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.32.1/Makefile000066400000000000000000000006631325327334200157670ustar00rootroot00000000000000.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 mix elixirscript.test clean: rm -rf priv/build mix clean deps: elixir_deps js_deps elixir_deps: mix deps.get js_deps: yarn elixirscript-0.32.1/README.md000066400000000000000000000046631325327334200156120ustar00rootroot00000000000000## 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. [Documentation for current release](http://hexdocs.pm/elixir_script/) 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 compiler 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.32.1/config/000077500000000000000000000000001325327334200155675ustar00rootroot00000000000000elixirscript-0.32.1/config/config.exs000066400000000000000000000022001325327334200175470ustar00rootroot00000000000000# 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.32.1/config/dev.exs000066400000000000000000000000171325327334200170640ustar00rootroot00000000000000use Mix.Config elixirscript-0.32.1/config/prod.exs000066400000000000000000000000171325327334200172520ustar00rootroot00000000000000use Mix.Config elixirscript-0.32.1/config/test.exs000066400000000000000000000000171325327334200172650ustar00rootroot00000000000000use Mix.Config elixirscript-0.32.1/lib/000077500000000000000000000000001325327334200150705ustar00rootroot00000000000000elixirscript-0.32.1/lib/elixir_script.ex000066400000000000000000000065271325327334200203200ustar00rootroot00000000000000defmodule 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" ] ] end ``` Available options are: * `input` (required): The entry module(s) for your application or library * `output`: The path of the generated JavaScript files. (defaults to `priv/elixir_script/build`) This should be a directory. If given a file, it will dump JavaScript files into the same directory as the given file path * `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.32.1/lib/elixir_script/000077500000000000000000000000001325327334200177505ustar00rootroot00000000000000elixirscript-0.32.1/lib/elixir_script/beam.ex000066400000000000000000000077511325327334200212240ustar00rootroot00000000000000defmodule 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, map} | {:ok, atom, map, list} | {:error, 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, beam_path) 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 info = Map.put(info, :beam_path, beam_path) {:ok, info} end defp process_debug_info(error, _) do error end defp get_protocol_implementations(module, beam_path) do {:ok, protocol_module_info} = process_debug_info({:ok, %{}}, beam_path) 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 ElixirScript.CompileError, message: "Unable to compile protocol implementation #{inspect(x)}", severity: :error end end) {:ok, module, protocol_module_info, 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.32.1/lib/elixir_script/cli.ex000066400000000000000000000040311325327334200210530ustar00rootroot00000000000000defmodule 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.32.1/lib/elixir_script/compile_error.ex000066400000000000000000000001201325327334200231400ustar00rootroot00000000000000defmodule ElixirScript.CompileError do defexception [:message, :severity] end elixirscript-0.32.1/lib/elixir_script/compiler.ex000066400000000000000000000115441325327334200221250ustar00rootroot00000000000000defmodule 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 @type compiler_input :: atom | [atom] | binary @spec compile(compiler_input, []) :: map def compile(path, opts \\ []) def compile(path, opts) when is_binary(path) do opts = build_compiler_options(opts) {:ok, pid} = State.start_link(opts) 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(opts) 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) if opts.remove_unused_functions do FindUsedFunctions.execute(entry_modules, pid) end modules = State.list_modules(pid) Translate.execute(modules, pid) modules = State.list_modules(pid) result = Output.execute(modules, pid, opts) State.stop(pid) transform_output(modules, result, opts) end defp build_compiler_options(opts) do remove_used_functions? = Keyword.get(opts, :remove_unused_functions, true) default_options = Map.new() |> Map.put(:output, Keyword.get(opts, :output)) |> Map.put(:format, :es) |> Map.put(:root, Keyword.get(opts, :root, ".")) |> Map.put(:remove_unused_functions, remove_used_functions?) 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 defp transform_output(modules, compiled_js, opts) do output_path = cond do opts.output == nil or opts.output == :stdout -> "" File.dir?(opts.output) -> opts.output true -> Path.dirname(opts.output) end data = %{ ElixirScript.Core => %{ references: [], last_modified: nil, beam_path: nil, source: nil, js_path: Path.join(output_path, "ElixirScript.Core.js"), diagnostics: [], js_code: nil, type: :ffi } } Enum.reduce(modules, data, fn {module, info}, current_data -> diagnostics = Map.get(info, :diagnostics, []) |> Enum.map(fn x -> Map.put(x, :file, Map.get(info, :file)) end) info = %{ references: Map.get(info, :used_modules, []), last_modified: Map.get(info, :last_modified, nil), beam_path: Map.get(info, :beam_path), source: Map.get(info, :file), js_path: Path.join(output_path, "#{module}.js"), diagnostics: diagnostics } info = case Keyword.get(compiled_js, module) do [js_input_path, js_output_path] -> last_modified = case File.stat(js_input_path, time: :posix) do {:ok, file_info} -> file_info.mtime _ -> nil end info |> Map.put(:last_modified, last_modified) |> Map.put(:beam_path, nil) |> Map.put(:source, js_input_path) |> Map.put(:js_path, js_output_path) |> Map.put(:js_code, nil) |> Map.put(:type, :ffi) js_code -> info |> Map.put(:js_path, Path.join(output_path, "#{module}.js")) |> Map.put(:js_code, js_code) |> Map.put(:type, :module) end Map.put(current_data, module, info) end) end end elixirscript-0.32.1/lib/elixir_script/ffi.ex000066400000000000000000000061721325327334200210600ustar00rootroot00000000000000defmodule 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.32.1/lib/elixir_script/lib/000077500000000000000000000000001325327334200205165ustar00rootroot00000000000000elixirscript-0.32.1/lib/elixir_script/lib/agent.ex000066400000000000000000000020541325327334200221530ustar00rootroot00000000000000defmodule 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.32.1/lib/elixir_script/lib/functions.ex000066400000000000000000000002541325327334200230650ustar00rootroot00000000000000defmodule ElixirScript.Core.Functions do @moduledoc false use ElixirScript.FFI, global: true defexternal split_at(value, position) defexternal graphemes(str) end elixirscript-0.32.1/lib/elixir_script/lib/js.ex000066400000000000000000000036441325327334200214770ustar00rootroot00000000000000defmodule 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.32.1/lib/elixir_script/lib/store.ex000066400000000000000000000003411325327334200222060ustar00rootroot00000000000000defmodule 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.32.1/lib/elixir_script/lib/string.ex000066400000000000000000000071111325327334200223620ustar00rootroot00000000000000defmodule 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.32.1/lib/elixir_script/manifest.ex000066400000000000000000000012531325327334200221150ustar00rootroot00000000000000defmodule ElixirScript.Manifest do @moduledoc false @spec read_manifest(binary) :: nil def read_manifest(manifest_path) do if File.exists?(manifest_path) do manifest_path |> File.read!() |> :erlang.binary_to_term() else %{} end end @spec write_manifest(binary, map) :: :ok def write_manifest(manifest_path, modules) do data = Enum.reduce(modules, %{}, fn {module, info}, current_data -> Map.put(current_data, module, Map.drop(info, [:js_code])) end) data = :erlang.term_to_binary(data, [:compressed]) File.mkdir_p!(Path.dirname(manifest_path)) File.write!(manifest_path, data) :ok end end elixirscript-0.32.1/lib/elixir_script/module_systems/000077500000000000000000000000001325327334200230245ustar00rootroot00000000000000elixirscript-0.32.1/lib/elixir_script/module_systems/es.ex000066400000000000000000000023101325327334200237650ustar00rootroot00000000000000defmodule ElixirScript.ModuleSystems.ES do @moduledoc false alias ESTree.Tools.Builder, as: JS def build(js_imports, body, exports) do imports = js_imports |> Enum.filter(fn {_module, _name, nil, _import_path} -> false _ -> true end) |> 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.32.1/lib/elixir_script/module_systems/namespace.ex000066400000000000000000000033001325327334200253120ustar00rootroot00000000000000defmodule 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.32.1/lib/elixir_script/passes/000077500000000000000000000000001325327334200212465ustar00rootroot00000000000000elixirscript-0.32.1/lib/elixir_script/passes/find_used_functions.ex000066400000000000000000000167631325327334200256510ustar00rootroot00000000000000defmodule 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, _, _, _} -> name not in unreachable _ -> true end) state = %{ pid: pid, module: module } Enum.each(reachable_defs, fn {name, _type, _, _clauses} -> ModuleState.put_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.put_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.32.1/lib/elixir_script/passes/find_used_modules.ex000066400000000000000000000243241325327334200253010ustar00rootroot00000000000000defmodule 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) :: :ok def execute(modules, pid) do modules |> List.wrap() |> Enum.each(fn module -> do_execute(module, pid) end) end defp do_execute(module, result, pid) do case result do {:ok, info} -> walk_module(module, info, pid) {:ok, module, module_info, implementations} -> walk_protocol(module, module_info, implementations, pid) {:error, "Unknown module"} -> Logger.warn(fn -> "ElixirScript: #{inspect(module)} is missing or unavailable" end) ModuleState.put_diagnostic(pid, module, %{ severity: :warning, message: "#{inspect(module)} is missing or unavailable" }) {:error, error} -> raise ElixirScript.CompileError, message: "An error occurred while compiling #{inspect(module)}: #{error}", severity: :error end end defp do_execute(module, pid) do result = get_debug_info(module, pid) do_execute(module, result, pid) end defp get_debug_info(module, pid) do case ModuleState.get_in_memory_module(pid, module) do nil -> ElixirScript.Beam.debug_info(module) beam -> ElixirScript.Beam.debug_info(beam) 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, _, _, _} -> name not in unreachable _ -> true end) state = %{ pid: pid, module: module } Enum.each(reachable_defs, fn x -> walk(x, state) end) end defp walk_protocol(module, module_info, 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) module_info = Map.merge(module_info, %{protocol: true, impls: impls, functions: functions}) ModuleState.put_module(pid, module, module_info) Enum.each(implementations, fn {impl, info} -> ModuleState.put_used_module(pid, module, impl) 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(args, state) walk(guards, state) 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 case get_debug_info(form, state.pid) do {:ok, _} = result -> ModuleState.put_used_module(state.pid, state.module, form) do_execute(form, result, state.pid) result -> do_execute(form, result, state.pid) end else ModuleState.put_used_module(state.pid, state.module, form) 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 case get_debug_info(module, state.pid) do {:ok, _} = result -> ModuleState.put_used_module(state.pid, state.module, module) do_execute(module, result, state.pid) result -> do_execute(module, result, state.pid) end else ModuleState.put_used_module(state.pid, state.module, module) 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 walk(Enum, state) 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]} -> Enum.each(names, &walk(&1, state)) walk({[], [param], [{{:., [], [Enum, :member?]}, [], [names, param]}], 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 if ElixirScript.Translate.Module.is_elixir_module(module) do if ModuleState.get_module(state.pid, module) == nil do case get_debug_info(module, state.pid) do {:ok, _} = result -> ModuleState.put_used_module(state.pid, state.module, module) do_execute(module, result, state.pid) result -> do_execute(module, result, state.pid) end else ModuleState.put_used_module(state.pid, state.module, module) end else 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.32.1/lib/elixir_script/passes/output.ex000066400000000000000000000106251325327334200231500ustar00rootroot00000000000000defmodule ElixirScript.Output do @moduledoc false alias ElixirScript.State, as: ModuleState alias ESTree.Tools.{Builder, Generator} @doc """ Takes outputs the JavaScript code in the specified output """ @spec execute([atom], pid, map) :: [{atom, binary}] def execute(modules, pid, opts) do 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) prepared_modules = modules |> Enum.filter(fn {_, info} -> Map.has_key?(info, :js_ast) end) |> Enum.map(fn {module, info} -> {module, info.js_ast, filter_used_modules(info.used_modules, pid)} end) create_modules(prepared_modules, opts, js_modules) end defp filter_used_modules(used_modules, pid) do used_modules |> Enum.filter(fn module -> module in ModuleState.list_javascript_modules(pid) == false end) end defp concat(code) do """ 'use strict'; import ElixirScript from './ElixirScript.Core.js'; #{code} """ end defp create_modules(modules, opts, js_modules) do modules |> Task.async_stream( fn {module, [body, exports], used_modules} -> modules = modules_to_import(used_modules) ++ js_modules imports = opts.module_formatter.build_imports(modules) exports = opts.module_formatter.build_export(exports) js_parts = List.wrap(imports) ++ body ++ List.wrap(exports) js_parts |> Builder.program() |> Generator.generate() |> concat |> output(module, Map.get(opts, :output), js_modules) end, timeout: 10_000 ) |> Stream.map(fn {:ok, code} -> code end) |> Enum.to_list() |> List.flatten() |> Enum.uniq() end defp modules_to_import(modules) do Enum.map(modules, &module_to_import(&1)) end defp module_to_import(module) do {module, module_to_name(module), "", "./Elixir.#{inspect(module)}.js"} end def module_to_name(module) do "$#{inspect(module)}$" |> String.replace(".", "$") end defp output(code, module, nil, _), do: [{module, code}] defp output(code, module, :stdout, _) do IO.puts(code) [{module, code}] end defp output(code, module, path, js_modules) do output_dir = case Path.extname(path) do "" -> path _ -> Path.dirname(path) end file_name = Path.join(output_dir, "Elixir.#{inspect(module)}.js") if !File.exists?(output_dir) do File.mkdir_p!(output_dir) end apps = get_app_names() ffi_modules = Enum.reduce(js_modules, [], fn {module, _, path, _}, acc -> acc ++ copy_javascript_module(apps, output_dir, module, path) end) copy_bootstrap_js(output_dir) File.write!(file_name, code) [{module, code}] ++ ffi_modules end defp copy_bootstrap_js(directory) do operating_path = Path.join([Mix.Project.build_path(), "lib", "elixir_script", "priv"]) path = Path.join([operating_path, "build", "es", "ElixirScript.Core.js"]) File.cp!(path, Path.join([directory, "ElixirScript.Core.js"])) 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, module, js_module_path) do Enum.reduce(apps, [], fn app, acc -> 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) acc ++ [{module, [js_input_path, js_output_path]}] else acc end end) end defp slashes_to_dots(js_module_path) do js_module_path |> String.replace("/", ".") end end elixirscript-0.32.1/lib/elixir_script/passes/output/000077500000000000000000000000001325327334200226065ustar00rootroot00000000000000elixirscript-0.32.1/lib/elixir_script/passes/output/js_module.ex000066400000000000000000000005021325327334200251220ustar00rootroot00000000000000defmodule ElixirScript.Output.JSModule do @moduledoc false alias ESTree.Tools.Builder, as: J def compile(body, opts, js_modules) do imports = opts.module_formatter.build_imports(js_modules) exports = opts.module_formatter.build_export(J.identifier("Elixir")) [imports] ++ body ++ [exports] end end elixirscript-0.32.1/lib/elixir_script/passes/translate.ex000066400000000000000000000007371325327334200236100ustar00rootroot00000000000000defmodule 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, timeout: 10_000) |> Stream.run() end end elixirscript-0.32.1/lib/elixir_script/passes/translate/000077500000000000000000000000001325327334200232435ustar00rootroot00000000000000elixirscript-0.32.1/lib/elixir_script/passes/translate/clause.ex000066400000000000000000000055231325327334200250620ustar00rootroot00000000000000defmodule 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.32.1/lib/elixir_script/passes/translate/form.ex000066400000000000000000000257251325327334200245570ustar00rootroot00000000000000defmodule 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 alias ElixirScript.State, as: ModuleState 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 = cond do ElixirScript.Translate.Module.is_elixir_module(form) and ModuleState.get_module(state.pid, form) != nil -> Remote.process_module_name(form, state) ElixirScript.Translate.Module.is_elixir_module(form) -> J.object_expression([]) true -> 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) module = Map.get(state, :module) pid = Map.get(state, :pid) {function, _arity} = Map.get(state, :function) ModuleState.put_diagnostic(pid, module, %{ severity: :warning, message: "receive not supported, Module: #{inspect(state.module)}, Function: #{function}", position: line }) 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_var, _, atom} = left, right]} = ast, acc when is_atom(atom) -> case Atom.to_string(left_var) do "_" <> _ -> {compile!(right, state), acc} _ -> {ast, state} = compile(ast, state) left = compile!(left, state) {left, acc ++ List.wrap(ast)} end {:=, _, [left, _]} = ast, acc -> {ast, state} = compile(ast, state) left = compile!(left, state) {left, acc ++ List.wrap(ast)} x, acc -> compiled = compile!(x, state) {compiled, acc} end) {var_decs, params} end end elixirscript-0.32.1/lib/elixir_script/passes/translate/forms/000077500000000000000000000000001325327334200243715ustar00rootroot00000000000000elixirscript-0.32.1/lib/elixir_script/passes/translate/forms/bitstring.ex000066400000000000000000000103041325327334200267320ustar00rootroot00000000000000defmodule 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.32.1/lib/elixir_script/passes/translate/forms/for.ex000066400000000000000000000072661325327334200255300ustar00rootroot00000000000000defmodule ElixirScript.Translate.Forms.For do @moduledoc false alias ESTree.Tools.Builder, as: JS alias ElixirScript.Translate.{Form, Clause, Helpers} 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] ) collectable = JS.identifier("Collectable") 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)} ([do: expression2, into: expression], state) -> fun = create_function_expression(expression2, state, module_state) %{state | into: Form.compile!(expression, module_state), fun: fun} ([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 = ast |> ElixirScript.Translate.Function.compile_block(module_state) |> elem(0) |> Clause.return_last_statement Helpers.arrow_function( state.args, JS.block_statement(ast) ) end end elixirscript-0.32.1/lib/elixir_script/passes/translate/forms/js.ex000066400000000000000000000064051325327334200253500ustar00rootroot00000000000000defmodule 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.32.1/lib/elixir_script/passes/translate/forms/map.ex000066400000000000000000000030651325327334200255100ustar00rootroot00000000000000defmodule 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.32.1/lib/elixir_script/passes/translate/forms/match.ex000066400000000000000000000067551325327334200260400ustar00rootroot00000000000000defmodule 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_decs, right_ast} = case right_ast do x when is_list(x) -> l = Enum.reverse(x) [head | tail] = l l = Enum.reverse(tail) {l, head} x -> {[], 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 { var_decs ++ 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.32.1/lib/elixir_script/passes/translate/forms/pattern.ex000066400000000000000000000166601325327334200264150ustar00rootroot00000000000000defmodule 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.32.1/lib/elixir_script/passes/translate/forms/pattern/000077500000000000000000000000001325327334200260465ustar00rootroot00000000000000elixirscript-0.32.1/lib/elixir_script/passes/translate/forms/pattern/patterns.ex000066400000000000000000000030411325327334200302420ustar00rootroot00000000000000defmodule 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.32.1/lib/elixir_script/passes/translate/forms/receive.ex000066400000000000000000000021761325327334200263570ustar00rootroot00000000000000defmodule 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.32.1/lib/elixir_script/passes/translate/forms/remote.ex000066400000000000000000000076101325327334200262260ustar00rootroot00000000000000defmodule ElixirScript.Translate.Forms.Remote do @moduledoc false alias ESTree.Tools.Builder, as: J alias ElixirScript.Translate.{Form, 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({:., _, [:erlang, :"=<"]}, state) do ast = erlang_compat_function("erlang", "lessThanEqualTo") {ast, state} end def compile({:., _, [:erlang, :+]}, state) do ast = erlang_compat_function("erlang", "add") {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) and ModuleState.is_global_module(state.pid, module) -> process_global_js_module_name(module, state) ElixirScript.Translate.Module.is_js_module(module, state) -> process_js_module_name(module, state) module === Elixir -> module |> ElixirScript.Output.module_to_name() |> J.identifier() module === :ElixirScript -> module |> ElixirScript.Output.module_to_name() |> J.identifier() ElixirScript.Translate.Module.is_elixir_module(module) -> module |> ElixirScript.Output.module_to_name() |> J.identifier() true -> ElixirScript.Translate.Identifier.make_identifier(module) end end def process_module_name(module, state) do Form.compile!(module, state) end defp process_global_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." <> _ -> ElixirScript.Translate.Identifier.make_alias(Module.split(name) |> Enum.reverse()) x -> J.identifier(x) end end 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." <> _ -> module |> ElixirScript.Output.module_to_name() |> J.identifier() 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.32.1/lib/elixir_script/passes/translate/forms/try.ex000066400000000000000000000064001325327334200255450ustar00rootroot00000000000000defmodule 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, _, [{:_, context, atom}, names]}], body]} -> names = Enum.map(names, &make_exception_ast(&1)) param = {:_e, context, atom} reason_call = {{:., [], [param, :__reason]}, [], []} reason_call = {{:., [], [reason_call, :__struct__]}, [], []} reason_call = {{:., [], [reason_call, :__MODULE__]}, [], []} {ast, _} = Clause.compile({ [], [param], [{{:., [], [Enum, :member?]}, [], [names, reason_call]}], body}, state) ast {:->, _, [ [{:in, _, [param, names]}], body]} -> names = Enum.map(names, &make_exception_ast(&1)) reason_call = {{:., [], [param, :__reason]}, [], []} reason_call = {{:., [], [reason_call, :__struct__]}, [], []} reason_call = {{:., [], [reason_call, :__MODULE__]}, [], []} {ast, _} = Clause.compile({ [], [param], [{{:., [], [Enum, :member?]}, [], [names, reason_call]}], 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 make_exception_ast(name) do {{:., [], [name, :__MODULE__]}, [], []} 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.32.1/lib/elixir_script/passes/translate/forms/with.ex000066400000000000000000000035351325327334200257100ustar00rootroot00000000000000defmodule 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.32.1/lib/elixir_script/passes/translate/function.ex000066400000000000000000000137561325327334200254420ustar00rootroot00000000000000defmodule 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) :: list 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.32.1/lib/elixir_script/passes/translate/helpers.ex000066400000000000000000000045541325327334200252530ustar00rootroot00000000000000defmodule 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.32.1/lib/elixir_script/passes/translate/identifier.ex000066400000000000000000000026621325327334200257310ustar00rootroot00000000000000defmodule 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 def make_alias([x]) do make_identifier(x) end def 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.32.1/lib/elixir_script/passes/translate/module.ex000066400000000000000000000154611325327334200250750ustar00rootroot00000000000000defmodule 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 @operators [ :+, :-, :*, :/, :!=, :==, :===, :<=, :>=, :=~, :++, :!==, :--, :<, :>, :=~ ] @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, %{attributes: [__foreign_info__: %{path: _, name: _, global: _}]}, _) do nil end def compile(module, info, pid) do %{ attributes: attrs, compile_opts: _compile_opts, definitions: defs, file: _file, line: _line, module: ^module, unreachable: unreachable } = info used = Map.get(info, :used) remove_unused_functions = ModuleState.remove_unused_functions(pid) 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, _, _, _} -> name not in unreachable _ -> true end) used_defs = if Keyword.has_key?(attrs, :protocol_impl) or used == nil do reachable_defs else Enum.filter(reachable_defs, fn {{:start, 2}, _, _, _} -> true {{:__struct__, _}, _, _, _} -> true {{name, _}, _, _, _} when name in @operators -> false {name, _, _, _} -> if remove_unused_functions do name in used else true end _ -> false end) end # we combine our function arities combined_defs = combine_defs(used_defs) exports = make_exports(module, combined_defs) {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 = [compiled_functions, exports] ModuleState.put_module(pid, module, Map.put(info, :js_ast, js_ast)) 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.32.1/lib/elixir_script/passes/translate/protocol.ex000066400000000000000000000046561325327334200254550ustar00rootroot00000000000000defmodule 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 = [body, J.identifier("protocol")] ModuleState.put_module(pid, module, Map.put(info, :js_ast, js_ast)) end defp build_implementations(impls) do Enum.map(impls, fn({impl, impl_for}) -> ast = impl |> ElixirScript.Output.module_to_name() |> J.identifier 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.32.1/lib/elixir_script/state.ex000066400000000000000000000103741325327334200214330ustar00rootroot00000000000000defmodule ElixirScript.State do @moduledoc false # Holds the state for the ElixirScript compiler def start_link(compiler_opts) do Agent.start_link(fn -> %{ modules: Keyword.new(), js_modules: [], in_memory_modules: [], compiler_opts: compiler_opts } 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_new(value, :used, []) |> Map.put_new(:used_modules, []) modules = Keyword.put(state.modules, module, value) %{state | modules: modules} end) end def put_used_module(pid, module, used_module) do Agent.update(pid, fn state -> module_info = Keyword.get(state.modules, module) used_modules = Map.get(module_info, :used_modules, []) used_modules = Enum.uniq([used_module | used_modules]) module_info = Map.put(module_info, :used_modules, used_modules) modules = Keyword.put(state.modules, module, module_info) %{state | modules: modules} end) end def has_used?(pid, module, func) do Agent.get(pid, fn state -> module_info = Keyword.get(state.modules, module) used = Map.get(module_info, :used, []) Enum.find(used, fn x -> x == func end) != nil end) end def put_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 put_diagnostic(pid, module, diagnostic) do Agent.update(pid, fn state -> module_info = Keyword.get(state.modules, module) if module_info do diagnostics = Map.get(module_info, :diagnostics, []) diagnostics = [diagnostic | diagnostics] module_info = Map.put(module_info, :diagnostics, diagnostics) modules = Keyword.put(state.modules, module, module_info) %{state | modules: modules} else state end 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 is_global_module(pid, module) do Agent.get(pid, fn state -> result = Enum.find(state.js_modules, fn {mod, _name, path} -> mod == module and path == nil end) if result == nil, do: false, else: true end) end def get_global_module_name(pid, module) do Agent.get(pid, fn state -> result = Enum.find(state.js_modules, fn {mod, _name, path} -> mod == module and path == nil end) if result == nil, do: nil, else: elem(result, 1) end) end def remove_unused_functions(pid) do Agent.get(pid, fn state -> state.compiler_opts.remove_unused_functions 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.32.1/lib/elixir_script_test/000077500000000000000000000000001325327334200210075ustar00rootroot00000000000000elixirscript-0.32.1/lib/elixir_script_test/test.ex000066400000000000000000000047711325327334200223350ustar00rootroot00000000000000defmodule ElixirScript.Test do @moduledoc """ Unit Testing Framework for ElixirScript. Requires node.js 8.3.0 and above Uses assertions from ExUnit as well as has a similar api to ExUnit with a few differences ## Example An basic setup of a test. Modified from ExUnit's example ```elixir # File: assertion_test.exs # 1) Create a new test module (test case) and use "ElixirScript.Test". defmodule AssertionTest do use ElixirScript.Test # 2) Use the "test" macro. test "the truth" do assert true end end ``` To run the test above, use the `ElixirScript.Test.start/1` function, giving it the path to the test ``` ElixirScript.Test.start("assertion_test.exs") ``` ## Integration with Mix To run tests using mix, run `mix elixirscript.test`. This will run all tests in the test_elixir_script directory. ## Callbacks ElixirScript defines the following callbacks * setup/1 * setup/2 * setup_all/1 * setup_all/2 * teardown/1 * teardown/2 * teardown_all/1 * teardown_all/2 The `setup` and `setup_all` callbacks work exactly as they would in ExUnit. Instead of having an `on_exit` callback, ElixirScript.Test has `teardown` callbacks. `teardown` is called after each test and `teardown_all` after all tests in the file have run. ```elixir defmodule AssertionTest do use ElixirScript.Test # run before test setup do admin = create_admin_function() [admin: admin] end test "the truth", %{admin: admin} do assert admin.is_authenticated end # run after test teardown, %{admin: admin} do destroy_admin_function(admin) end end ``` """ defmacro __using__(_opts) do quote do require ExUnit.Assertions import ElixirScript.Test.{Callbacks, Assertions} def __elixirscript_test_module__, do: true end end @doc """ Runs tests found in the given path. Accepts wildcards """ @spec start(binary(), map()) :: :ok | :error def start(path, _opts \\ %{}) do output = Path.join([System.tmp_dir!(), "elixirscript_tests"]) File.mkdir_p!(output) ElixirScript.Compiler.compile(path, [output: output]) js_files = output |> Path.expand |> Path.join("Elixir.*.js") |> Path.wildcard() exit_status = ElixirScript.Test.Runner.Node.run(js_files) # Delete directory at the end File.rm_rf!(output) case exit_status do 0 -> :ok _ -> :error end end end elixirscript-0.32.1/lib/elixir_script_test/test/000077500000000000000000000000001325327334200217665ustar00rootroot00000000000000elixirscript-0.32.1/lib/elixir_script_test/test/assertion_error.ex000066400000000000000000000005361325327334200255500ustar00rootroot00000000000000defmodule ElixirScript.Test.AssertionError do @moduledoc """ Raised to signal an assertion error. """ @no_value :ex_unit_no_meaningful_value defexception left: @no_value, right: @no_value, message: @no_value, expr: @no_value, file: @no_value, line: @no_value end elixirscript-0.32.1/lib/elixir_script_test/test/assertions.ex000066400000000000000000000126451325327334200245260ustar00rootroot00000000000000defmodule ElixirScript.Test.Assertions do @moduledoc """ Defines assertions for use in ElixirScript test. These are a subset of [ExUnit.Assertions](https://hexdocs.pm/ex_unit/ExUnit.Assertions.html) """ @doc false def raise_elixir_script_assert(error, file, line) do reraise(ElixirScript.Test.AssertionError, [ left: error.left, right: error.right, message: error.message, expr: error.expr, file: file, line: line ], []) end @doc """ Asserts its argument is a truthy value """ defmacro assert(assertion) do %{file: file, line: line} = __CALLER__ quote [file: file, line: line] do try do ExUnit.Assertions.assert(unquote(assertion)) rescue error in [ExUnit.AssertionError] -> ElixirScript.Test.Assertions.raise_elixir_script_assert( error, unquote(file), unquote(line) ) end end end @doc """ Asserts `value` is `true`, displaying the given `message` otherwise. """ defmacro assert(value, message) do %{file: file, line: line} = __CALLER__ quote [file: file, line: line] do try do ExUnit.Assertions.assert(unquote(value), unquote(message)) rescue error in [ExUnit.AssertionError] -> ElixirScript.Test.Assertions.raise_elixir_script_assert( error, unquote(file), unquote(line) ) end end end @doc """ Asserts the `exception` is raised during `function` execution. Returns the rescued exception, fails otherwise. """ defmacro assert_raise(exception, function) do %{file: file, line: line} = __CALLER__ quote [file: file, line: line] do try do ExUnit.Assertions.assert(unquote(exception), unquote(function)) rescue error in [ExUnit.AssertionError] -> ElixirScript.Test.Assertions.raise_elixir_script_assert( error, unquote(file), unquote(line) ) end end end @doc """ Asserts the `exception` is raised during `function` execution with the expected `message`, which can be a `Regex` or an exact `String`. Returns the rescued exception, fails otherwise. """ defmacro assert_raise(exception, message, function) do %{file: file, line: line} = __CALLER__ quote [file: file, line: line] do try do ExUnit.Assertions.assert( unquote(exception), unquote(message), unquote(function) ) rescue error in [ExUnit.AssertionError] -> ElixirScript.Test.Assertions.raise_elixir_script_assert( error, unquote(file), unquote(line) ) end end end @doc """ Asserts that `value1` and `value2` differ by no more than `delta` """ defmacro assert_in_delta(value1, value2, delta, message \\ nil) do %{file: file, line: line} = __CALLER__ quote [file: file, line: line] do try do ExUnit.Assertions.assert_in_delta( unquote(value1), unquote(value2), unquote(delta), unquote(message) ) rescue error in [ExUnit.AssertionError] -> ElixirScript.Test.Assertions.raise_elixir_script_assert( error, unquote(file), unquote(line) ) end end end @doc """ A negative assertion, expects the expression to be `false` or `nil`. """ defmacro refute(assertion) do %{file: file, line: line} = __CALLER__ quote [file: file, line: line] do try do ExUnit.Assertions.assert(unquote(assertion)) rescue error in [ExUnit.AssertionError] -> ElixirScript.Test.Assertions.raise_elixir_script_assert( error, unquote(file), unquote(line) ) end end end @doc """ Asserts `value` is `nil` or `false` (that is, `value` is not truthy). """ defmacro refute(value, message) do %{file: file, line: line} = __CALLER__ quote [file: file, line: line] do try do ExUnit.Assertions.assert(unquote(value), unquote(message)) rescue error in [ExUnit.AssertionError] -> ElixirScript.Test.Assertions.raise_elixir_script_assert( error, unquote(file), unquote(line) ) end end end @doc """ Asserts that `value1` and `value2` are not within `delta` """ defmacro refute_in_delta(value1, value2, delta, message \\ nil) do %{file: file, line: line} = __CALLER__ quote [file: file, line: line] do try do ExUnit.Assertions.refute_in_delta( unquote(value1), unquote(value2), unquote(delta), unquote(message) ) rescue error in [ExUnit.AssertionError] -> ElixirScript.Test.Assertions.raise_elixir_script_assert( error, unquote(file), unquote(line) ) end end end @doc """ Fails with a message. """ defmacro flunk(message \\ "Flunked!") do %{file: file, line: line} = __CALLER__ quote [file: file, line: line] do try do ExUnit.Assertions.flunk(unquote(message)) rescue error in [ExUnit.AssertionError] -> ElixirScript.Test.Assertions.raise_elixir_script_assert( error, unquote(file), unquote(line) ) end end end end elixirscript-0.32.1/lib/elixir_script_test/test/callbacks.ex000066400000000000000000000053211325327334200242440ustar00rootroot00000000000000defmodule ElixirScript.Test.Callbacks do @moduledoc """ Defines ElixirScript.Test callbacks """ @doc """ Called before all tests are run in a test file """ defmacro setup_all(context \\ quote(do: _), contents) do do_setup(context, contents, :__elixirscript_test_setup_all) end @doc """ Called before each test is run in a test file """ defmacro setup(context \\ quote(do: _), contents) do do_setup(context, contents, :__elixirscript_test_setup) end defp do_setup(context, contents, name) do contents = case contents do [do: block] -> quote do unquote(block) end _ -> quote do try(unquote(contents)) end end context = Macro.escape(context) contents = Macro.escape(contents, unquote: true) quote bind_quoted: [context: context, contents: contents, name: name] do def unquote(name)(unquote(context)) do unquote(contents) end end end @doc """ Called after all tests are run in a test file """ defmacro teardown_all(context \\ quote(do: _), contents) do do_teardown(context, contents, :__elixirscript_test_teardown_all) end @doc """ Called after each test is run in a test file """ defmacro teardown(context \\ quote(do: _), contents) do do_teardown(context, contents, :__elixirscript_test_teardown) end defp do_teardown(context, contents, name) do contents = case contents do [do: block] -> quote do unquote(block) :ok end _ -> quote do try(unquote(contents)) :ok end end context = Macro.escape(context) contents = Macro.escape(contents, unquote: true) quote bind_quoted: [context: context, contents: contents, name: name] do def unquote(name)(unquote(context)) do unquote(contents) end end end @doc """ Defines a test """ defmacro test(message, context \\ quote(do: _), contents) do contents = case contents do [do: block] -> quote do unquote(block) :ok end _ -> quote do try(unquote(contents)) :ok end end context = Macro.escape(context) contents = Macro.escape(contents, unquote: true) name = message |> String.replace(" ", "_") |> String.replace(~r/[^A-Za-z0-9]/, "") name = String.to_atom("__elixirscript_test_case_#{name}") quote bind_quoted: [context: context, contents: contents, message: message, name: name] do def unquote(name)() do %{ message: unquote(message), test: fn(context) -> unquote(contents) end } end end end end elixirscript-0.32.1/lib/elixir_script_test/test/runner.ex000066400000000000000000000005511325327334200236360ustar00rootroot00000000000000defmodule ElixirScript.Test.Runner do @moduledoc """ Defines a behaviour for an ElixirScript Test runner """ @doc """ Callback for running the test runner. Receives a list of JavaScript files from the compiled Elixir code. Expects an exit status representing the success or failure of the tests """ @callback run([binary]) :: integer end elixirscript-0.32.1/lib/elixir_script_test/test/runner/000077500000000000000000000000001325327334200232775ustar00rootroot00000000000000elixirscript-0.32.1/lib/elixir_script_test/test/runner/node.ex000066400000000000000000000007231325327334200245640ustar00rootroot00000000000000defmodule ElixirScript.Test.Runner.Node do @moduledoc """ Defines an ElixirScript Test runner using node """ @behaviour ElixirScript.Test.Runner def run(js_files) do test_script_path = Path.join([:code.priv_dir(:elixir_script), "testrunner", "index.js"]) test_script_path = [test_script_path] ++ js_files {_, exit_status} = System.cmd( "node", test_script_path, into: IO.stream(:stdio, :line) ) exit_status end end elixirscript-0.32.1/lib/mix/000077500000000000000000000000001325327334200156655ustar00rootroot00000000000000elixirscript-0.32.1/lib/mix/tasks/000077500000000000000000000000001325327334200170125ustar00rootroot00000000000000elixirscript-0.32.1/lib/mix/tasks/compile.elixir_script.ex000066400000000000000000000065111325327334200236620ustar00rootroot00000000000000defmodule Mix.Tasks.Compile.ElixirScript do use Mix.Task.Compiler alias ElixirScript.Manifest alias ElixirScript.Compiler @recursive true @manifest ".compile.elixir_script" @manifest_vsn 1 @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([binary()]) :: :ok | :noop | {:ok | :noop | :error, [Mix.Task.Compiler.Diagnostic.t()]} def run(_) do {input, opts} = get_compiler_params() diagnostics = try do result = Compiler.compile(input, opts) Manifest.write_manifest(manifest(), result) result |> Enum.map(fn {_module, info} -> Map.get(info, :diagnostics, []) end) |> List.flatten() |> Enum.map(fn x -> %Mix.Task.Compiler.Diagnostic{ compiler_name: "elixir_script", file: x.file, message: x.message, position: x.position, severity: x.severity } end) rescue x in [ElixirScript.CompileError] -> [ %Mix.Task.Compiler.Diagnostic{ compiler_name: "elixir_script", message: x.message, severity: x.severity, position: nil, file: nil } ] end case diagnostics do [] -> :ok x -> x end end def clean do manifest() |> Manifest.read_manifest() |> Enum.each(fn {_module, info} -> File.rm(info.js_path) end) :ok end def manifests, do: [manifest()] defp manifest, do: Path.join(Mix.Project.manifest_path(), @manifest) @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.32.1/lib/mix/tasks/elixirscript.ex000066400000000000000000000004711325327334200220730ustar00rootroot00000000000000defmodule 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.32.1/lib/mix/tasks/elixirscript.test.ex000066400000000000000000000010761325327334200230530ustar00rootroot00000000000000defmodule Mix.Tasks.Elixirscript.Test do @moduledoc """ Runs ElixirScript Tests """ use Mix.Task @shortdoc "Runs ElixirScript Tests" @preferred_cli_env :test def run(_args) do Mix.Task.run "app.start" path = Path.join([default_test_path(), "**", "*_test.exs"]) case ElixirScript.Test.start(path) do :error -> System.at_exit(fn _ -> exit({:shutdown, 1}) end) :ok -> :ok end end defp default_test_path do if File.dir?("test_elixir_script") do "test_elixir_script" else "" end end end elixirscript-0.32.1/mix.exs000066400000000000000000000025041325327334200156410ustar00rootroot00000000000000defmodule ElixirScript.Mixfile do use Mix.Project def project do [ app: :elixir_script, version: "0.32.1", elixir: "~> 1.6", 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.3", 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.32.1/mix.lock000066400000000000000000000057311325327334200157770ustar00rootroot00000000000000%{"bunt": {:hex, :bunt, "0.2.0", "951c6e801e8b1d2cbe58ebbd3e616a869061ddadcc4863d0a2182541acae9a38", [:mix], [], "hexpm"}, "certifi": {:hex, :certifi, "2.0.0", "a0c0e475107135f76b8c1d5bc7efb33cd3815cb3cf3dea7aefdd174dabead064", [:rebar3], [], "hexpm"}, "credo": {:hex, :credo, "0.8.8", "990e7844a8d06ebacd88744a55853a83b74270b8a8461c55a4d0334b8e1736c9", [: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.18.1", "37c69d2ef62f24928c1f4fdc7c724ea04aecfdf500c4329185f8e3649c915baf", [:mix], [{:earmark, "~> 1.1", [hex: :earmark, repo: "hexpm", optional: false]}], "hexpm"}, "excoveralls": {:hex, :excoveralls, "0.7.4", "3d84b2f15a0e593159f74b19f83794b464b34817183d27965bdc6c462de014f9", [: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.10.1", "c38d0ca52ea80254936a32c45bb7eb414e7a96a521b4ce76d00a69753b157f21", [: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.3", "a05252d381885240744d955fbe3cf810504eb2567164824e19303ea59eef62cf", [: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.3.0", "cbfc8e3212f64683615657ea27804126a42ded634adfdfee258bf087ee605d46", [:mix], [], "hexpm"}, "unicode_util_compat": {:hex, :unicode_util_compat, "0.3.1", "a1f612a7b512638634a603c8f401892afbf99b8ce93a45041f8aaca99cadb85e", [:rebar3], [], "hexpm"}} elixirscript-0.32.1/package.json000066400000000000000000000025651325327334200166200ustar00rootroot00000000000000{ "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": "node 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 } }, "@std/esm": { "esm": "js" } } elixirscript-0.32.1/priv/000077500000000000000000000000001325327334200153025ustar00rootroot00000000000000elixirscript-0.32.1/priv/testrunner/000077500000000000000000000000001325327334200175135ustar00rootroot00000000000000elixirscript-0.32.1/priv/testrunner/colors.js000066400000000000000000000011411325327334200213470ustar00rootroot00000000000000export default { Reset: '\x1b[0m', Bright: '\x1b[1m', Dim: '\x1b[2m', Underscore: '\x1b[4m', Blink: '\x1b[5m', Reverse: '\x1b[7m', Hidden: '\x1b[8m', fg: { Black: '\x1b[30m', Red: '\x1b[31m', Green: '\x1b[32m', Yellow: '\x1b[33m', Blue: '\x1b[34m', Magenta: '\x1b[35m', Cyan: '\x1b[36m', White: '\x1b[37m', Crimson: '\x1b[38m', }, bg: { Black: '\x1b[40m', Red: '\x1b[41m', Green: '\x1b[42m', Yellow: '\x1b[43m', Blue: '\x1b[44m', Magenta: '\x1b[45m', Cyan: '\x1b[46m', White: '\x1b[47m', Crimson: '\x1b[48m', }, }; elixirscript-0.32.1/priv/testrunner/esm/000077500000000000000000000000001325327334200202775ustar00rootroot00000000000000elixirscript-0.32.1/priv/testrunner/esm/LICENSE000066400000000000000000000022001325327334200212760ustar00rootroot00000000000000The MIT License (MIT) Copyright @std/esm contributors Based on reify, copyright Ben Newman 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.32.1/priv/testrunner/esm/README.md000066400000000000000000000104451325327334200215620ustar00rootroot00000000000000# @std/esm This fast, small, zero dependency, package is all you need to enable ES modules in Node 4+ today! :book: See the [release post](https://medium.com/web-on-the-edge/es-modules-in-node-today-32cff914e4b) for all the details. Getting started --- 1. Run `npm i --save @std/esm` in your app or package directory. 2. Add `.esm-cache` to your `.gitignore`. 3. Create the ESM loader to import your main ES module: **index.js** ```js require = require("@std/esm")(module) module.exports = require("./main.mjs").default ``` By default, `@std/esm` **only** processes files of packages that opt-in with a `@std/esm` options object or `@std/esm` as a dependency, dev dependency, or peer dependency in their package.json. However, you can enable processing **all** files with specific options by passing an options object as the second argument or passing `true` to use the options from your package.json. ```js const loader1 = require("@std/esm")(module, { cjs: true, esm: "js" }) const loader2 = require("@std/esm")(module, true) ``` Enable ESM in the Node CLI by loading `@std/esm` with the [`-r` option](https://nodejs.org/api/cli.html#cli_r_require_module): ```shell node -r @std/esm file.mjs ``` Enable ESM in the Node REPL by loading `@std/esm` upon entering: ```shell $ node > require("@std/esm") @std/esm enabled > import p from "path" undefined > p.join("hello", "world") 'hello/world' ``` *Note: The `"cjs"` and `"gz"` options are [unlocked](#unlockables) in the Node REPL.* Standard Features --- The `@std/esm` loader is as spec-compliant as possible and follows [Node’s rules](https://github.com/nodejs/node-eps/blob/master/002-es-modules.md). :point_right: This means, by default, ESM requires the use of the `.mjs` file extension.
:unlock: You can [unlock](#unlockables) ESM with the `.js` file extension using the `"js"` ESM mode. Out of the box `@std/esm` just works, no configuration necessary, and supports: * [`import`](https://ponyfoo.com/articles/es6-modules-in-depth#import) / [`export`](https://ponyfoo.com/articles/es6-modules-in-depth#export) * [Dynamic `import()`](https://github.com/tc39/proposal-dynamic-import) * [Live bindings](https://ponyfoo.com/articles/es6-modules-in-depth#bindings-not-values) * [Loading `.mjs` files as ESM](https://github.com/nodejs/node-eps/blob/master/002-es-modules.md#32-determining-if-source-is-an-es-module) * [The file URI scheme](https://en.wikipedia.org/wiki/File_URI_scheme) * Node 4+ support Unlockables --- Unlock extra features with `"@std/esm":options` or `"@std":{"esm":options}` in your package.json. *Note: All options are **off** by default and may be specified as either an object or ESM mode string.* 
{
  "@std/esm": {
"esm":

A string ESM mode

  • "mjs" files as ESM (default)
  • "all" files as ESM
  • "js" files with import, export, or "use module" as ESM
"cjs":

A boolean for CJS features in ESM
"await":

A boolean for top-level await in the main ES module
"gz":

A boolean for gzipped module support (i.e. .js.gz, .mjs.gz)

 
  }
}
elixirscript-0.32.1/priv/testrunner/esm/esm.js.gz000066400000000000000000001264331325327334200220510ustar00rootroot00000000000000‹¬—â6ú¯xüî)(^&=€†ôÞ¯ËÍ3F`mŒÍIbfxàÿ~ß'K.¬‡lKYK_ï’Øp¯E ’‰ 'I‘k¾-VûLLªO$v…2š“õ>OŒ,rbèѯA$=Ê5Ñs¹ J˜½Ê\{¶É]¬‚œ#ˆåX²l|uÍr|,ˉc2È”ÄYFrÏËrÖ¬…MƯF ¬DÙšk"ÚrÃD”p V¼±˜ivŠ¨À%=~Y>‰‰Vb-sñ«*vB™ƒ%;BÖr³Wñ2ÖÖ|¿n7baƲ¤%ÈÏy;"•-f00Ñí­Ð?ÙàÍj zô~¢ÒxŸ™r܃l¹²"š…qæ2ꊶ;¢fqžìTa s؉(õ/÷¹÷© )2 ŒC&ˆˆ4ÿð=ZR2']¡¦N·ÿÛK%H¸‹M-ë‚YǪ^$w&$JÄFLDóç=“$ßg-ûä¸=ÙZBÊ+Ε×`¸òaQ\6®r$d¦ìljû b†_Yº*$×t’ ¤È:} Í•}Vuü0ÞÁQz±Œ3)ô4!ç\œNaa£awƒsÅôúFIkCÛÞãPé…4ðˆë¸f³z91kãqmÖl,fÙÔ×t¹ZÖ:¤—|}}µ.+ø¼GYŸ)‹8¢,Á/¢r!å`{"´Ž–2_É|Ã2>« *c¡Ìõ¼,¬óØÈ;н‘Y¸ˆ”XíAÈ¥˜S4“´Ê«DOŒ:5O« 8S0Il’‹¢¬§—Xp'O¡0ÑŽ7‚‹a8Âa À¨[½y±¨·¯rw°sª3«šÒÒž´[¾bˆöûïúhoü$œl ¹IÚLÆMÔ„oa»ÉŠeœý›´vì€Ò)à\ƒ)v&å#¦¡†6—ú¼ÎvÎ{ÏZ¦¼ ‰*ÎNÝÑÙ©[õÃ]!WÁˆÝ+i¢¤—ªYwTh¦(ó$å+µÐ__£…ú<„Ø3ô‚ò8OðlÉ©+@…x?Ë7áU}ôÐÖ˜F e"ߘôæçs̳ßçÿ^ŒŸ³ ‘ÚC;TX¬~•ALgµH˲6<ÌðceNQh'`ãˆá&º «­™A¿gU{ !ÐWJŠ„ßåPûTü¶_h×ñ~F§0:ÈŠ|#T`Ò8öŸ‡a¤±Š$!­beR©»îÐç"3ù‚„[0%d¸gÈäw ŒÀ¯-¡Ñ£ØIU¤_ÖMT¡â{n¬6û¬P|¨ç× yx×v¨ï-Z,7?žNÍn:ºl†% \«ye(ܽ€(™÷Š²f¢¨f÷g¢,QKTÅ©„™ˆµàzþþb†Dz—ICÂ(Ä<ìÚw[¥Oþ;½óÉbø—'¾-ªé%øж¸á£Á@Lô5 êþ¤t«Ë§½D”½ƒ~Õô«zÐÛ.A[ú†}µ±·TbÊêàv©Å²f<˜äƼgÃ…Ï)súB”Ô®üm¿·[orËá™Á7ràqN<#Ïåé¬ÅHÙ˜-=£w”Ý84Ç“•€žnÜ(|òT¿ýôôôŸ'=“؉obù{œoñG(-ih-3#T/³¿””R·¼|ˆTx`U¹cö‘I}èÜ»›UüÎâlÞb pÐe 52[ íÀ_Õà…jø— 1WŽ¸Q¿i¼¼2§Sø€Ó bSüXÜ õE¬¡~Û‚¶eÇjË&!à ™x°¼ÊèY!sa+íƒ ï5…Á‹2‹I­L‰]'‚èó·#Ë™¢Gì¨ï^#Ÿ÷òéǦ„mƒ7éÍlzÓOo#êͧw„U®g/–æ.UØn!|6¿h!xCìWÎþ¬0¤3.åã—¨¢ ´OèÉ 4ÿí{që^ܶËšáøxmÕ©í&#ÿ²ÓYûƒ÷ÅŠýöB±;äÑø÷Y»Ðµ-tñÂ…Î [êÖH´±±rcŽÅÍŸNXÁ,å ®eOšÛT ™½à…±x& ,&ûÔ¥r:ªŠFýÉg$Žœ@.V'.× AvX2#’cÊÐ1$§– sm÷ð©·¹¦ÈTñŒ+2Ê×M†#lq‚&bþe»ee“w«ÇÓx^¤k—›Ÿ•ÌDZ€ÔvŠä—GŠä¯îÐDŸÕ:q¿ÏfÁÂv üA:™b1KXÊ2¶g»Zºàv>ùéä ½™E݆jºA0ÌyâXSøÚ¸$Q–UàÄ…!­jpî©ý3âÌÙ-"fD@‹Á‚:G·þZ…g](Èâh¢§þF4ÑÃ!Å›™ë…YRw¡¸¶ÏÜÖãÙ1U‚°†û…}APš»¾RÖÚ\ámw0hAž—~3ò¿¶ÈÐé~×à\T«Á@2÷ \!¨úmAv录Þ-¿h½ùžù‡!þÚ%xu™¬ýÃìw ü«¼‘òYór4Ü?¦%e@Yõ>––ÕÚ¿-A³`)³‚ïp° ;­m£œ=ª  ¾²ɦH†uð©·~Úk<ËŠ;¹A¤2+¸øÅ:AA¡PûÅ·PÙª Ÿûäþ0 :ÿÃá¡Êݦú«·¥ý`î,Ùü°ˆ€û«8I»ÃÙ´Cö­[=³Àíj¬QÊ6|s:¹Ä"ž‡müzqÃÍ8mPËR—r…’ü3 õe§Sg¿î?¹ZÖÈÓiÙa‘1µŽn×tH׃AÚKÙ¢ø?_VÁÖ< „ÿKÐ6-î†ÍÝ­a¸Û¶íóýö/—\hƒÛ%¯Ü{‡3>ð ?Eö7¿ý‘ƒLNbáìGH…Ço«ñ|#^éUKñýž(ªéb‘¹BiZ` Ë+NŽF÷'âk/¿ÛêUwñ^ºP‹'ã• XŸ›[___X^Z]š[_Ÿw*âËhpκÜI‹j88…²Æ末Qº™î–8#sAwÞ]çžwf«> TÿES÷x îÝ=vßwݎ˱T—£G¹yÁ&:QbyÞÌ/¥j ª¡U $þ|@UUPÅ6´gÅAHÛCÚ^HKü@«#­®h®ìÖᢹ>Y¶…‚> ú(ˆIÅž¡Ø3ï¨xNj݉ ºzÏM„›œ) *ß ÇwÃ1 gœ‘ç€yNaJä©) a˜†‡„ŽS2®d)Ñÿ™yÞÛ@l€¬oÊœ6¦i+qêSÜB 1E°­`ÛŠ±&Ê"šå ÷ü´ϳ\F¸ péœA8ÃÄr e[máÏ3Ôu¨ÃQ,ñ¬Ü}í}ÿ«6ôûó uÿ7ÿsíî«¥Á’(]l¨3üs‡CÍþÈôýz­©×¾ú¼ø·­wý ¡ Ú"˜Ê‹§"±ÊùeüõiZrIðç™–tPšA5çÑà˜5é#zÞ!F<ÕЩñ8ñ4ñ4ñJ˯t{Pšï4çÎäGš4ú¶ðiùÉm‡È}ÒܧŸ¸ã÷Bs/ÌùLó€`d ƽˆŽ{÷L»ÉÎh€RØ– oŒ+ƒÜké½)õ}S‹w¦øM‹ßäø „ÿÔ½ Û8’7üUdÎÑbßq9´6“vÏfß\“¤{v×ñxh ¶Ñ‘H Iù˜XïgêÂ)ѲÓóœýëX$n …B]ÄÎtÌÃyCÜÃyóâ3ý!¦ñU÷¼¯Î›ãT|ÄÏím¿nvœ—îK–fJHH&UdÃåO /^A2prñ¾VSÂŒ8Î⮺ ÷h‚²ËãÞ&® ÷´Ë‚ì…W©¡ï-jÚ&2¯xÓ¼½SžùWæg—Ùf°MAs=-ŽX,Ê—Þ ðSaáy4ܦü¤Õ®«W²ú¢¬åÎí¢¶PuÈÌ!ÜŒõÅ„ž“öíøMƒos…ooÃÄ•¤´ÖQ¢|ÛHÚwÕõ‹%þ¥Þm²*Œ_Ÿì[Ç…!g Zȇƒ£)ÖšåTîkNuí®šwW츊ßÛeg‹O7Úü£Òl¸…fÈPJ¨¬‰SС‘Oë8Tâû–`Û–T¸gåºEËÉÛQrÁ¥^ V]t2¿º€P¯'–OÃZb®u _ë0p$I¿hÙ–WËãÅã^½¯ÝÕçím s×H+]u\“¢qðZ|¿¼"ßÓ•.u?¹54½²5À´O{àîæÒ¥¶Ž÷a¶ˆ†Úk×´ÿӤЗP½]$õ1δ¥D}­“ýÚú6o÷Å~¦³ú‚dòs¹\F©Õ ª~—¿[ÊÜ>Nã*<3)¶ŽÓ~{r«´Å(•Q&šÒ¾”EÓÉ«óX¥hI‘fÑ+K—Îȹˆ)6Y;©È@e5Š©[ÚfÅU§hN ¥l?íf]èx¤ÎÎ\ÏNá|§Ø\ÌqQ©(è‡ÕÁ­¸^¬’,V¶NBcö3-É`°©ü £=^håê£ê˜¶VA?fD‘{Ö8<$8óÿ©ýtª¹p‡øë­°:SѬÒà8m2oLD,lÕR2­;vÀ¡m=´öBÞôŒKé⪸¿8Jqq=½ûŠs©`¢YéŸß€ ‰[ˆmlÖ¶07õ»¬#K̘ÞQ¶.«&,çK5:/²ÚV.Ó ©h*åžssUk{tƒÉ釮ŒCú‘ÿÈ.觠߱Δ٠¹ô;”&ÓìŒ~_9{‘l¤Qãº{Ê(à%(?‚¤5:sÜ´Q3h£p©Df­áƒl½ÅŠ±k` S72?ÉjK £T\BÓ˜Að2¤ýëf.Fßq©`㛸Š¬›;T""nX,Ú×ÛìHddSÕÎKŸq‚ŸyØ`T4°*`,*‡M½L)×ÍlÚ—)ïø©Á*Õ˜UÌ­¾Æ'X°h|©3h^´Ú¿òò{M)¾…;«£FÔ‚™:×gÝÌ„óÉZ40YÉÁRâí­-º\ÎAhóEk›/ZÚ´EÊÅmVY‹!æ¾$Ê»'ÄýÜ?£¥Ááᬢ´4˜ íd-­/%êÂ/¸p…8%ÃÅ>â>]3Kð\J .JqEgúí-¢¼½%¥ödRëm³‰˜¼©ÿªš‹n¢—»ÈÇ›šÄŠ\”Ë‚¶Ewœ®öy–‡4ƒ¦ß]áýìÜ[«(aÐÔãµ³e©­c(¡iÎGr„ Ú!ºþW=ŸÓE×çYæµãî²—sÇ¿ß+“@0&¬$piÙQÝi¾>Ë(à+ö«Íuö²ªòr!ÛÈurÉ‚gi^È}EÇR}¤Ö·]5z=Þ¯gSZy–[ð÷èâ˜z.i§æ wX%=S®—'º$0Ò—4¹óy´™q~°ò{64o¼ÊB.úy:|˜5ÇKq€¡0ͧÓñѹPÍ>5?+ê uÖÀ§:7wƒÅb±kœ›@Œ:É„í|fyaz²÷ ô„äE7O¹咽°|º™œ–ctÙMþ­nF›²žô%X»Wð­NLà¯Âñ|Çb¦‘žvÅþ¸íÄsc›ñBkYèÜu;uõ§‡?’éÕ//ß¼þñäåÇ?Ÿ|þ¯‡­üXòùB’¸sï%NŒÜ™ÀŽï9r.âæ>||ÿùý«÷oÚ›Óë;,Ǿ͢l:„cصr´Ñ!»Ò“. SÛúÛן>½~÷ç“·ïüùÍa–¼Ê Tèó¶€ãáÁ“Ç´û^<ß¾½­ž?ÁóöÎ.±ñ¸çé÷›øHu]ÜÏî·h@Gî5Å5J²#/ðû1–ÜF~JW†MÛâ°i{{6(jN?»{&j½_àý *»˜i%¡º uG¨ÍÛçe1úÏjù¾€'dÆæÙª™;i úÿºqUåÓ(ò™Vû˜kÕ¬x]|&.üUY4tgI»¥ø6R5áõžzø\$¸’¸ CpÄš¥Ìvœh3ªŸTU7oTaâ"f™Ë–—9`ÝÁƒ—±Ë¦sú’ ! _ÈKû,¦‹ÂÕG’Æ!;wŒ@tGÙ”Žçxž?ÊÓÙ¹›h¢_­!ùj(UÑtÏÄ–ØJSžçÄ’àI6ŒfâL8o¯àIÁòE8&c¤*€L³}s$gµ¹g¶S1¡ßÇ[©ý&ΑNÇì)ýn?NÅ5ý>OÅ%’©ØŠQµC¾zLµ=šÛ¸`žMœœ˜åÅ£íþ["’/Ũ!C.x§\”l#ù‡dIÚkz‡DZævïô‚ŠV˜ÍñýʈM°ÓÇ|›YÕ‚&ÔØÙ(È{9HN>«¥kÏÁ®5–_Ë\&b —~£Ño¿ÔŒo¸±4}päîÕŸÀw®‚0V«ƒ8±¢3I(I 7ßôù>0ÄØ·ß·ô9ìEØ´…ÎR‚`ª•ž·ý ‹aVJÓ@sÌ®Gqû¾û §6šò €ªdá´ýÐÇjYí5yý5ˆ?ç;îoËÕ !ÿíÊ iO¿àåàmîðšäªà ’ ŨWß¡ºCÑ`.höá7ˆ†vDÓ|H¥²àÉ–Y²ýR]Ϊ¡„È{_I“6 uV{ù’²‡í'¾ ÷_vëE)dÑ"…¬²Bt Éz6«éO?1Í',g¸Ò Q•FÁ$£ ±VA”לHàâ7}†it9A™H¹…•zÓEé(|\i#Ÿ / HÆ…N€Ysìr8a’õÌYÑœÕ 'PPᜡÁeæjÑ´S¥eçmN¡ Ã)8Þ¬¤3ÁB`…Š€9]?T2»êRš¦ IC‚^4“åÐ}®]má$ ˜s¡@-ŠQª#’Pªжþµ&Õ“w¶Fß(QQ¢ZÌkP¡½èímˆ 5½:¤^pW]L›Cr4êÖš4¦T–ZD`*ƒzÀ’!ëÅ cÚw¸Å+ã—Jú+õ uÎý¤ûÞˆn·M~³IÏ`Ë;½= š‚’eTJÖ|¸Ø EG„ux£Îtgé¡p#‘/„ËñtC!F9SjQÇ”mÁÄ.yûÅFyUÈ*ó+¯+¾S„¾tA×?UåÄ‹et©³°%¡âêNÙ©ø¢ÆŸ»q¬ ®)e7ª˜±X¹Ìj/§Ï™ŽÎw'ò-[% 9-h™å­Ð±(â"«*ê‘• NÂ}ÜùÜKzCã}ÔÀœ4Äœ7œ|åTÊ¢3’D#Œíó@bX —*pò 6Z‹‹ÃZÍ(3MÄ8?RØ?9˜ÁJšá¾„€Û%…pE %´J_Ü6®  õ%_Ùª45“´.©Ñ}bÑBz—ºò>m± é?ÅZ€ÈwWuÚJ™Eär[²ý¨Ã[t¢ò˜r¼a§pGg&5:¢©„HBz›´XÊ»v†pdryc½fö$œ‰J¿ã)¸DžUÀ3Aý‚Í@­ã{GÔ}ö‘ –‡—÷Ï•ð4æ5ã’Ö,Q²Yâ2 qª­„¡…”]éö×ôl(£ ¦"Û§‚.8•¸d<•à‚†f£«ÕT÷”ƇþöœøŠsiÅ´k\oQWÞ¤W^®»n´Ùt”72Þh‹0*¹®Ÿ¼ë¨¶WY5:Î싨»J„xß³ìÞ±£Š†:o·—|Ûj3õvµQƒ£o­6‰êIú Kl‘øoŒ%)Ý‚A£™…]«¯2éÇ• ª±ìhA”s€?}»ÝW*ÑXŒºÁFÐ?| “² õ¸cüËý ؘdu7ߦe­®ûßd~FŸˆª_pÈ þævÎ6Õ\h•ë%ö†·\j +Ò»-IM·Û¤¦P@…/ýD-9ÞXîÙ Q›3‹*¹RrülÉâ RE˜½Ò>HO©6~®Æ$Rféò À‰?N•Ìžoé½Cæ¿æ“]ÛOî’¼ ’¡Þ÷Qb«6Y|Òk”ÛŒ7猨SDëÞ¸pÃY11L„'öœçµó4žWü•CUê8ú R/Û†ì»uÎ2˜³úþ9{C{wËwõÅa¬Mž3ïý1¹±íÙnh<–ú h\–O¢|ȳ³eá¶ÖlÁCwI´QañL8„•$aóo¿[Ûx´¹‚ÎÄ؇h¼»{‹f†[éÀûN*Dþê?ÐSÜAIÜÆŠ´‰<ªn²qþÏD[T-—r)§y-9 Ú˜öÚañ=s²·óôyëôÙ2cû®™×#Z$g…×m¥˜N1 ° ÉÖƳÝÄ y å›Å¡¢$¯ä0G¾alÝ1Ïû‰í`–¥AÐ;m€0gÚ3pÍ’ µ¿æU‘œYÙÎõûç-]ï»ÑÑ~VïÝøØ2rWÈ+Û™fL—M³4‘¾t2Z¾?FX5 ,à²4üšŸKþ6]ê¯ £è;tÖ–,ˆ}•$,}`ÂER¿:ÕuùûtÐegRøÕ%Þœ4·|¹îŽsO 0¥LF·(oøv˜$ŽQcqP¨à‹ŽÂGzS% *µo–T=MÀE jG]¯‰q’RȵÀ8íûô W[¡d) ®)?0ÎË[P¹1”Ý\«ã+ú•æi¹F.­vLRb¹!ˆ›Äm³]åS6«Ü£×i¦ÄrvY.¯1NG¿7H§ßs¤;±åiøÑÅëlL§ á¬XËêRë:VÅ×Z\jN¬…Ä•{:ô_ tδÎJÇ…aH²ç ÀNHmÕÆH(( ,d/ZÎÀÙAHÕ/O F³†-+dv”$¨ª£ïÆdç`ñÈíg=Ø=÷VÒëBfgK šê›HŠÈNõÂŽ±A¯ìâ^ýÇ,]\s²„{z§9û6O"Sõ&“ æÉ£7lžÌ¹G#-9º[mŒÃ7i,s:5M^¶`Û ŒLÞGÕ/I<Îû‚äãÛøE?3ÒÌ|œfØõ`±!ÔꯟˆÈÆâÛÍJ\¤0@Ê»—¢5ž©ƒ{‹W¶x*¨ùµÓïëâÁUÚvÙ¥ÛevÀÖ[153më8:Ø¢=z¢#aÞÞB~Éø´›XOÈ6~H;¦ÑQÇ8Ó•Rv Ùäì7˜Ö9š|¬š›%ŒÌ©CõóbÔ¹Rã1üÀ*9)Ñf]–ÅF"’?lmmÓŽJP2;µ8YÍÊ€ñ5‡´l8`J/ÍiŽÌ2]¤aåý{[ —•`3Z¶:Sþ’ôƒù€MHc…¶ÓRê6RŸ.§öí>{±s{ÛÖRÚ˜»qÀÄ©Ÿ´Fß‹©Ç_´j0dN½‚fÈÐv‡3¥s¼pìŸ7»Hû­Þ¢Â>Dm,Çd)ŠØ†‰–ÌR®’}É=ÝS#ú¹ð†-!§MƒóÒ7>¤ºcühy¬éñoá–ÝXVXJ ™5›(‹ËŸ?~$wÇŸ^¿9ì‡éÿþþí¡¨[L£]¡k9D²A»E3Ãxö-תEm‘Ú9”N¸·8Ð,WÔ.ÊžPµ*¯”¬±ï­yÃ8©U•…S{÷þÇÓ/?ÿû]’„jPq˜ ¬Ž+â2eåÈÿT–ˆœZ§ð"í«½n|Tf¸?u†ïôn’©õæ9aù7²\èÓÛàzMþÎÏß<Ÿ‹<ûöCòCŸþ ”¡:Ÿþ‰S¢yúaTΠsD0ôHÅî–Ëä¿Q.ƒÈÆKw“nbÊåï³ï>¦ßzáfT÷e¯¶·#A'·»(V‚jú×VF‰¶DÇMmeØØÞ->©ìÄË,±ÉdÚcYÆÀ8ÔÀÉýwbèöcì<{a¸KÖYdlº/[5O°¢%™1Žuj>¤‹‚…¼-ÕÔ [„6´ÓÓè2ãNžÈ€Ö˜Ö¢sSxóÙ´Ï/Tjɉ?é¾`*Ö¢—뺌Í@ÉJ© ¦c²¦¬5¦Y»œ©µ_D¹TÔ-W‡¾õ Õ>6ó@•>Û½õƒ¦ÙžÏñœÏñçøò!òg|-Ø¥ Áأ̌YÄ8¸—Š3–|øÜg›•§|7xæmV6¿;ÞxôûÍ6œu'Ë82(1™ÌîNÅHœŠkº2Œé²p®I²¹+]L)¹wE ·þˆÕ©>`¶1!$ò oé%%ãtÐ.Ø¢^"a Æ¯óS§s§£4ßȵš{J/š‹-õ¯ïâŠeÙõàÚgQ†{¹½]ƒ½öï_FDvLE1Nû]¼smN§”ààÄT‹ðʼnµ¨Fß–¨G•¢Dàdu˜5sÌp¸Ù4p3Î׃ÊSŒh ••Oˉ§àÍ×Nü”1\c¤ï¤”!&ûÉ_F¢$[‡š»cAæó‡©Uî6®úó]ŸloU¬ }P,›V=„²ï9¸hÞ•U*(y‡¦—yó£~lvç®ÙÏí4f«üÇL–U;ÐF>âB<…ý[øÕü˱8#Ié—Í/›ã’¦sQÖÍ—ÓM1Z½¥'÷Kðóß*ÁǶEïäYÊ$>-çžauÄÿ&åûn¶Æ1êã 6³4 …HKáßÝv·Xƒ%7…ɺKPM=g¿Öüñ#¬d¤up'ÿH$ Ö5:­K ÃSQ‰©¦pyê¿uèìYÝQ‹ UîȱŠá´[Ð|ô$|éƒ*Ò!i‚{Ðά6ia¢Å‰†$· L³ºê¥[Eó©0\D|d¼µ[¸náTNuK×í£Y3¡ ÏÅuhw›7kCÅÙ†Ù˸ŽÃ”ÞϹ~9äwŒp7éÁpè¢Ç¢Ë&ã(xÝk«%ÙmèÇ]³"† jÉ…Zü7Z 'µÕûËA¿á™BEÃQ|…êÝ(äŒh€öˆgêËdÞî¤+#²5 ‡¤t?â7˜Ð ñ»ã™©ɹ.Ö×7ÅŒèÌ—ëÃ/³Ý­­/³Ÿ~Ú:Äß'ÛÇtw˜fßJœË«~òÞ>G65´rT“Èc$+Ji乬j„vñÁÀŠ²Y']‰Ò¾}=Ëó|lêd­ëg[.Œ°óŽ.¤ƒ"u¦%µ•&ÂFm_×пwø}Ndó-1¡4¢²£V5ëúãg/¶·ÍúÎN¿Y²÷bçÉ¿ôòü)^ðÛß}2“V‘L¡€*´‚’ýo>Ý"¾µ98ØM/CìÏïí‘•TFž NÜ¥ãÎ9Í©Þî“GÍ& ÄwŸÁð¦íÛ¨Úc'ºænï<#Êöt‡–“}+^Ÿ–d0±E˜–g[‹öÑ9‰(ë4¢¤uz€ÖÈ|¿,K*L”þ…²¾Áa–l òÞvŸÈ‰Ê€Ô<+\ ™m‹Šf¿¿_4©ƒ¬F? +è…T£¸»a¯GvóªMñjκä)IŸ½{¶ûäñÓõ"%(§º=‹Š ô²ü‘tòŸêEV¶ûÕAVöhYwžô«õRSö©v(µˆO}¬_ìKêÄ÷±9^j_>ÊÆsÓº“þö¶I6é빸$³Ì¡ºØ¼H‚ñV‹MT¸”(þ€ØäØ’¶DlÖRl2¼qV•>¬6ügi§¹ó6fá´ ûAºº-éc{ n\‘Çiü¥rh­×ή£@8°±ú§ì—:iÃ¥XËŽ¨ŒN ÊÌ÷%U4XÆ ͲÃݯéÒåûªí/2¥o¯VR¸V8}^ýù­ÜéË!MÎnEêËYa¥N%æh¢‚Ì9¨ ,zq¬EÎ%EâÖ<%ŸðIâOtÏoJv«Oz§Ä¶öjˆŒxä\#w>$…îËE@ä0&±›þ¢º¥Œ l;Õx©½ÿKíý_jïÿ’½ÿY›ÕÚMš…ÆøÉ8žá…·ÂãqÜÄN»Á£¨pmðôf|I]]¨,ÜÐõG“c[öθ¼´ÃÌ 5é#õN•&·6ÀÞZ|g –§ÁR§XuŽè)#7)7•X 2I˜LqÃð9jÏ,²˜:PÇ ¢yXœtëLS2ïã»ÌÇ!y­§ï̇»=MÚmëÌú%ÖÑáæ›1r‡Óô‚×ÖÇ`Q6g°r¨!ê°P㔾[ˆqŒñ˜>'yAúŸÅ^c,²–ˆjÍrD5i"ª5´aßû¢Ù¯´Icuì Ó‹nQ­ Ü/€¬Šƒuv<˜x¥Pb¿-j E ´¨mu®Ï°d¸.ËÚB‘¼_òPf‚’S±P,«Ó»Ì3oZÍ3oVF¬õ‚6*!HMiªˆ"3üú¹Ê[ÔW+"ä yŸ-Ñ“víHi'Päc-6ÌŽþ¬V÷=سé39Ð’¦·Ú$s…ŒÂieœìÛ¦…»9xÖÖ£¢óø‰¦Yú\¨¡ÑÃo›Ö}'í«ÁÞ3ÎîJ}ÂH}ÂH}ÂH_¦¥¦nNÕ`ý [&ü¦ß)iÏ#;1†…kñ·ËÜÙu!«+/Vwfën ‘XŒ,)ªi¢VÈ® dW^Ⱦä¹-”·bšXb89j·]\чtJU.Ëoà°pòÛ"þ·E>Ã_cl“$‹À¤“ç–KÅŠ¹,h/jÇ ÛûP—™‡0âõøxÈö‰ŽÅ ã{YÿJÌìhO0/ÕÊA˜JŒE•ÚF`c'y.Ä…˜Qv)–—®L£å!¦…mô‰_ÔNbJ¸ŠŠÊÖn¸>=4ýÖÀNÚ«Ñž¯E9ãyçó-«¡ZP­ÚiPhhVF"O¸e QT±J„^a¿Q’Cb,ÏÝýŽñnØ’ìNÙ÷̸†ŽŒ/î$ ú åÄê0ÝNË´"8·Y^´v$1“ƒÁrîѪ Ügwá61¸qÞ‹£F:ÓG¿§FÝtmôH—ödÉ÷X^¾ûsæoqêÄ.‘J£0ñš'ý¾‡Ë2v_-c' 8·.[ÞϦpã"ûŠÑ2+„ò®¢Êù‰ö‰ÒF™r÷ÍOö ÛË¡.%ó¥*JUN夔ZÔì$Géö‘r°ªYA‰ô—ÞgôΘMIüN(£`(QÿÎÍ8ZøÉvŽœ·¢hù.Îü˜dœ\  &Ãc#rñœóøãoãØe~Ð>š¨Z.xíÔ²y=™È‘ÂöôyÌéH?­ñQ"j Åq7Š]RBC £Øoh1qTÇÍ!òßH°EóÎ4ˆJ™ÚpLÖA)¥iÌäaOðÀcêæ Å/îäýŽ÷ß·û8>èÜøÄ”CV2Çò^‚G¥v‚Ê…DäÖÀç0pãôÚ¸6Ÿ#ˆú”µ3Ò_é}Bøé Ï=®z{'œñš°Ù`4!±GdB^‹À q¾®6ýïú?tùcû·Gûá8}4H¸M|R¢“’Ûýt“6ú&Òë[H¶6áçÑÑߎ ¾<ú²™>Ú‡§HЦ±‘ÀL´ÃþÒ 5O‹Ï ë³;ÄËIß”ÃT, »Õ´V5Ýãó¦ˆ[%9—M8áp¬—: –-&‹¸”Æeäü=Sn*\œnîÁGS–ë<Ý·ÞxóœŽæ¢e¹?pQûu§5AUL0Ý÷CÒ¡aÀî ”†Ä=ÿʨ‰…è^€8ÞUU Z2¡Y"W‰¡¸R4TÎÆk“ï(öjœcR¢l›ëâ®ÍEb›NR·KUB ÞrŠ¤oÞÃýî÷À§å“G(ú@b–k^h¡jü›-ô¸oÉ_ÌʱÈüÙèó±±ö3A¨lîå+1?ƒeL±UWi?Æ;?¶A}'žyŠÆ’ºÆÓì 3ŸÎ”'ÔæÅM¨—{Ï‘Ì:ĨÔú)q«QßKÝ~ ¹á¶H¤¸Ÿ×¤ÄZ¢·.´4“¯u”¶þ2¤ŒgoI¢Ëo%™ûŠË˜DñÊå”CØD€íEß¡(tÆvQHf_Ýbús|ænßù°ãþ4ßj´Ï@_åÏqN$1=^»fÔòå”'näòÞË'?Ò~‘@)£½ðnÅ^¿ zv÷0(OŒ0ŒnT#¯ùb—Ž Ê#<fuÊbŒøoYMƒRþŽT'ü¹¬H`þÀ„bD׆Lì O 9n‰Øù¡_83ª±pÛ¦1,®ðç=þ Ãåí/ʇVs÷_ÛYŒ'u%½ +w¿ðNH6‹¾Ž 8®˜ëžg@¥ ±]W?/…uÆ™˜§‚ƒÔŠÊ)9äè ¿ì—–ÌÆÉyöIv‹%ÏÖ¸¹è8S% ävo5ãäÍ‹¾i{Ì>>~®†æSVê‹&¦eÝ7¸ÇWfû6§#uKã˜"‚ ÂèW7žÓ3‰ývùFâ?Ö‰;ò½ƒWñà«#e¯Ò((ò/|[ô0ÿ€„•¡-]V„ÒM~1ãüQÇüv½˜ø+Ú÷UÊÁHBa¯Yý0÷O‘€â3—ù$¦Û?.êWOËÑͪ€gnÄ5‡¥\0šõ#¦ˆŸp0õYè~Õ¨ßF¼ë¶cÀ­ÀÀ3ã©¿yýnB羯RåØZAEl`SÇ¡JŽÉiO:ÚÒ[° ‚å7ŽíÇ$‹A1ûÉOfD!Öô÷‰\–c6\ɬ˫;²µk ¯b*”ÓÄÖX¿D«méýxQÃS:n>ªó‹¦ëXdèTðíé—c•×½dcÖMÒÅ¢ô(’4œZÄ5 FhÁöaò1§IWØf/Ùeøf$ª#'¹¤a÷ç¦á'ïN"»m.ðE6Y5Ѳv§6 Pá´’Ò.JUÓÊñ2×ôqf³‹–²˜àz.(Øžó¡’gêÚdâÂ/êïÃsXÛ.Oìáe•Ó–)‚-ÿï.¼!ÅŒ'­ƒê…ÆðÿØþ/¸ÏšVÜÑÌ­µ†n«C¶¬[Äò=úÈõý„ÓS/ÐOડ„¶ê?»Åò"aèt„Láš1ÞÔÑéfñÓ÷Ù„,”Y…»NFi‘b˜º5sŽþ=Å}WïT—Ø:Çöµu€|]™S íH«Ç¡èÿçÜ®î_(I±q•ÔѺàgF’6 ô9[Å .ñø,®ü…ˆÄðX«kƬßHüÈþ²<²÷…rn’_Š$üú5‘eåYéByí6z2ôkø¢ èWq4<òî@`ÃäJioÜ~‘&¥—%_ÙMi#‘E"ÿxÀupëb¯\…ùEwH/4¹Sú¯‚Õh'—ªV ¤å¬·I¢ï(5Í ¦-GômûºÒԵ߅v¹Ïi5é éS‰ä$éÅŠõºYœ­Ûð@æl‰¾ê&=)ÖÔÂ×T%©F÷>žüYTeʯ«$è‹£äÌ[ÉÌ[nIi ‰f˜Äe"òT7w”ôþ[R~ÏßÑð†4–oI/7«›%”Ÿéäùq"z½bݵô€<6àõ˜&ᣖփÇá݈qó­@¡–¡P{(¨Þ2Lew ,u+Xj‹ŒÁ²¯bPtÓ쀦¯}™£ «xÂÊNø7™ì G;±“lB×GÈŒýhÙÄŸ@aÁÛFeðçác¢/¢wC%ÈæX´Só'©œ!K6ú+3GW)ÛÕ\’qzpxc‰îïÌ.ÏQÕ Hñ„ï[ÎcNÎKД.+Öw`鶹's~<Ž³8jü îòÐ)›EËB¶¯n²²1k1\Z‹Õd‹¿²™ŸÊ±ù Œ³Ý’ö‰“½Y¶¶&ƒWáRµËö¯œ­ê7e9E–y´É,ÖB†{ᬩæáaMrY7.Ÿ9CÛ´e’oo?Î`³J£Ï>·BºýeVµÿÎË:*ÇÄLþ)^‚ßß¿ò~K…ívá¢9?Ûâ'÷•WÅX\W¾×Û\_§*¼ÕPÜl®¶aq!W—_—úCr{ýqIlj>~O˜ÑMˆ£Û.í廑HŒ¶Ø!€ªæJÕÒLÄ®KúONû["»4[7{ÝLG EJ–m®<ž`³Žs(Šô›„OuýOˆL¨Ó(‘RŸÑ,dzú­ò %%톴ÏWÌU›º—hù‰€ àõ‘y…Rï›>ÿ\·E½r«üÕî~ÕMôCB)ü–HÀ/ÐI0ðâ4z@!«ŽG¢}Fú_ô>—Òí3Ò¼ÉæÑ4=*uZIcczŽ¹/RŽyLø5ª ©æýP=¤Ðo›°Œ ²í3oªu†Du†øœÅ;?™Þê+e@ÀO(ªíÛ¤LÁ¦ÒC¢¡coôc€Vkè¤\]¨±DŠ~X2õ¤»Ä/JRwG?÷mx NÕ(Œ_3Íz6å…Ñ&Q³Hă-i>)ŽdóhfÇ2NÇF¥&6Ÿ†Ã)ø5m6c ~MÒYn–6Qº©âŽ-ò“ó…(ëßVÕ3Äåùé;ÈÌ 8 ÔÄï÷Ôc—HÔ䧇׋3âvûI~Z7Dî›Î)‡íœÞ4²ƒko‡99ŽúÙÁ÷;¼(î‹ðz_tÎÆeÞtÎ˦ìб½DGU…þ'«3:R:ã’TÕ¶KJyZ©Ë¼ÁoÙ°þ|JâvhÀ¸„i”êÀ8öBûÕŽÞu‡F_ÔJBÃX‚fÍ÷úŒn¹ ‡˜ŒÏ1c7²ðÈ}åÙxð™r“|Žéox3ødr,òÄ`ÇŒvœ¸d[F6^9²‘*g3rð1Vˆ‰Áø3lFy\^Ç$Ÿ®Ÿ7#ŸLŽ…CžŒâ˜±`3²ðȶñàãÜ“8 6#—±³‘† 7^|2 VœF/ã[’ŸooF6^FrÌŒ<1eá‘m Ù“œŽÍÈÆËXŽ™ƒñlFy®¼ŽI¾„ùïñfdãe$ÇÌ(GÖ+[5Òñ1z’#Œ<9cu Æ—°ùðÈíFúßëɔ☱ÈêFºœ 3V81ðÈU \FžŒd¤`ÃS>ÇŒÜn¤b—gù‘LFÃ0 E[¢2]Žû/Á0áy>qùvãfP?zÔA?FßÐá/’™½H–',›N­Ñ©8°'Úh§—ó0Úžè…ÓxÚzàÑ“nD®N§âÀfŒÖ©Sí{×îN§‚˧eÍŠF]qá6ª}7ªýtÊ(ÉhV4ª¥MèÆð€Sºâ<«%Dï›ct-ß„ÓwÒËã2lÓËH f-…QÑ}ÓË]Ë*𠺟ž9øÐÓé„K§hÏÏ_º°)úC1*tÅ\p)ö÷œÆ˜©Ã¬hÎñ\ÖpZ¥Àª¨ zaL£—\“ÃmÏm†Ø¹Àz5`›Œq ÃÞq7½ŒH´Ñþ—%IJN?Å…IKâ’‘®¸°hi“nFoph¹ù¹ qÆ,p)v§‹G|†%f?p(Î÷\Z–u˜ # zhð”NFéÔ›^X&Zh¥º8œ‚8åÀf øeÆ0´ÄzÞÁ¸£ÒΈýŒœQ&¬ŠÆè±.Ü™±ü9¸sIb ˆ¢Å›æ4/ÖÿøÊû 02³„Þ?‘gOéøÙ¿cïÿRÄÆó÷ñ‚ rÚ³¼yËÈru~rÖÁg÷‡ Vì¶/D~¶,F›¶‡=MdãcÜ‚þDŽ}!2ù4ðÙrÊÏþc…Ý!2í]Œ—ùÐD&.FÊXE:N‘cëYöÆý0{ÌÈ6ÿD6^Fy¶~"ݶ„›È³ãÉvm¼rvÁŽ—ȱ§Û›0cá+@|"ÙæWNIØqà9¶~¶59ýÃjÇ'’íÚxåìŠ]dâ9ö&ÌØD¸ãÉ6o¼rJÁŽ—ȱµa·-aÆ&òìHv]9;aø9öt{›Èã‘lóe”‚MdàOäØZ±Ù–0cyv|"Ù®WÎ.ØDþDŽ=›½ 36.æøD²Í—Q 6‘?‘ck·-aÆ&òìH˜íþá“s 6"ÏÞ&Âx 3'ø‡EägK¹¶†È´ëÃ"2qá¶{ˆ{Bdþù¾Ó¦aäŠ'^|¶rFÁ†œÙq2Ö¶»qi/9ùÚ"ÓÖ&2ñ2Z`)ØEŽíŸH±#‰|Œé‘ëy¶MFÿ8“H±9‰0jÂl{ÂlW‘s2{Cdþ9b‰û…È´?;Sˆ,›C„QšÈ³'D~œ†]dÙZE®mÁècL;C„±BäpO†H±¹0 £†È´m1z¶#D’ý}"Ç®™ö6ÆËœENȴ5D'DÆxìK"Î?Ï9¯âáFËXÂÖbOˆl{?¬r^p"=9Ï9ýÙrxóGú‰0æDî)D¦mÏö"rì¼øì ä  .›²H·#ð³«ÈÙÕž™öƒÿ8#D¦MMäØÒ5Û"Œ•;ì ‘ioµ/D&oî)'7[2n<¶†È´}‰»“HÁŽ/>»?{—ȳ¯bã œE~¸ñØ"“ìýóFˆ<›B„‘3[Ž/Ã/D¦Íï?cg ¡ÙDáÊGúTUUw‹§È,XÄ,ûðÉqóÀ˜é¾Õ§N_cÜ™ÿõ—è|¼ý÷jüjä÷ŸüV¿>_¾¼}}^ìz}ÚïÇÛï ‰ š@Ç›W‘(ÉFìE1‡8uüB›†Ü8äâ šMØ–¨7ºøl—KË R -BÞ¨ÓáQƒ‹$Âï‹\̼8­>{³E·S˜f¡ñàó5Tcpo9l‹Û‡N^ÎT¡LôÐ •÷}šöPE&QȦ‚,c¢¤|‡‡wá•ã¼°ý4ã'áØàr¨!/›Dnˆ°?Ÿ\]žpÔ— Iµ Ùèþi'™†ÜO‹Å,Kgˆ&¯˜$m¯ºôSc½ˆË9â:y%’³Ñmb×Ek/jõ¢ƒ³è9r!•Çu©¶I‚X8‡ÎAaªíç4ËŽQ”m»‹[g¹¶ÐÆF3.}¯8E°a›ð3}ãe›õÍ#„ Û » ‹™×š%oäúÕ¦T¾é0ÏuBD8öIì¿Äg¯Í¢qýZñÉÿy½zI<È<ë•­ÁrPÏ¡*DÅ֢˜"é=B«¯èÒþú÷‡¿×uV˜L½s‹‹rÜ”9Úž„r…BE†ývÕ eõ²Í¹Qânë©ËÑv¶Dbã`¹Þ~~ÿóýÛ¯?Þ¿ýðïqžÇý‡½/aoäæÑü+rÍaqÍÎçž{¤T”;ég;“<“kçëïR,º]TåMz-ý÷%ˆz‹D”å>öž#m±x‚$‚À‹ßÙ?§Ág]ïÆe«—•±_ûB/ÂÇy • ³‰þY†â—AN!ÑŠŽË?þÎþÜ=‹J&ßvYPÅþØù¯]ýmG¡4¿þu K|ûQHì6}L¡OºZàzîvJ$‚Æ3 9þHÎF,ÂÀ*ÿߤ%xŒ¸nÖ¦ÜÞ†öîf]»ýæò²u]lŠC‰4ÿÁ s+ÏE+0òßu_qìà'ÙÏÇçÍ59ï„ œ">˜aÿ{Wß'pˆ³¶r}V1nUe7ëgÁÐyHß›†­ƒ©AÿAÀ,q¢€[I4ü¯9ö<<ͪ|Ÿu^N³Øþ¨õsYùÓWŒPÅ6—”&8W€ <Õ[R6|§¿ÑÎ7›¶ |› ƒö»è3äŠIߢ4+¿Ô¢xÖ‰ vü½|›ËëÞM;Bî£õËQúœì$Xš7¸ÿ«£²¬þÎôÐlíÏÍ--ž¿QxN¿ØÜrL jpïn‹|Kߧfß´ÿ™9Kr †ƒPy>'XÉ2»Ü¶¢ [JÆ“p§™ì!Z©Ø“‘Aq¼s8•=#Ö8pPûH«\rrZù:¡0š—›»õª2ó6´a©¤?Ҩܾ³µçÿ»]†ö‡ÁŠ0œ&Ó¦î»Íís÷ßI86¿éêïR±Ï»ž0àwxÏü'F§„Š~þM7^¡ƒ ÈCÍ?§ÍÅáüøÌX(éyþçãc€qe*%×M8¾éI\ìPZ•ÎN#À}ºuáHy8‡ÞEqÎЂmµnƹâ z3êsi2ÐX½WÛÆ.jÀ¸õ¯Óìx´ÚQj,Sb_$ëP]}å5—$ä%+šoQ-.ܪcÀMÆr ì·Í©vZÍ;‰ÕýÁ“§L¡ q:Êi«ðϤi;÷×µ›¦£¾„Yós@Á²È§¡Çª4ó5dÑiXà³.Ÿ·ºÓÚê›´à+S*Dœ•¡CDÖ1ˆùìÉSÁg'íõyÖê·(8¹í¯¬v%d/ ßÁ Ç&ØC:+WŽ/wtŸEŸÛ´ÓÿAI€¸~¶îq@¾ mÙÞ‚èâ™ô‰^v;ñý}ñш1ˆŒ¶ 'äÙ觗—pù ¿7Qm^+¾Ø*Œæ¸Zq¾||]x:¾#ôHí¬’+³Â•0œªVÝ4Eí1‘iåk8R„úÊÝüä¶ZÕû^oñ©$æŸv#ÌÛÓ ’×C:p ÙŸnåç‘q鯸HÁäyGŠ6‰€sv±™6ÀiY¶.Õ¬­›pfÎœˆ¾éˆ?Ò ÐͬÏïEnln‹ÔíÌÃH;J!çÏ®8p"o ‹cÊ•vyf÷ï.`44úär2T:l¼Êؾ²š•û(ÆîE[W]1⶗,çÓ®ŽÝXć1¶áš³Ûm j‚þi]7 _óÑ]Ü“¯wëõ=e!­„oˆþiÃ?û95RÓ‘òi7†×9X<‰om×µŽ™”$!¶ŒûžI—cÉÛÆ0x²uÚÚ÷vž#zÏȘçRg̼ˆñ\}ë¼£úú Lghâ@%Qe}‰‡*®ƒ4‹Y°v3&CxŒø'ty\Ó•sK8nAaŠ´CÍw£SSÍ7Îåk5³)CâÝXßÜ97¼I§z)§zC¤‘d*m ©_¡cuÜÚÅxíxB­öÿPˆ5R§A€/Œ-È|l)ÊÔˆÀf·»áŠ¤…l RÝX*Ä~âÕ0ÙâqÙÕc!ýYûÂÌ.¬ŸþÐ%DähŸÑÊ [Â…*í-£!ˆ´Ú2|»&¶€<ë Lõ´6v‹ïr-m½À&É'òM õóëÛV2“ÂŒˆòž² €P ±è|PEá>U¯ý´Ññ8Ci"¢~Ê]„¦Â}#DG¾¦Å·ìÜñSèl•í0+e^›¸"z M V|È‹õlÍÕÑI[’¥Så£õl<ŸÓ5A›YÚf<"1 m-N ª’!dbó-‰§ëä†|Ò¡è Û®`3Þ°ÊEv·ŽXv™lü4lHä_ õÕˆÔ×u6n•ö4"ˆk@P—öŽKþt×\Ó-…'¨µ½¶K»ó$ª¿Åb8"oZ‘B^»}ÆÛBëß0Ókí&òĵÝ0ŸR¢¢lìvQ='BŠµ<«¸#IÖ€ ‹¶°Åj¶kIolz¨_qøj‘~L[cý¶¸ž+àF@{΢—¬ÇËŠ[æzt4lÒ¹à÷ÍC¡./bÑ6gÇ<|1:YbÕf&ÄP€'ønÇÎúdyO‰ÅqÝ9(˜~JuÒÅ3€Üý<(q¹Ýɧ[efDmÛÖãeÓøTßD(±j¾Ï ÍTˆü2ÚgI(î0½†ƒƒiDùÀUo½¨›C…œíÚ€óNþÓOoqÊÛ±4Ð i@!Sgs" áåNœTc²Æ,2¾Bû¿µ‡ù!Üг–6ªFèd³æG¬måFÕc2u´“ôÓDâºW¦:Q^AŠj5(’H{¶–0ƒ[=@SÚg¥¤]á·}§ª2êƒzË)e Ý*«rAD¶£H?q¢ÔI¶(_¸Ë×ìɸA‡YXåèÞå#ÜAxâÙÎç&D”­ÓU `5ã'&M_m:“qcì½>,6Ûg„`ظ×Û…Mkjñ$Œu. ƒ†¤>9ÙZ\墠 7c;…‡å+Âìq²È@J¸GaHýl[KµÙF>ÎÅW<%ƧŰ|—£}ö¼i“xdöÀ´ûÝný{hå8¤›¼×*÷°&°|= ‹œ+¹ r“°­À7’IU×…]Zºæê<;Ïš©:ǽè?#r¡º0/D®³IÔ¹¥²†.TN9ñFrî€j7Ð~þÀöè–/ÃÞðlmÊ¢7½oÚï–„gÅ€Kêç ("Ï¡ÈÀàó#¶µ®%Hº #¥$JÇq‘a·FOò4BG ¹ä4d?lزˆtf1ÎqùT™9jgœ¯HEÈwø´¨¾óÿÊ·Ô@…cA OOtíî×ÄÆö$xó0„íèÝÔ#Æ%×WƒS¯Ìà#'ß„ÇoøúMQfa>òH÷ â/ôçPð”›„b­ÀfŽehøÅæ¾åסŠòàŒNä3aì㸦òpg_khç{XN=*Ž£r¥rK½²~ºä,Æ:.]ß÷ïH³å{ý_öòzù²õ¿Ã¿{ë†ö…÷«˜­¬¡Ø¸üå¿à¿€mWÜdŽk›u.BÅò ×Oã\þ IdÝâž7Ðyœæ3];€†”ç£õêÓ¦¥«Ò¯0™]!ZêÂáûçØ2ê»Ó•)J•ªPIõ©Òä…1öjÛu{sï¹K® ˆ@†òË–þOW‰‘­¸ø‰î¸çbm!Œé”îWÈ™pª#{®ð1Ö¡BÀ;Ž›¡¦YÝ¢¨ðò‚ÿæ~"Or¢#£rD›áõ,cñøÅ>Ó/hªÓ°°'ò› ¦Åæè}‚žõ›óª™u@Ô†€<Çu[âÑ{­(Éè²Ýâæ+K)Eujùyè ó~¬N ÑÛÓæ.FÍ]‘ùÞ5)Nîj25î/ —£ËÂJ\X¹ñÐ…AÈ ‡Ö½^\ûÖf‚´xƒ³0óÑÂ颚~öÞwùœß}÷ Œw+¸¦xÔÃì=ëÜM’FápûxScŒÕ^©—ª\øX€4{·ó—iªF5€þ@Sh•±³¸‘)%^êÚNm­¿í+Ûí#®lüÌ.ØÑf|£º-¾Õ˜AÞ ‡)¨¯Ìüª·*ô#»ËD¥\õcì6ïÆö .ðV¹ù]¾ù­F7?{5`û/¦Så‘ii/ŒïÚW‚W⊦½FÛWö¥!¥é•·±dU· 2Ói.àJG]w)ÂDЩÚYEY2Ž‰a?˜ïŠÕ­aR>mdÏì–û9Tk`LóUGAP}k8wc9U TÖŠŽhþ™M¦´BßÉâfIÊ)¥~[qL[RwÆœ¸¨Zø˜ ìBÝÃ0¶£†'ÈC@ºŒsÛNbÝÊXõN­´†FŽŽ¿k´Eô•ïSŒÄ=è 3®NèR4­õŸtž¼ÍÝ‹¢‰[¼ÚÌ̾ê´Aúu¦¿x ú>a4Aí=(cl[”ÚFgÞ((ÂbêôI”gáÇËÕĵË[7i{Dów·îBóDc˜\Cœ³0¾÷¢â,yè¸Øl~îýºöf&r%PñŸÙ¿ðw/m$…zcKû‘ÙDç%qùKÅiÍjb4Úܤ‚< »zšÅs9W㹜§ñ\Î)ž‹f³7ÅG©`{®Í°_r|‹*u9%Š<·g…{ËZ¿¶¦Ï'M ØÜŒd‰4ƨU4š>2‡€‘º±h” Ýa±¼Aƒs˜^3D¬wåÌ9Vé3ÇIÍæŽ0Ð ª ¤2Îl À•eâÝÍ( ‘,Wë×´ççãöû€QÂ^Ò=bMŠaYàèh\pFJï&' “Ä”òÕ 1d©ÍÕ+Bù~€Ê8˜e¼‘)„¾Ê6­W½+]Œ®¢Áýœv»#È¡Ë•±>—|‚ ߌIõ8¨(|áôŠÔ|<•EEâ DÑd5ú‚‹)Ù+¶ò~C}ÏsP0+ÊÒYÐÊqGFÁ>ËÚØt^±uåþ¹²U<~É-ßeÝ¢b¿êþvPÍúßúÁ&º«šØMXCÓv·kL¦`…I®Å!“1]¾¸Åè¢Õ_OÄ#&}V¼™mŒeKäÞŒW.òÒ2”ƒ€Dá´qˆÚ-Ì°iU`8IßÂ7–ÎîÇ?úe™›ò† ææ·DE"_-y[ÕŽÓŒ`XØÚ£Dìæû0£¼åŠÃŽu—6AgÊ„8y ßbôŸ«]œÏ‚_E_#Ï㌦°œª_™F•è’’³”Ôž¹Üy†«¥ç±ÞL¸‘ÊÌŠåÚ¼œûmyÑy9y³v\Aÿ¾WµIWhîH»Ù„ÒÅÈÈáŽ'Ro;Ë QïÛÐ#xIܵ½žƒóá±úàJ?n…-“‹ï×ð † ã-à˜ïÂ.&žÁ%g™ííßþíÆóÔÈ÷£¢°+£MˆÑ=4öc?qÆf^ìIUVx´÷ÅìÊäÌOþä¼ìtnum¿m{¦•¬ç^É;ºÓÌ—{”âR}òùØOŸ¶¾z…B¤ËúSA‘¥vÁ×L Ò]#‘ŠWé;^’ú拵;zï´ u1£ o÷Ë«(sÍ UÄn¥¹ïðñÏ}gaù¨/€¼s*‡rêµÒ=§b\KÌ1Ø]Ÿê*ž‚¡ž';‰· Qè) ¤}ʳþÏãëPE˜Ì‘™7>SëoaëZGè€vÈ –ð-k%ŸyíàKo‚|Á N'+T–*&ûø`›õ“6tÅ GÒµï`O¿¯c>Âî GäÏ$¨ä¢ú¼°Ð=D c³éùØUÿLÂïø¬P"Û}ÏR›Nݪ°ÿ¦c–º!,)ÑVž®Ùë†bÞ_qpGP¡ó¹{¿æ„;;#ûαŽå…cá5BML‚šJ)§­v(.˜í‘&”›7ï¯Ñtsv­þš^ãÑÚCÒ:6 iùé\ê~Kv³4í[?Ñ¡‰Ž¤ëu#[³}X7âÊϧ]ªÙÌ[y¹D‹Mº^xO%=C¢ ¿õ0“õëP&m¤oW Gi©øLZŠâÚ·³fÃFº0ïšÖ;sÄÿÞÐxž;Y²Ke°/1GÖ”ë î:§¡ÄédÙNšaMzŽ,—“Aú©Œ•.%ì@ò¨¦B‰RSëI8ÙN„#O#éýKÊÐ[)MNÿú¾ÙŸþ¥|ê¾ï%Ä'OOrc’| ¬þP™Ý.ed‹ ×,ÿ`XqÙ˜2iþBïQ²×ôú„jþ‚Ów…cqa‰¿v¾±ª–‘€>#FÛÁØ oц#¹Yf†<Ù‡üh«­S~´êU¹5~p.Â4`îð;s¸íÊÄ“]ez`ôM±(ªð^gŠ³ž“Hó º¬Ê“0‡™Yò=×Ã&ÙK‹ú¾HV©ioJj Œ‹©øýºÔ<ÖµKé{è`Úw¼bÿ0‚„ø¡ãí¦n˜»ä1ÌâA÷M«3Æ—;«fþO@KV¦šGG„o_­»åo ±åÌœ·Ƨ³Í{^©[ÛpÓ«ºˆìÖì-wIp€iô1˜‹½ÎU"Ž£É‘1‡gÑî“ÂÈõû¹~߉»À#ñ3:³ôFéÔè²ç{È«ovj¤€#%=¥±å”eNíØyLõ¨šAÔ¢{ÅñUaÞ¾ß@Üj£¸Õxü‰9köN Î”'ƉÁsk@«!½äi7é‘'¬v%3ý–þ±,¦ªNëÌãÃÀµá ŠXývØ ¬Ö «žö3qk,|ÿÆRG´,ÍT_“Äi}:ANò`4qICõ§HsùÊ ]¿æ½Á C‰½ÆÓ1ŽÉFˆîÐÈFcÒÖIÉÒg¦Õ¯&’n¹WÔŒ1$Œ¶9¸~"F·™l䭇ĆæéÓe¬TßpÔ™¼ðø½¥Éî=ÖÍ“'-$ù‰%é,Û=ÿ[‹Jø¬Hiç9Ѩ‹Ö7²ÿ§º.Ý¢ý½Ñ³Ž¼‹Ñ5R^°¤ç®ò•dh™]&*‹jq} ”£ë.!¢ï­ur*ÒËÆ#,¥í8ºV¾^èöârf ú#ÌD™|•ûtxjTƒE$ÔÖw‹õ劀 C’å”#T¿àÍ\VJ¾VpH*•ËÝŽ'iä°95t/•<‚™é p~È€$Ñ5®AûSPåb]6žvú-Ü4|kBñ|ðs?BUP6¬Ææ+˜MÏUòCkglß÷Nm«åK@‡Sô‘ûÔa@«ßê”íU‘[vG…jk€å•¶ººMw;auã~IÀ xÝDëh€ÖÑÊwScsI€YNT›eÃw¿‚JšÿÁÿ%Òž”,\ÌkZ®üubyMÇ#Ùç:‚Š¤6Hïbûî„f¥öt†o¥žöÜ#ft4¡•ñyjÊãCŸL9ŒË£ĸUØ6¿W›Â¡v°¡\õ.[ÑeòQñ¶¤Hä¥$¬˜.åk­Æ9@%ªìÔF‘á>.‡K` »²z”‹sÛ庼Îø„ ×xNܲ5&É;Žï€""C)sZÇ“@ñð«~áìù`ðïGÚˆï»ÈÇ0hêðÇ|ÔÙây··i-É£H¯Ê:.¹¿^è#æ¡=µyTïGÚ#ŠR;¾Amó‹$”ýïCh†ÀÝíƯOdžíê±u¶m9¨ËÔyß÷äéŒ>ê§~{º°/Û¿Æb´?å[V›¼eAðk_8ÎÆ OŠ¹&|CÓï?×ÿOr9šÿÒåoèbÎGxý,§Õ¹··×ÌréÏ‹«æzõ'³ßîóáãÞÓŸÂàQílnÉb ýë+ËŠñP»zTüŸ:¦–'ªuõc{?WiàŒŸ~@"»%þ‡¿Ä—H‚G ”˜û¶Žã{N0&£ÿ"{‘üB¤ìWÏñ$Å3éõÔÅÑûG còŒ;Ðx·`"àhάʤ8ºujáEG’ªT÷øj1®\èÇ»þ±“!rÞ¦ù·ëÿðWE#mÚÎ¥’+0õ«cˆpé%Áž«à½Ðš½v™>h–ÆF©EÖ˜nT'?ŽŠß¾èê{ÒæΪëÍæ¶ÚÛ¿ø"Pí‰FMûÜušZƒXì¡KPuMpɃ\4‘/ðÀº6-†uC¦³.ª°m3ùµºÜ~·)†NùקuM¸§÷÷þ_4~NŸ–Ó–›¹Iwö”UÔªVag(ûÜœuprË_c;¿1znÍÐòãßÛpù7¢ö¿ÀÕåÒ|cZôsA)ë ]0$õÍYwö/>—ÿ¯x܆»p64±¾„1|r¯éúàÑŽ!«¥ÖŒ—ü”ÿu€!>ØÔa »N°‹‚¸AMè¡£Yß):¶)ã'ü9á [»Æ³s‚,±r?Ýyשm^ͧý—¤†´ÜF)±Ñó^n”ê?ß(5+¸‡½eþIÑ—*¶yIK‡09tHÔAœ'4—Š’óRgÌósü:½ /•¼Ì·!]/ž\J.”ؾRòo_é¹KÇJ +…›ºa»²×SÔH/ЖNötŽš¤µ_½, ¬ò)Yï™æ)|ªš_WùÂrùب!ÏõÙÍmW “£˜ƒ ¡š›ð[‹SŽTHÈè® QÆužN(ØÇ)5H?n–¯Ø£zy{ëüífÙÕi·¹\“ôQíñÕ£fj…M!O“øŽ¯vZBè¬ë8øÄÚ?Œ–&°ž9ͶQÓŽCIž[ŒKa "My÷ Ðz,Óå1ëhî“ù­,ñP–¹˜%c}NV–n•v„ ãgZ³i¦¥ÙãÐ)ðuýɲ ‡…ïžÀŸ¶GÇ>Ztl ;ÁL&Xd›y6E™ØŒ—T¬ úæýÄgþÙYÉ8~¥[60¼ëºoÐål^5¤°fñ~ûv½%9™±Z×}b|Aÿ½0§E=?ÕœõP·Èø~Ý’ý‹Ÿ‘‹Iu¦JÇí¢ S9La5«²i­ mh'±ö¼€yVè­Šè¨Toqó˜¶@¾h|ÑÁ Y¿œ<•ÙÜŽ:Àôey¯ Zrø³ÈÖûì(Êlp¶ÂdR‹ê•U¦ '檒’;‹|8Ã49ÊwšŸýâvX©¼îÑy=òÅ™¾Ûò\r‹ •&@ EC@œéáºcÕ’ñ‡曵 ËÞ”õ$ën0}’UÌöÍeE§žaáí!4€½‹ç“`“+sеƒ,c·f&’ž­Câžé… (êArrž€?¿­ñ-¦¹YEcF¨àHQ0šø*jó15ÆÌTÔër9.…m"O^í”:êØÎ4äªå¸æ¦Õ"Çn§ T#¤õãyÝìH "ø_ö°‰cЩô¨o¯SgÀTÑXÆ.¹œ¼èdÑñ~°„Ëa¹Ë¢&W¬¢íB^}¼#­…gÓ˜ îTMVÑè)´ÃÅL£\K«†‡nšõrýàšZ¶€ØȱRž+ÇÍ_8nø˜ˆÖ™äq¢9åÏrxPOòÓ£—ÕñÊ¡šCF–¦WL®Oè%í‡}^G"ŽØfá°=UÈöiÁýK‹P}åGÓ[W?2zÁ¿ó]£7|rkã¦Â¢*Äóé×”k¯U×âJ,›ìa‚j:‚¦‘DºÜ%×6J«k„ã¸åk¡Ò$s”g„½I’Á6Ì‚¨[4ÔGnn}ürQ…ý%­¸¨Èß¾:Jô›‰Ô™C}!€k·…ÛúxÏøY(š?Š&té±Gp(› êì!“ úzl¯’, Hº²ß¡ºx´¨VKZ´éR£]Ê´¼ö–[y4†äëWf1nGšÚíbôC¹Á}Õ´-Y„ ò¾òžè€t¼ÄŽ üh²sDzÏ‹V¦Ñ (ËÞš˜óvo}r å«ôwå!H!H—2HWuš›wÉá#H™‡ÇªŽ ý—ƒñèÉQjFYÕÐ;•Ÿ+ tä¢!•£‡FG¾¸þ}ZéŒ2Ð646DÓo¢ÝLÆ*è}Ò ŒÏ½:fÁJ™ f•ß <†½, Ž¤ ÈîÉ\dSå‘#åuô§ý G{UÐø»ˆKÄè3 8R¶îƒÝ³³”mÖXYÓ,Ö´?¼„ÎVáÁ!ÝÑuÍe€2‡]_Êã'Šï¹H£^ùrÆËå„gúnÇŸ"ÄÇ{BÎ ú5cˆ^ó:œ¬’5†b«-s,fm¡co–¯œ*@íQ¼UÖ-›ÆA“{œ÷èï/éO«œ÷´èùˆ=t  IÑu}-,Á9·8Ø=GŸÙÒ‘®ä<%]ZiŽHS;1NÜõp:)Ê1ÄjÐE?½®»MÖ©æøúP¢$켳ѬDÈgz æ\×´¨BîD÷L _'zM©Ç&£4#0 ÿß…(­¶Ô® ¾°˜·ó¹,Qœ¢æg«iã+´# ûEËU·•wfV…ÛCuLBÞšîO>Bù>¬ú3¬[kE©hè?–zñêõɆ0<~›üÄ—¸]’#þ/wÍ6¸˜RM ÉÖÒˆ¯9¹‹Ñ1&›\ª%tcOò°Þ|r J,‰gš‹¡Â ·"g¬†mB<í¦b ú\#`â5•L=© Ð红%â=û”] ” Û`pÙ{]å…Ä  Å 8j+£6#à¨å8ê¢ %+®»¼X÷.àÅèÍ«; $S‹o˜šþ>À¢4$«µàv4´ÍhhËlh ›t Uè›iøaÊJÏ uJWl÷?‚ =…qÎh£+Wkä|¶¢,YrˆÇF~deüc¶ØkËb‡ð3íµ)W ÂjÀÁ)‰o-,èÖÑP$2ˆº ™Ê((¶¥dÈᙋ⡪÷°ØÞüìÄEËƇw¶0†ÃN¦à¥.v”w«Þ†„AÑ’ÞBðb|LÏGÖN8w-“†c9&3ùí‹ht‡m[èùI2y#R¶ câ6Céh 1˜æååE4lt½À§w·^íK1’¢¤‚!›¤îq¤Zßè|‹1ÊÃázBý®uA…@wl?1›Ö) 0~1ÄÕ‘Ò&€¥Ž[$˜ÌÌLRÃÚZÞÇá»ÿK|.1ÄBÜ6rS„0-t$WF?;3MÌŒ“´SS̲""ºCHÝ65ÙWnÓœõSG©¬E·[wÁlÊ’Ìɹÿ¬Ùv‘ˆÃíÈ£rÁÛRZø:z¹þ­sëUkÅ¨ë² Ê‘¨66BPκ¥÷ËíƯL §†úqpÄ’"G*Žh]_ ­ü\ÊññÔÜG™‡‹ÒŒ÷_+;~¥„”‚útë‡i[ë樷%¼™òOyo«Õ‡é½ƒ„¼Q¬ó^¶_ì†ÚVߨ¡¾ µˆ¼’+S‡KGq{¡S¾­`<Ì¿‰‹6ê0ŒQ:¤hz zÜZ”fhô¸BP+Eθ_›Y,VÈÞ¬ˆ'ä©ñœ±…·e 6MÂ7!J‡O²àØÐ÷ÛáÓÔÅýœïYóVö,w3ñÑ´mvOuÙìØe³€H½ nƒ‚ûñúÚ?´¾HT[e/wé|ej­.Àt¶ŒDЦ‚— µàm†˜à Æ ˆ Á6 í)PÁðÄn¤Ùšñò¢R¼ž°ïÀ¤Ç}(-aÂÜC0aŽaÂr«64Ý°‘ïÀó¾Ü$œï5ÁDo“[“Þ÷hnq \P¬šYÉžŠl7yÎÀdJæ £)ü ]6hO•ÃT&#[§`¹¡0#2(ÌÝŽ¥çâGbû¥h¦ð=µˆ=d¨ó¦ÜW“8` üžG+ZÓ¾åHšúšy“$°yù[ÕÏ]¶•Y(åf}VÙî±JÞ÷ñ7NWÔòŽèr˜x‹ñ8®Sq}ÙÅÓK;8ÌLæ+ba Áw+j'krß²CDïxöZI ÚÕ죪\J2ewúBËìˆq°#*Ýq0ºÐé¢æÐùç]§ž §O&öƒ}ÃÄÙßÞú -Úí_‹³8ãÞ&gÑ‘“=ï¼÷P˜K‘£´% Îôx?±cQ6¦eto¢{ ºkì¦Ì(@2 `2›ŸÝºî»M›—¢¢ðoÍý–&Õ'·œLrÙ¶Y9„‚H¢Ðœ¬òò_þGuïÂÕ6î4•âÓó¬õ‹H ´´5uóöBw»Û–.´{)åÇÞ‡µ(KýÝß4’l‡Ðçvοg—ØòHF£Ñh4ªÒë£C´Ö%¹º4âèQBâ<¤®aj›rœzן‡EÄ&5,"¦"þ‹øOLÅÿºm¿*®vÕˆ¯ý€tˆE-äqX£ÍLsÅÍköã!£ ìøxØÀ«å/à ¿T}³3i˜²­–ìÿQõ‰ò˜ŸFÂë’|;Úó¿ $lÊsâ%E­úö_±dÜTZq÷ÔÁWx³õ‚Bϯ˜wX™E2 ZK3D$B=C?{5þ—\m[Ê ¬ÀÝÚHôÌû6úÕ^Ž-òî šæ®Vìq#ÀxÅa¿ÒD OÊŒ#Ý{þvXG±Ïšé‚p`ÕÓþX0@íWÚ,P ha»ÐM/pÂ/ÖU„Ztë¿f¹Ò*ŸÐô4¥Ëœ‡ÍvcÇX¥eX²*?¼‘HZÙ`óI´ÖPKîš°î–0½]cvQÑÒÝ•âVýèÔî§J¦ö)Ý6DyXËv%d»æÊðI-™ënè—°LžüÁ `CDz<üºê^«epÍí⪻j†¢I\/.š¶€–ñYj‡mæÆ&†Xp/èãJo|”r«Âv›©Ÿ–´;ËÇ ].nq-}ÃcŽ­}ß×YŸ£aù„/Nt!ûxr•>2{!š\ç‰]ê}3C±¤î ÊÿZèe]ïUG‚&Úa›Í“vÃ|1"(ÓÖø¡)X\ß(3C™6ß½Y F³6¾áCÝÍ8$ô—ñ4´jÉU½è­äogwL#ß¾ñ­.>\ÓÁ‚ûE@±¸èé ²²šà¯ MÐ'XéÉuñNœe°jÜRNWÓÜ:Þ`ÅÑú¤Îbià@®s¸‚?7"ãU*ÈÓ(†)pâî=ð÷H—íëomt12ÉHö;.'Ï=½œ¥IË ¶~†®ïŒú,ÿ@¿+5F üJ Íp©¥fð¡å¬Ý2Èá¹—˜æ¼:´ª®„V(zu-ë´Eø-¨e4Ï'¸k§&ÑŠ%öÞÕÙÑl ÷sµOÏý¬"&=hß5ó«H‚'F-r2ËUB–[Vé$]S£jø'°ENZu·É‰‚Néq€dqdjY:Õev%WLF\—_²sý 4qœ'|X<„J¿7ýKCH© 2ž¶ƒ? ½å"Ñ‘&’ŠpC÷H}› ’DTÂã” ‚É æ8Ä‚8ˆáºìY£¸ºÉc ˜×Q—r•ÙÌ#̯À…õÆUÙÂ¥»—Ú!È,¹\Ÿ=Ijìä±R¹œÂ´{Vd‡W6`xj®¯áRß„ê|\6f5Ø–äË9 Å1뾦P-pçÁÂßÍ1–{lÍjY‘ë5®;ë\_z¢BQVlÅwW =·3ѾÞëè!ëü¾"šúÞ¯Ñ=“¾R©¨ÒèógX{¦>pö`&]+šH[¤| 9Ks9J£Ìž÷þ½’üëî½%[t~…ÀÂÄ„‚‚8bG½é Öãéè(V°Q¹"añj8Já5‰g)ü7Ìϧ¨Þûüyþù:Þ_[}×÷NdÌ|…l”ÛZ\¦½8ZûÆ,ž‚¸¾ÿC¯Z{yoCF8_Ü9Ÿey…71ÚæÑ ö¨Ð×1úÕBˆxŸê$®ï×âÛþçùËGkk«ðóüÕ«|}A¯¯à°ƒRP{ÄÅ@ÛdAÁº3Çú°6<ÙzÏäHR— 9NOâ\BtN‹…YòÚ„¡Hr‰¤-“Âlnk§ ¿^%‡¿‰DÎGèì ª½¯s¬·ºJxÉçÀb%{û,³½"“ÏÀ~üpX®>~Ø)¼m>€·Íæ ­]%Z» ¦v[ð„ Guzxfÿªzªnˆ(ºnÆ„:‡Ž¶û%,aMŒ‡Œ‰áͶòëiÛ¾uÍÐ/®X0Ò,±;ѶÔ¹®úX+D¯€%oŽq™¡è÷®¦¤Kô¦W&ò#Uu³|”ÊqA»Ííý‰mœBueYçV–à!™k¡4PN0®™ë¢¯Â“ÓP3ÕXRóýM¨ÁK¯mùc4LœÒ¥Å ¹ùʃmøÁÚÀ|žã|ù¶‰^$S>â‘&iv içÿ¡)Aκîjmq–Ã"¥sÓÙ¨Šg">CêÌx£ØEGÞܦ¤Hïí?z|pf‹™ê’‘"3 4I¼×G~^ÈÙ…ãl$ÐûYÖ±}JK€åü,®¯V: FBx3nå:û'õ»-îÚ‚­#GíU~’>»‹ z’JNP‹g/> ÚFç¾Sí˜rTj‡Lˆ"Yró¾[1óbC*u a”W.$âòÉ$KSž´ @6ŒU¯ÍÐ¥¿Ùs„Ø.Ç£s5ÑÄXѦ;†KbÜ'ý¯µÀï=v¥¿¯^¯›¯©h©X·.õµx?w{žûÜn*³ßMT@!çµ[•ÀgëÊ£ã»Z_9 °¡„$ £†ái0·ÞÕ6@ÆêàØîsìín2ˆ=6Ø•jËï%†ãÖµäò³Jÿç¹¹2ø6¾•Nôx“ô•Mò¼ ù´|·¡ô@9´pÎ b¾ÄÚÁ`²°G‡qÕ»iJèäS.]¢=µc¹¹ÒwF»î­í>Dµu¬E,ÅvÑx_óýcxõ…×B²ÝsYÙ ‡·@·¯T}ΣpWS»vÈA²ü7üöë9¡DÛìÝã=LËÜ2<×rNØ·ˆx¸ÊívˆîFh?Œ®Ãû ÷Ýh8ôFlSiñQ‹á[N+þàvê@ý}£Ÿ èx®KÓ^î„CTódž²¬6°¦vÍ5&í>§6mÝÂÝéb¤–Z°.„-ŒÍ|GŒu«ØÁmr¥•©ôñ#N:bÜ\Ú…M[[ç´cLûo !n瑱`(ÈpÄE¾ÿŠ¢U©B?¿Žž+!jKU8/¹Üý3=™‚}dmõáAïžÀ0¶¥Se•|ä”ë§ëhsŠ2¸&W¢ X­!ÿ·c‹Åš¡ïº·3®à¦€)E°êŠøÍö=vd• DÏ ü¤„‘ÌRK–˜ášhS6Öiy£âû|äÛ?•nwè.‰16«DlœÑ«óLÊ(ËK¨h†sÚ®“È Æ°­Û¹§åé¢uÎhã8—™®ò'`y°ñ`8HÖÙ˜øx—FÜu4aMV7«À¼ª6c†ùÊrA´œÅ¬™uáy6†"šÝqìfÀ?è–Ûd[ÀlÅj8JÆ".$ÝiÓA΋ÌFÅ‘žÿâÂ×íë³l2êÝD«€wÚJdËžªì¡>ÏhÎ'ßJgPŽ›ýÖ´$œj¶Cbâ6%“I¥8%thh¨—Õ[hiÏTú¡’¹JKÜm/ðwðH˜ÅÅLés™Ò #ÕåŒ=SD«´¢_ h·©ð/¾x{õðZ˱®ã±­ãT¥™òK`‹©¾©êˆ Ù$wH,§t À„^Ñ„In-Ck:£U$bÝÆ<¬TYŽN”@âÔrVUƒWŒ‚Wqh|9UìÃTØnœüÏu£m›UÚzFNºÒ¡"øtŸn«¨¼"p‚;Róm‚ü±½g`ÊHž¨Ô!×d¸^|'Uf?OÀ%¥WkD%Fµ0G‚ŽÔ5ÅS¼£ç« ry£N%‘Þ»ÔJó¥èS.èƒ#Õ7³îIÙôDIÊß/UõÞ2 ØMŽ<2wý!}Ué‘’šú…¼Ô¶¶‰¿/yؤß1–€µÑçýç_ôÝ5ø€Aéð™N)z*•†qwᛪñªÕTqán[ßÐì¿éô>aÄq| Ë>›ûoÇYQïÍó/©rŸ÷Ô¨Ÿª‰ý`Âc\‘¹k>Ñ€Æï#ž¿vŸ,VQã2î²È*pí¡íné¿*7´ýJa–‡Ît5™I=ëk,‘Ðà¨o×Ó™î%Ò 4l‰‚2Eèo“ôÝdäO„Tƒs¥j¢ÎªHW·a\öƒ2”H¼^P=÷Brɼä ýö͵^McÙ)£«ï~Or6ïðèmÞ@UR×F]J¬·TZŒt‰‰‡”ˆuíå&º1"}îç 7‰Y¹pL)¥¡&§µ™´âAØ<9…´UiƒÛ‰jKànhÕ¡N¨¼®Y4jßw+¯¯TúÞJí—áøµ‚rªFðRÓo(4OÁw”’ÔÂvàC°tà–?£LoZéÄw‘¸Ïf¦§­ÇÁÄ zÜwø»ÔðàCÞÉ|Œk¬®ÙL«YU`àL2 0í‹-E¶_b©"ƒeÍ="È"Í­² i!óýÙ(ßÀª¦âãÎV.êÜ—ÝûV¥/•V¿©t°!?©ôç½wf“:;¾2]ÿbÒç£{òG“ìì›ú*ë!Ùh™wy× ¯˦Ê,S-Nkœ*R^Ë´µõ²R¥ì#Æ,Ô¸s®Q‡J* öÆÝšŸ¹e5M›Ú‚7Úe'óÙ¼´ÇT÷ŽÐ^ÃdrÂV¶m?šäÀ"÷£r{Ã+ñ,íÊlrÁkÖBc0’cyê¤Á4½icOõ¡“‚Ý<'~òaî6÷ô¦ê(ýªúvSo*°šÛZ§:Æ8xF¶Ú/®ótê«k¶š[[ëBsçØ´j®ypTÅ#Ô©Xñ\Vòzº †þ™04ŠûÄÈkP6T[ÖBw¾pµ]·õéäc§q?;ël§JO)Fï5Dýcˆ;¡Û^a ÛŽLõI„®F¶ÙÖχÇ¢£Ù Öê¹ ˆ8Î’¥ ,‡úï‹¿öˆ¹¸é5´£ … X*šd©ë»­íâmßm­i%gNï* cܼP†íìñæ}!sü} úÏáL£Âk]¡¸±*˾¹ý7Žþ™fGž¨S}ë ^b¦M!GøûPÈ1ÉûÑy¼¿?ë:ÜùEFø7:ú}ïÃîö³·‡Û|$òßì÷wÛÛ/_¾~ñ?ó‹ýº½»ûnGFæ!,Ó –H¾[˜—Ï>ÿøŠ¿ò ým{wïõÎ;†àu $}öTS+w_½ù¸÷“Ä—÷Ïv?¼~öÆKÙûóÝ ïõÕÇ7oü××ï^›Ççov^üÅO]ññæÃöîöK óÓÇW¯Þ>{w¸óîÍŸ:a÷Ͷ)çòrûÕ³o> áž}ØþñO(qžRpÊXÈs÷xì'îñÌ=^¹Ç÷xä¿ºÇ ÷xÉfæÛfóʨ¹3BשЭfïûòÀ.½÷çi•Â¸¿®éýÞûc´ îøøöÍoî‹Ÿ>¾ûEVýãé¼Ôaãúh3ïÂHg½›³ó•þ¦Ot&è‘d`q‚´ç_¥qêíËä\26ä¢!©ÌBú+XOɘ“mPÀ0xK<þqd»€÷òD‡×ïˆ<Ýkà;%@ÆœÙPâ$ÆìòyV¡CªÿÊ…ÿþúÝËߟ¿þ°÷í›ðT<ûÃX@5—‡ppºPS¬Ÿž¸ê7Û¿mc„hJæ urw]¨~ñi^‹ªÔ¦¶3uö†+4/\'J®Ö|äšéãâÊÞÕIo\mY¡Fpr 7%†ã¤ÅÙÏTSq“LO£ ÞïdZàq~ÌÍÐPxV™ëBéÚUšT¸ˆvöÏ´ä*úŸ`j±F²ý+ÏÐŸå «Ic=úÓ§ÖÌ>+UìeXcÓaUá­%3Ÿ¥JcáØ,&ŒÍð ·ƒtá:Ô .ÁúűF`úzh~“@Œì¼}¿»½‡Ÿü;²3‡î1é½–,úòŠ`è„²Ë YJÇ3–̤ߕ†h'@û>êÑãy9:V±˜æóÑAºFO_íÖÌþŽÊd–ãánБtÝ!jÓ+צ8è‰û˼[3.wƒþŽ÷²Ð®,éWL†ã̽¯äîs‡²Ü¹Ú„o%GA¾JxE Â~Ãèikú‡¢)˜.¢¸+šð4aÄ¡N!df{Ej•ÎÒŒ ÆCûÂL,ÙTZ1SÖÆÎÏÛ0·®Ãä« U2¹1ä 4T‚ïå«I¸Ÿ¢R3Unñ”I°´Am¸=^BZUC9VöTs.Ûx&¦™o=ÕcMju1Š5[ë?¥Àí·;MG“©¶Ìýû2¦sPÅ©·LpµÆÕxŒìòÓ@>µ„ÃuSÑIÆ%"THÔĦ¦¹£^Z¬–h‰¬õÅñŠ%û@@ˆXÈÓº&ý÷õßí¦ˆQ}Aq1ÿ& a3íÜ&Óëwa¦/·Éôã§×ï9ÇÞ­r||ççùë;Ú³ûìwÎ÷ìÖM ó½¸M>‹¢êÃnžiK¥ê¿Îéyžü';O¿àÃ<ÇÇ=É°»£Ëô/Ž¯Ïàõ£†{ѵڶï(É÷†ò»òÕ+4J˜c :àÌ(›Òt©ú§j4±Ï¼Õ߸q‡u°³nƒû±à§8ö]ní匢îªV6Nšâa”¡¹±¥ )M"݆Mqü}¿tì­jn¼bLÍÂFÎb%é•'®êtCqª¡ÓgÁîP½ž+Ð, ’ Ô%QH`T/}é.pæŽf༬Ǵß=36NbezËœ¼+«4 .‘j+çdÆWÆ]¤J$î…fal^”r–¸òUÆWBuY]'Ó<Œ …ì‹iÞu6»PÓº1FclÎœ†j‘΄â?‡| ]e jMfŠüÔtŸª)KX̆«5–èÔ§›²¥O•P«J!Kx3íÀ™5¥ªu‡À~>b§ÑGzÆrs»Ã»*+GYy$%8¢Y@”y^b¤ÐNª¬xX‰k*çUüõ¨iïÊAoé?ÓNé‘ ’‚b¹“ŸˆÙ3D‡Ú"¼¹ÛãÐ ¼U›yW8\ Þv˜òómðnž­¦èhkRµeKõDém¡¼q°c¿r²Å«®³{ÿ Õÿ…êð^§Æ5k^GP¥œ@’Áéà<$¿ºwfí„ií-¡ÜhÐÛ££Å0Z6!D‹“=DC Ý;²„Q½ Zf>jœFS©¹ fËM9\•Ž×eÎyÀ” ½d¶×•4‚–ƒˆ•)‰—Î:wÕ…*JuÛª±EPµßœ‡ÆêêÍh }B4NTsÙÖGWÓss¹<“]é]cÛ,­/ÐÚÈ٠ɠЪ‘½°bnlgÅÔï­ølt¾œÌ¤çȼÝô|K˜ã:L✪!kðÀ¯³lÕÏ ÿ>4˜·EƒèÓF¡&óq]©Ì¼Vw)_ ½âcÑ+ Üm#ØÕáéJuv^]é9™NTæ³;æ2Ô;s4f4FµÏ|¦3-qr7ò²­\3Dò†[ÿ™qž‘Ü„`ºßšü?G–ºþ`h¢-ˆ(««D¹‰-ª™>ÔÕ==éO±W›‹„¢äSMu³üã)«³bîŽï¯I³¤~nx»~\¤7¹ ¶C’ë{¢ÃcöÒ‡Xïí¬ÑÇ*ü¸åc-©ž¨z²Æ"j«¢l)†ÅyêeŊ¢<ΗE›æÀ'• |ȳß~—ö»•!ÑÈ-ü;hC=óÿ ‰üdY ÂÄxªpˆ ±ˆ1šÄzZáwi¿ß’XÅMìOÇEvŒkù”„Pf¹–~Ì’ô“fÎçœ×'-u˜ñ1†”ÚWôû @ѵ wKWüIX<Õ&³”r:yÚ(CŽX…*gÓ %ÐÇ"èpä1Q³ä˜Òöî–çèWÚ£ôß/që‡ÞÈ ºJ¦-=;ž¦ÜZv6<%\yRqá‰i6fø#úî%£ZÈk•Fèï5–åxv®›œ"#àS- ª£x*±½0>|bµ\µøh,„´1¹[‘h·™·¢Åœ9Á\‚ :…ýü©Š[$§h%èþê$„v~­,y8L¤’?lÕÇß›ÁýWò.5w(¹áþz¼yÑ@<:çy0>MgPÏé.–âÃ(ꕉGÃË°L;|u1y¬tã‚Âr¿÷ zÊFa÷yáOQ¼é E!UíDFH‰í¸ ²iåì¡Ê4QôÏjúîøÛóâª7/zhl«á¥ ô»3ñßä¡ðÿþ`pàrïp|tGò¹3q "#µ·8: n —0ZÿÂpò'À“`»,Fçöœ‹w"”°æ©[ÊÍd6k9ð¡;ÜÝþõãëÝíÃí½·æ4tôÞÆè@ÅçðP•o3æ5GŽ!½w/Íâu!ÿ‚Ÿ5!ŸÁÏ@Èðs_Èwðó@È7²nÅî>úGN¼º„×ý„€xrzC^¢ÄIÍðnj¨’] '?@›B¾ÇsüAÈW\æ"¦ÀØ[ 6 _„|ÀuÔò%6Ú÷~78ÕoÁÜy­åXõAñ[ÕÏ‘4íu4?Áø”DgЇµŸÈ­E<ïŠRP¦mÅixÅ”uRʸ P(åoB`ýÈ,ø›êÊX•£ ý‘vU×(Ê¢]A>l‹®Jæ¤ÊÊYjÈ^xÅ…;@6¶0³áZÂGL¬™Ñ“ñ–Èögû£íX„ ÓF¦J<ö Ï•*^¶? ôEîSbF”€qƒ³ŽÒÕDéM`¸- –3Œ%j<Ì}ä>²Æ‡µM_ÖÏ›Îå¿-ð-Þr-ÿ´E•(’oaÄé²2 ™²&OþqÒ÷cú\þ¢ ¤í?(má÷wü]'¶ø1 L(?Ò=hÕ–øÑ=c9wÓåOÖ3ÝŒå?ÓŸú‡°fŸÎF’þ¥üÒÀŠx!‡ñåDþš:ÍXþœþaô(¼]¯J¶ÇBÿ€¢ ^ir/îNoŒgÏ”ð5YHU¥Eü'žzÉrdmzÏ`„£ön?ƒ½Í"¾Û›Ã²B–KײêàT.ø[=Hc$?Y§k(°\nÌËOò)W‡ X¬‚Wö©ºkèÙFœô²t…±Á2Ø{]àÖ"d TŸe‡ÜØPáÆî?8ô0µKú“ZÐ’`†°’uRЗO”~Ï57´ÿ¦iæn#/Dü3Ûaµ˜û%ÐuA’rëÝU…ɱuV¥e%ó ‡M! |kÏàÐr¤ð`D¸íÃÊŠiÚÏH=2œØÈjÇ<Ï+CÔ_ðH8† ×&r<™8´Þýv”å[üÔÜäôBæúº\Fø¡B‚C29õaãœÜ,0ÎxÆd &êE6”í÷™Î_Úü2³2KH…`zU×µ<­PRð¡¼i•vj€rΕËÜ~x©hõ7+äù:£tÌ_ChôŸIÅnEpÂåÚHä³*=¯bHpB²yÆñ¬ê<äx¦Cߔ鼑]â¹½*žT.‰lcÇœØ ]qU¥“JžhBAwiF|,äW2ò0^¤æÕ/²J/´ª^eSyX¥Ûºé?e˜ ôi[¹ƒ‰tïæ¡ ' Â6»Uê°Ô§6äÁÓ¯³R'ÍÏ{•;œ°SÉ¿¼×/•|V¥KŠC÷/ÂQêÆ—fÝ;Œ÷ª!šw´Ý*‰ñ9Ò¿%„É覓Qv'­o°. "!`çÄr«"ü µùL¾ÓäÅÃrüÐjÚvÇP²]é,vò¬rª •‚D-w±æGB¾ÖBôÇa}_Á…eq¿7LîÀqçsžôD¢ÿ~wïÉWÒï}ÎïüëßøþÞ“Añg1“3Š†âµ½±Ms&ÖaÈ$\ËŽ¿4ìÓ»”KFúcÔeD1Ó7XÜp„F1陓q\j‰]-,ð50¯0× ¨N±‡QY¡e¢ªu±Ð·¿…Í–e°,«âEw¿šj¬Á*º,°–Ÿôðƒqø6¡¿>ê‡u!ÿn’×E¾dá‹CÉ|ÆìuÓA <Ÿh"±ìIæ*\ ’ûùãšÔ¯ßõYûyë°!«t.ïjFÛò§jéšužO³ü‹]²ÂÀé²êË?µ(‚ÿèE·ÜùÓ°[-Y^ùÙ˜{–Õý+ÈKùóM]Í’§0Z*©P‚\P0WWZõæ»"YÑÓ3yW èÆ"YH¥PG¿›Ù=ɤ‰2—(IS%Ú¸øÎ-ÚE¥¥‚à+gj’*û£Ë`$‹¡RÝ&CžŸ4:Ø‚ÅCÛqMý&@ÀÊ•»_;¦~$Ögó§p,ÞåðnÃè ù) ?oåéÏ8ªZ5â(¨]Ý! ÛÅ‘C5šSñ?Q› <ë>PO½×°2´6„`{ú¬ñ ·E™Êº£Lå\¡Ç«žÝ«©åLá€Ã³µø°:$><yŠ`äL;KáPàÆô'Ç%âèlò ý¹.j{ëTA½v‚g—£Sõ5b©1oÅ¿Âœ«tÑQb$©9þšZ³õæ*.Y¿£$%ºÌ:Õ0°>V"Ak"`3ÏöÝËý—¢–Ç”è2—ÈF%”´úHÐð(†ØÐ3ÕžUo5tö~U'J69GN”¿_uÙع™øÑú/裼Ò} ½~¢»t:üeËÞWEŠÛq‰±À¿jKñ^5¢)¥¼ÔiÈìr[u· ¥Ûz¨äNç÷K)¼y\˜)1(±] ô/(nºŒþ½Ù¬õß¾=MöF°+ÂèP¥`ˆ¾`Ó³HPê«õ6ïÓv2¬“8 tÃu' ×!›=ÍçhûÝÎö»:žŒÞùÖ$•;R¢¡9yO™3Æ(òb¶%.4BDØüÕìs*Ìj>'†k¾}óMIU`{Æk9—8¬’†>²§$›cNÀÊH§j"q2i57è™c€AÛ~à¶éÅ öR¹õÑÌzðƒØ °øyo‡ÅÊZ€Ñê]“V¼¬-¬¾nl½·'‰\kÛÊi%Y5× ï­ôQœdÙ,´:þe.<ÏX#<ÒíâÝ)@JHk_c» fÏ?~|fÇØ(=ÑÎ@µK-‹äŒŒ¹M ÿhØ("û¥œÉÌÛóÈÜÜoëÊð8Ô˜uîÃŒñˆL¼sŽ7"Ïùq+‚*qXLÑz9<çÐI¸Ût #|ñcIüDÆP'øl6|à´y<çb¤·ÃzŽÅðÁA°Ý~‚O¼å{–~QØŽ«ô~å™,1DÀ±Š¯0>ºÀF½ê‚Ø⫼—éñþ•6!éQu9üšæ梉„¢¦"¹€¯cx+Á êR.A­çÆø+Mó¯a<›¡mzÂM–—&~ÎWÚ×<¯%"š^úq-Àø;ÝÉ•d¢$i5ŠdL{¨si¶W“2ÜH=â:²´½lÊoÞ_è«/¡«õžÎ0‹Eò[…aâå… û´"Žp›Íx Q¬Û@Ôµ©ß¬ > µr©wo‡³¤ðwô”ÉK-‹åX!õ›e¡þÓ8Äè+à6ä»Eý•ž©8Øiv«-éÜ€ ü™h¤É\r´®™mÛÖ_*ž1[ƒfå¼!TŽÂ.VÚÐ.Ë4¢¬Q/ïEtpK?ö÷òë’†ª’È&Í ­ä»Žz%hCy-D$CiAø·AÎl+Æ~+Æ’³£¥C>:é‰{ÚóÿøYt9ÊТ;Çãö<³Ÿ²œæ,rQi§³Ñøg0Ì[S˜¨pTÂÒéN$ÐPÏÐe`Hnt?Wd„ǽ‚i›D‘ÀW¤oÔ;íE\ R.³”c/ª›ÍÒs9wüEßÒ© +õWHmzŠêˆê-1HBSÎ9ÝÇãõsØ ú,Ë!ùêÚ“p±ˆºå͆ùlýEªú‡f$ËYúLõívQïC}…ßF0¾iQŽÓ÷8ŽÍ\£Ú½«Å·%~^ëZ8ÍÙ…Õ¦3!›•¥cYÖ>Ù+ï(u¹¢c,"íÒ9FmríK Y„s¤š.`¦lÙ“™ŸÀ'¡þÑÎ0nzl}w›;Ú<ñÛq®¹õ¹b4¬|Ö@mÀ£“¸9o‰Ù–¶ìMh]5³ÙbÄÓôø»;3M'§ÝÇAÇKû= ø¨4Е*Ràœ‡ã¡SHAÃñ]DŒve#]UFÇ f𶠷\£àÒd³¿þ>iqzªÑuš‡3ÿ):貋tÞÔ5Þ¯0Ê…ºª!&¤; •ƒ)ß¾éçà ­lW(ÂN:eJ5HS kjQû/h/ , \¹B.B-tˆ—NP=ÚpD=Õª´>¹€Õ•s°Žcõ²4I™ic©Ö‚5’.›‡Z¾ÑöŠu!wña€fkÕéCœþrT©~>»Œ…ð”@Yš}%´ßgVMTbËG±’Ù9öŒBìÍÇ(\Y,°6ßÎb|4•†ò¸ñÝU±üÁª<½CÉÒ¸–ÓŒb°e¬Ãð­ø:4p#Ña9 jVWàMŽ³B ±ÅÛº#46á¹—¨oM€ž#èÛŽTüìÉÊú)ªåä=ƒÝ=…^<= AˆüŒÃ©ótJÊÞʪ=ÄÆ­ä•õSBÑÿnR…¯AWM út‘ŽœQ¨Íµzkž±Ó‰åþLVBcl(z>OC{ëT.R­b|û¶O:•uØ—ák¾RRûv]ZÄ\ŽÜéÑs¯­ï‰f(o‘غá© ä9nƒ¾Î_  ô+ðwµ€ ¿É‚¡?¯-ÎÁß9WÍ‚'g}º¼áOì ·õË»2—¼@uÁ_ߨþîöû7{ªYÌÖPk—4XležÇÉnÚÊf‡‡N¯Côu¹Uù¾ös» è÷4îÄvë«>1B@YÕèð§­w`ªUݺʢy“·¸tråIš’Bà…{öô ^˜†ýØQ ܲG--¿¼;¶5Yõ¿Ž+ü*‰@`8j|˜×0·a†P´@ìf -Sé&ÎE=ãm‰ .Y*ä2,ÉÜ„úI¥¿)]بá'làqÄü¥Ÿ¸¡g›ˆ~b”ouœiTâÕ‘¸ð‘Þ²¼Øì°Jý£âkÿ0Y“šÉ@úá®’uéGJ6¤ ˜Ü—&„fò@bR,Ë‹IŠ¹¤XÅE¯0Êh²Š)ª(½c-o·ù³®éã+ûŠÕqPJÚ”Ø&?˜œÆæùö‡{H 6ôêÃ<–èEŽŠYÃ8 ØŒŠÄ 8 H‹V0:ÄàÍëçˆê»o“û76¥ ÒEš°;P†‚¢(æ”äù$Œ^6%A<”Í É#Ù û˜ 8”Zé 2Ù¼OYÍ+èxÂ÷ÊËK›ÔLj„ B0ôäÄG&½­ÚL­ P‹%áv™p»! uæGîqìOÝã”ÃX­eüpMô)‚ðK…Oñ¿¶Õlª^²STÖk‰c½ñ)çÙ¹*iò .£ÊQ 3º–{xJj ­°HÓ”ã¢xò[ÆL|ˆƒ þ°þaXýÎ1SMêë=·04çLá"QŽÜãصÄ5…¯Ê6 #lMG‚#ÌßèyÏéýFCX´ƒ¯ˆR]ú_iŒZÝÑG5Á1ò#Ê©`‚åJž`2=h·×wJAˆƒ¦è¬n¬ï¿á¡S¦Yß2¹-¡™ÄÜõÏ>À.¿Ò§¦,ß&¼`~ÒiÛ#~`fH« êÓ°hÐPÝë»ösŒzw«ø|s±­ÏÝàkhxÇdTêQ}¥MlÖ\yôLÈ~=YiS«½žK[tÙò½–(|áìÏGÅuÓúUBú"±!ô´ÍÀ3iºœ–Ï¡­¼®®1©á”³f[zÍÖ/2ӤЀ5ŒL­ áÙ拧$¶dFôôpŸ.³3Ö=ÄA²:J-È -ßX6;=ˆ¡ -öua3DH®ýÙÒó5-”Ê4Ž·%«¡ ­ct–žšØ3îD £ºšÒsØŪ‹ª†% è?C1Ê0Âb³ëÔ—•´½v«QÒŽ­‰ìÓ )[ '~ך‚v0+e&*ÃæÇžåœÌ¯%ljG]d ªO‘ê¦Ö!—™´ SSQ¡Æª1ví¼T> -× ªAü^ÓkL=žÐ òô°f§?dÎÜ-K™%¸Än¶2YêPð($ëëП&z¥ ´3³¢°ù>æªu~^ð¬ /-K5ª 4ŠpÞ²–‚²šÌæP@#MHRŠšq]kÿHèç¢z=Qe•TèMW¢S]®QKpŠáþdGLVZˆøÈŸÀ¯¶9²ì›ìBrfYÕppoûBåÕO£|2%Iö—YçÔôHN­:1€•(D™’£ŒSÜ'½Q;4"iñJÀ¼ŽvŒ8Ã.^¡W°$·Ûeº4ì-²È$“ƒ´ý1”Òÿ_ÙÙŠÚ‹È„§Ä¶¼Æ3nœÄÖ{ìÌ>ö³‘7JX²Ñ@|¤Aõ°+žTǪ̀‘Ëë’:/”¿Bvg¾ÆÜœïMVVxÍ ³Vå±VyÕì¡Ä šD%h,kÁêj[%pœOCïÔSÐÆ:‡å†V.)$P+2“V'ÑT¢Åz€w·‚7­ wbNC0€(BßóéGÜóõGOßɦôÆvi›Þ¤ë…ȼ¼•%B]`åQçêM¯ÖœÅpßx\eÝP~À¦œÁHâûq!·*S\e W&¼Ô­P#}òpBKº[ZVÆÅÕy5»%0ƒô@X«ÏÖÿÛˆ{=eelixirscript-0.32.1/priv/testrunner/esm/index.js000066400000000000000000000023471325327334200217520ustar00rootroot00000000000000/* eslint strict: off, node/no-unsupported-features: ["error", { version: 4 }] */ "use strict" const fs = require("fs") const path = require("path") const util = require("util") const vm = require("vm") const zlib = require("zlib") const esmPath = path.resolve(__dirname, "esm.js.gz") const inspectKey = util.inspect.custom || "inspect" const descriptor = Object.create(null) descriptor.value = () => "@std/esm enabled" const mod = new module.constructor(module.id) mod.filename = __filename mod.parent = module.parent const scriptOptions = Object.create(null) scriptOptions.filename = __filename const content = "(function(require,module,__filename){" + zlib.gunzipSync(fs.readFileSync(esmPath)).toString() + "\n})" const compiled = vm.runInThisContext(content, scriptOptions) function makeLoaderFunction() { compiled(require, mod, __filename) return mod.exports } const loader = makeLoaderFunction() module.exports = (mod, options) => { const type = typeof options if (options === true || type === "function" || (type === "object" && options !== null)) { return makeLoaderFunction()(mod, options) } return loader(mod, options) } Object.freeze(Object.defineProperty(module.exports, inspectKey, descriptor)) elixirscript-0.32.1/priv/testrunner/esm/package.json000066400000000000000000000007501325327334200225670ustar00rootroot00000000000000{ "name": "@std/esm", "version": "0.8.3", "description": "Enable ES modules in Node today!", "keywords": "commonjs, ecmascript, export, import, modules, node, require", "repository": "standard-things/esm", "license": "MIT", "author": "John-David Dalton ", "main": "index.js", "engines": { "node": ">=4" }, "scripts": { "test": "echo \"Error: no test specified\" && exit 1" }, "files": [ "index.js", "esm.js.gz" ] } elixirscript-0.32.1/priv/testrunner/index.js000066400000000000000000000013321325327334200211570ustar00rootroot00000000000000require = require('./esm/index.js')(module, { cjs: true, esm: 'js' }); const runner = require('./testRunner.js').default; const Colors = require('./colors.js').default; const testFiles = process.argv.slice(2); console.time('Finished in'); runner .start(testFiles) .then((results) => { const testsFailed = results.failed > 0; process.stdout.write('\n\n'); console.timeEnd('Finished in'); console.log( testsFailed ? Colors.fg.Red : Colors.fg.Green, `${results.tests} tests, ${results.success} succeeded, ${results.failed} failed\n`, Colors.Reset, ); if (testsFailed) { process.exit(1); } else { process.exit(0); } }) .catch((e) => { console.log(e); }); elixirscript-0.32.1/priv/testrunner/testRunner.js000066400000000000000000000072511325327334200222270ustar00rootroot00000000000000import Colors from './colors.js'; import Vendor from './vendor.build.js'; async function start(files) { const results = { tests: 0, success: 0, failed: 0, }; for (const file of files) { const mod = await import(file); if (mod.default.__elixirscript_test_module__) { runTests(mod, results); } } return results; } function runSetup(mod, name, incomingContext = new Map()) { if (mod.default[name]) { const result = mod.default[name](incomingContext); return resolveContext(result, incomingContext); } return incomingContext; } function runTeardown(mod, name, incomingContext) { if (mod.default[name]) { const result = mod.default[name](incomingContext); } } function resolveContext(context, parentContext) { if (context === Symbol.for('ok')) { return parentContext; } else if (context instanceof Vendor.ErlangTypes.Tuple && context.get(0) === Symbol.for('ok')) { return resolveContext(context.get(1), parentContext); } else if (context instanceof Map) { return new Map([...parentContext, ...context]); } else if (Array.isArray(context)) { return mergeContextKeywordList(context, parentContext); } throw new Error('Invalid context'); } function mergeContextKeywordList(context, parentContext) { const newContext = new Map([...parentContext]); for (const entry of context) { newContext.set(entry.get(0), entry.get(1)); } return newContext; } function runTests(mod, results) { const contextSetupAll = runSetup(mod, '__elixirscript_test_setup_all'); for (const key of Object.keys(mod.default)) { if (key.startsWith('__elixirscript_test_case')) { results.tests++; const test = mod.default[key](); const result = runTest(mod, test, contextSetupAll, results); if (result) { results.success++; } else { results.failed++; } } } runTeardown(mod, '__elixirscript_test_teardown_all', contextSetupAll); } function runTest(mod, test, incomingContext, results) { const context = runSetup(mod, '__elixirscript_test_setup', incomingContext); let testPassed = true; try { test.get(Symbol.for('test'))(context); process.stdout.write(Colors.fg.Green + '.' + Colors.Reset); } catch (e) { process.stdout.write('\n'); handleError(e, test, results, mod); testPassed = false; } runTeardown(mod, '__elixirscript_test_teardown', context); return testPassed; } function handleError(e, test, results, mod) { if (e.__reason) { if (e.__reason instanceof Map && e.__reason.get(Symbol.for('message'))) { const errorMessage = e.__reason.get(Symbol.for('message')); const expr = e.__reason.get(Symbol.for('expr')); const left = e.__reason.get(Symbol.for('left')); const right = e.__reason.get(Symbol.for('right')); const file = e.__reason.get(Symbol.for('file')); const line = e.__reason.get(Symbol.for('line')); const moduleName = Symbol.keyFor(mod.default.__MODULE__).replace('Elixir.', ''); let testMessage = test.get(Symbol.for('message')); testMessage = `${results.failed}) ${testMessage} (${moduleName})`; printErrorLine(testMessage); console.log(Colors.fg.Red, errorMessage, Colors.Reset); printErrorLine(left, 'left'); printErrorLine(right, 'right'); printErrorLine(file, 'file'); printErrorLine(line, 'line'); } } else { console.log(e); } } function printErrorLine(value, label = null) { if (value && value !== Symbol.for('ex_unit_no_meaningful_value')) { if (label) { console.log(Colors.fg.Cyan, `${label}:`, Colors.Reset, `${value}`); } else { console.log(`${value}`, Colors.Reset); } } } export default { start, }; elixirscript-0.32.1/priv/testrunner/vendor.build.js000066400000000000000000000107731325327334200224540ustar00rootroot00000000000000class Tuple{constructor(...a){this.values=Object.freeze(a),this.length=this.values.length}get(a){return this.values[a]}count(){return this.values.length}[Symbol.iterator](){return this.values[Symbol.iterator]()}toString(){let a,b='';for(a=0;a'}}let ref_counter=-1;class Reference{constructor(){++ref_counter,this.id=ref_counter,this.ref=Symbol()}toString(){return'Ref#<0.0.0.'+this.id+'>'}}class BitString{constructor(...a){this.value=Object.freeze(this.process(a)),this.length=this.value.length,this.bit_size=8*this.length,this.byte_size=this.length}get(a){return this.value[a]}count(){return this.value.length}slice(a,b=null){let c=this.value.slice(a,b),d=c.map((a)=>BitString.integer(a));return new BitString(...d)}[Symbol.iterator](){return this.value[Symbol.iterator]()}toString(){var a,b='';for(a=0;a>'}process(a){let b=[];var c;for(c=0;cb?c.push(b):2048>b?c.push(192|b>>6,128|63&b):55296>b||57344<=b?c.push(224|b>>12,128|63&b>>6,128|63&b):(d++,b=65536+((1023&b)<<10|1023&a.charCodeAt(d)),c.push(240|b>>18,128|63&b>>12,128|63&b>>6,128|63&b));return c}static toUTF16Array(a){for(var b,c=[],d=0;d=b?(c.push(0),c.push(b)):(c.push(255&b>>8),c.push(255&b));return c}static toUTF32Array(a){for(var b,c=[],d=0;d=b?(c.push(0),c.push(0),c.push(0),c.push(b)):(c.push(0),c.push(0),c.push(255&b>>8),c.push(255&b));return c}//http://stackoverflow.com/questions/2003493/javascript-float-from-to-bits static float32ToBytes(a){var b=[],c=new ArrayBuffer(4);new Float32Array(c)[0]=a;let d=new Uint32Array(c)[0];return b.push(255&d>>24),b.push(255&d>>16),b.push(255&d>>8),b.push(255&d),b}static float64ToBytes(a){var b=[],c=new ArrayBuffer(8);new Float64Array(c)[0]=a;var d=new Uint32Array(c)[0],e=new Uint32Array(c)[1];return b.push(255&e>>24),b.push(255&e>>16),b.push(255&e>>8),b.push(255&e),b.push(255&d>>24),b.push(255&d>>16),b.push(255&d>>8),b.push(255&d),b}}var ErlangTypes={Tuple,PID,Reference,BitString},vendor={ErlangTypes};export default vendor; elixirscript-0.32.1/priv/testrunner/vendor.js000066400000000000000000000001141325327334200213420ustar00rootroot00000000000000import ErlangTypes from 'erlang-types'; export default { ErlangTypes, }; elixirscript-0.32.1/rollup.config.js000066400000000000000000000017451325327334200174500ustar00rootroot00000000000000const rollup = require('rollup'); const babel = require('rollup-plugin-babel'); const nodeResolve = require('rollup-plugin-node-resolve'); const commonjs = require('rollup-plugin-commonjs'); const minify = require('rollup-plugin-babel-minify'); const plugins = [ nodeResolve({ jsnext: true, main: true, }), commonjs(), babel({ babelrc: false, }), minify({ keepFnName: true, keepClassName: true, }), ]; rollup .rollup({ input: 'src/javascript/elixir.js', output: 'priv/build/es/ElixirScript.Core.js', sourcemap: 'inline', format: 'es', plugins, }) .then((bundle) => { bundle.write({ format: 'es', file: 'priv/build/es/ElixirScript.Core.js', }); }); rollup .rollup({ input: 'priv/testrunner/vendor.js', output: 'priv/testrunner/vendor.build.js', format: 'es', plugins, }) .then((bundle) => { bundle.write({ format: 'es', file: 'priv/testrunner/vendor.build.js', }); }); elixirscript-0.32.1/src/000077500000000000000000000000001325327334200151115ustar00rootroot00000000000000elixirscript-0.32.1/src/javascript/000077500000000000000000000000001325327334200172575ustar00rootroot00000000000000elixirscript-0.32.1/src/javascript/elixir.js000066400000000000000000000000741325327334200211120ustar00rootroot00000000000000import Core from './lib/core'; export default { Core, }; elixirscript-0.32.1/src/javascript/lib/000077500000000000000000000000001325327334200200255ustar00rootroot00000000000000elixirscript-0.32.1/src/javascript/lib/core.js000066400000000000000000000034241325327334200213160ustar00rootroot00000000000000import 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 filename from './core/erlang_compat/filename'; 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; } function initApp() { const Elixir = {}; Elixir.__table__ = {}; Elixir.start = (app, args) => { app.__load(Elixir).start(Symbol.for('normal'), args); }; Elixir.load = module => module.__load(Elixir); return Elixir; } 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, filename, binary, unicode, elixir_config, math, proplists, initApp, }; elixirscript-0.32.1/src/javascript/lib/core/000077500000000000000000000000001325327334200207555ustar00rootroot00000000000000elixirscript-0.32.1/src/javascript/lib/core/erlang_compat/000077500000000000000000000000001325327334200235705ustar00rootroot00000000000000elixirscript-0.32.1/src/javascript/lib/core/erlang_compat/binary.js000066400000000000000000000026261325327334200254200ustar00rootroot00000000000000import 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.32.1/src/javascript/lib/core/erlang_compat/elixir_config.js000066400000000000000000000012771325327334200267560ustar00rootroot00000000000000const 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.32.1/src/javascript/lib/core/erlang_compat/elixir_errors.js000066400000000000000000000002531325327334200270160ustar00rootroot00000000000000function warn(message) { const messageString = message.join(''); console.warn(`warning: ${messageString}`); return Symbol.for('ok'); } export default { warn, }; elixirscript-0.32.1/src/javascript/lib/core/erlang_compat/erlang.js000066400000000000000000000256021325327334200254030ustar00rootroot00000000000000// 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) { let theError = null; 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')); theError = new Error(`** (${name}) ${message}`); } else if (is_binary(reason)) { theError = new Error(`** (RuntimeError) ${reason}`); } else { theError = new Error(`** (ErlangError) Erlang Error ${reason.toString()}`); } theError.__reason = reason; throw theError; } 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; } function lessThanEqualTo(one, two) { return one <= two; } function add(one, two) { return one + two; } 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, lessThanEqualTo, add, }; elixirscript-0.32.1/src/javascript/lib/core/erlang_compat/filename.js000066400000000000000000000011521325327334200257050ustar00rootroot00000000000000function join(arg, extra = null) { const components = Array.isArray(arg) ? arg : [arg, extra]; let names = []; for (let i = components.length - 1; i >= 0; i--) { const name = components[i]; const normalized_name = name.replace(/\/+/g, '/').replace(/^\/|\/$/g, ''); names.push(normalized_name); if (name[0] === '/') { names.push(''); break; } } return names.reverse().join('/'); } function dirname(arg) { const path = join([arg]); const index = path.lastIndexOf('/'); return index === -1 ? '.' : (path.substr(0, index) || '/'); } export default { join, dirname, }; elixirscript-0.32.1/src/javascript/lib/core/erlang_compat/io.js000066400000000000000000000004731325327334200245410ustar00rootroot00000000000000import 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.32.1/src/javascript/lib/core/erlang_compat/lists.js000066400000000000000000000111041325327334200252610ustar00rootroot00000000000000// 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.32.1/src/javascript/lib/core/erlang_compat/maps.js000066400000000000000000000102521325327334200250660ustar00rootroot00000000000000// 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.32.1/src/javascript/lib/core/erlang_compat/math.js000066400000000000000000000001111325327334200250500ustar00rootroot00000000000000function log2(x) { return Math.log2(x); } export default { log2, }; elixirscript-0.32.1/src/javascript/lib/core/erlang_compat/proplists.js000066400000000000000000000007331325327334200261700ustar00rootroot00000000000000import 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.32.1/src/javascript/lib/core/erlang_compat/unicode.js000066400000000000000000000013221325327334200255520ustar00rootroot00000000000000import 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.32.1/src/javascript/lib/core/functions.js000066400000000000000000000120021325327334200233160ustar00rootroot00000000000000import 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.32.1/src/javascript/lib/core/protocol.js000066400000000000000000000043541325327334200231620ustar00rootroot00000000000000import 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.32.1/src/javascript/lib/core/special_forms.js000066400000000000000000000067471325327334200241570ustar00rootroot00000000000000import 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 { let value = e; if (e.__reason) { value = e.__reason; value.set('__reason', e.__reason); } ex_result = rescue_function(value); return ex_result; } catch (ex) { throw ex; } } if (catch_fun) { try { ex_result = catch_fun(e); return ex_result; } catch (ex) { 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.32.1/src/javascript/lib/core/store.js000066400000000000000000000017141325327334200224520ustar00rootroot00000000000000import 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.32.1/src/javascript/tests/000077500000000000000000000000001325327334200204215ustar00rootroot00000000000000elixirscript-0.32.1/src/javascript/tests/case.spec.js000066400000000000000000000010121325327334200226150ustar00rootroot00000000000000import 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.32.1/src/javascript/tests/cond.spec.js000066400000000000000000000005321325327334200226330ustar00rootroot00000000000000import 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.32.1/src/javascript/tests/core/000077500000000000000000000000001325327334200213515ustar00rootroot00000000000000elixirscript-0.32.1/src/javascript/tests/core/erlang_compat/000077500000000000000000000000001325327334200241645ustar00rootroot00000000000000elixirscript-0.32.1/src/javascript/tests/core/erlang_compat/binary_spec.js000066400000000000000000000030021325327334200270130ustar00rootroot00000000000000import 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.32.1/src/javascript/tests/core/erlang_compat/elixir_errors_spec.js000066400000000000000000000003031325327334200304200ustar00rootroot00000000000000import 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.32.1/src/javascript/tests/core/erlang_compat/erlang_spec.js000066400000000000000000000122551325327334200270110ustar00rootroot00000000000000import 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.32.1/src/javascript/tests/core/erlang_compat/filename_spec.js000066400000000000000000000014121325327334200273120ustar00rootroot00000000000000import test from 'ava'; import Core from '../../../lib/core'; test('dirname/1', (t) => { let result = Core.filename.dirname('/usr/src/kalle.erl'); t.is(result, '/usr/src'); result = Core.filename.dirname('usr/kalle.erl'); t.is(result, 'usr'); result = Core.filename.dirname('kalle.erl'); t.is(result, '.'); result = Core.filename.dirname('/kalle.erl'); t.is(result, '/'); }); test('join/1', (t) => { let result = Core.filename.join(['/usr', 'local', 'bin']); t.is(result, '/usr/local/bin'); result = Core.filename.join(['a', '///b/', 'c/']); t.is(result, '/b/c'); result = Core.filename.join(['a/b///c/']); t.is(result, 'a/b/c'); }); test('join/2', (t) => { const result = Core.filename.join('/usr', 'bin'); t.is(result, '/usr/bin'); }); elixirscript-0.32.1/src/javascript/tests/core/erlang_compat/io_spec.js000066400000000000000000000004561325327334200261500ustar00rootroot00000000000000import 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.32.1/src/javascript/tests/core/erlang_compat/lists_spec.js000066400000000000000000000021221325327334200266670ustar00rootroot00000000000000import 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.32.1/src/javascript/tests/core/erlang_compat/maps_spec.js000066400000000000000000000042461325327334200265020ustar00rootroot00000000000000import 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.32.1/src/javascript/tests/core/erlang_compat/math_spec.js000066400000000000000000000003641325327334200264700ustar00rootroot00000000000000import 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.32.1/src/javascript/tests/core/erlang_compat/proplists_spec.js000066400000000000000000000013741325327334200276000ustar00rootroot00000000000000import 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.32.1/src/javascript/tests/core/erlang_compat/unicode_spec.js000066400000000000000000000020321325327334200271570ustar00rootroot00000000000000import 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.32.1/src/javascript/tests/core/functions.spec.js000066400000000000000000000060071325327334200246530ustar00rootroot00000000000000import 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.32.1/src/javascript/tests/for.spec.js000066400000000000000000000062041325327334200225000ustar00rootroot00000000000000import 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.32.1/src/javascript/tests/try.spec.js000066400000000000000000000011361325327334200225270ustar00rootroot00000000000000import test from 'ava'; import Core from '../lib/core'; const { Patterns, SpecialForms } = Core; 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.32.1/src/javascript/tests/with.spec.js000066400000000000000000000074131325327334200226700ustar00rootroot00000000000000import 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.32.1/test/000077500000000000000000000000001325327334200153015ustar00rootroot00000000000000elixirscript-0.32.1/test/beam_test.exs000066400000000000000000000006201325327334200177630ustar00rootroot00000000000000defmodule 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.32.1/test/cli_test.exs000066400000000000000000000015121325327334200176270ustar00rootroot00000000000000defmodule 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" end end elixirscript-0.32.1/test/compiler_test.exs000066400000000000000000000024541325327334200207000ustar00rootroot00000000000000defmodule ElixirScript.Compiler.Test do use ExUnit.Case test "Can compile one entry module" do result = ElixirScript.Compiler.compile(Version) assert result |> Map.to_list() |> hd |> elem(1) |> Map.get(:js_code) |> is_binary end test "Can compile multiple entry modules" do result = ElixirScript.Compiler.compile([Atom, String, Agent]) assert result |> Map.to_list() |> hd |> elem(1) |> Map.get(:js_code) |> is_binary end test "Output" do result = ElixirScript.Compiler.compile(Atom, []) assert result |> Map.to_list() |> hd |> elem(1) |> Map.get(:js_code) =~ "export default" end test "compile file" do path = System.tmp_dir() path = Path.join([path, "Elixir.ElixirScript.Beam.Test.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), "export default") end test "compile wildcard" do path = System.tmp_dir() file = Path.join([path, "Elixir.ElixirScript.FFI.Test.js"]) input_path = Path.join([File.cwd!(), "test", "*fi_test.exs"]) ElixirScript.Compiler.compile(input_path, output: path) assert File.exists?(file) assert String.contains?(File.read!(file), "export default") end end elixirscript-0.32.1/test/ffi_test.exs000066400000000000000000000006721325327334200176320ustar00rootroot00000000000000defmodule 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.32.1/test/manifest_test.exs000066400000000000000000000005221325327334200206660ustar00rootroot00000000000000defmodule ElixirScript.Manifest.Test do use ExUnit.Case alias ElixirScript.Manifest test "write manifest" do result = ElixirScript.Compiler.compile(Atom) path = Path.join([System.tmp_dir(), "write_manifest_test", ".compile.elixir_script"]) Manifest.write_manifest(path, result) assert File.exists?(path) end end elixirscript-0.32.1/test/passes/000077500000000000000000000000001325327334200165775ustar00rootroot00000000000000elixirscript-0.32.1/test/passes/translate/000077500000000000000000000000001325327334200205745ustar00rootroot00000000000000elixirscript-0.32.1/test/passes/translate/form_test.exs000066400000000000000000000144671325327334200233330ustar00rootroot00000000000000defmodule ElixirScript.Translate.Forms.Test do use ExUnit.Case alias ElixirScript.Translate.Form alias ElixirScript.Translate.Helpers alias ESTree.Tools.Builder, as: J use ExUnitProperties 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 -> x not 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 ElixirScript.State.put_module(state.pid, IO, %{}) {js_ast, _} = Form.compile(ast, state) assert js_ast == %ESTree.Identifier{loc: nil, name: "$IO$", type: "Identifier"} end test "unknown module", %{state: state} do ast = Enum {js_ast, _} = Form.compile(ast, state) assert js_ast == %ESTree.ObjectExpression{ loc: nil, properties: [], type: "ObjectExpression" } 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.32.1/test/passes/translate/forms/000077500000000000000000000000001325327334200217225ustar00rootroot00000000000000elixirscript-0.32.1/test/passes/translate/forms/bitstring_test.exs000066400000000000000000000014041325327334200255060ustar00rootroot00000000000000defmodule 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.32.1/test/passes/translate/forms/js_test.exs000066400000000000000000000055121325327334200241210ustar00rootroot00000000000000defmodule 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.32.1/test/passes/translate/forms/map_test.exs000066400000000000000000000037301325327334200242620ustar00rootroot00000000000000defmodule ElixirScript.Translate.Forms.Map.Test do use ExUnit.Case alias ElixirScript.Translate.Form alias ESTree.Tools.Builder, as: J use ExUnitProperties 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.32.1/test/passes/translate/forms/receive_test.exs000066400000000000000000000014471325327334200251320ustar00rootroot00000000000000defmodule ElixirScript.Translate.Forms.Receive.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, module: __MODULE__ } [state: state] end test "receive translation", %{state: state} do clause = {:->, [line: 644], [[], [{:__block__, [], [1]}]]} ast = {:receive, [line: 644], [[do: [clause], after: nil]]} state = state |> Map.put(:function, {:each, nil}) |> Map.put(: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.32.1/test/passes/translate/forms/remote_test.exs000066400000000000000000000006721325327334200250020ustar00rootroot00000000000000defmodule 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.32.1/test/test_helper.exs000066400000000000000000000001251325327334200203360ustar00rootroot00000000000000exclude = if Node.alive?, do: [], else: [skip: true] ExUnit.start(exclude: exclude) elixirscript-0.32.1/test_elixir_script/000077500000000000000000000000001325327334200202415ustar00rootroot00000000000000elixirscript-0.32.1/test_elixir_script/integration_test.exs000066400000000000000000000024021325327334200243420ustar00rootroot00000000000000defmodule ElixirScript.Integration.Test do use ElixirScript.Test test "Something" do assert {:ok, _} = {:ok, 1} end test "Atom.to_string" do val = Atom.to_string(:atom) assert val == "atom" end test "String interpolation with number" do val = "#{5}" assert val == "5" end test "shorthand failure" do orders = [%{email: "test@hotmail.com"}, %{email: "test2@hotmail.com"}] val = Enum.reduce(orders, [], &(&2 ++ [ [:option, %{value: &1.email}, &1.email] ])) assert val == [ [:option, %{value: "test@hotmail.com"}, "test@hotmail.com"], [:option, %{value: "test2@hotmail.com"}, "test2@hotmail.com"] ] end test "map equals" do map1 = %{test: "map"} map2 = %{test: "map"} assert map1 == map2 end test "multi-remote call" do map = %{token_count: 5_000_000} val = map.token_count.toLocaleString() assert val == "5,000,000" end test "filter names in guards" do has? = 5 val = case 5 do _ when has? == 5 -> true end assert val == true end test "tuple_get" do map = %{{1} => 5} val = Map.get(map, {1}) assert val == 5 end test "multi_bind" do [_a | _] = val = [1, 2, 3, 4, 5] assert val == [1, 2, 3, 4, 5] end end elixirscript-0.32.1/test_elixir_script/try_test.exs000066400000000000000000000013701325327334200226400ustar00rootroot00000000000000defmodule ElixirScript.Try.Test do use ElixirScript.Test test "returns value in try if no error" do value = try do 1 + 1 rescue _ -> 3 end assert value == 2 end test "returns rescue value on error" do value = try do raise ArithmeticError rescue _ -> 3 end assert value == 3 end test "returns rescue value from matching error" do value = try do raise ArithmeticError rescue ArithmeticError -> 3 end assert value == 3 end test "returns rescue value from matching errors" do value = try do raise ArithmeticError rescue _ in [ArithmeticError, ArgumentError] -> 3 end assert value == 3 end end elixirscript-0.32.1/yarn.lock000066400000000000000000004511701325327334200161550ustar00rootroot00000000000000# 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"