├── .circleci
    └── config.yml
├── .gitignore
├── .travis.yml
├── CHANGELOG.md
├── Cargo.toml
├── LICENSE.txt
├── ci
    ├── setup.sh
    └── test.sh
├── readme.md
├── rustfmt.toml
├── src
    ├── de.rs
    ├── errors.rs
    ├── lib.rs
    ├── macros.rs
    └── ser.rs
├── test
    ├── .gitignore
    ├── __tests__
    │   └── get_values.js
    ├── lib
    │   └── index.js
    ├── native
    │   ├── Cargo.toml
    │   ├── build.rs
    │   └── src
    │   │   └── lib.rs
    ├── package.json
    └── yarn.lock
└── test_macro
    ├── .gitignore
    ├── __tests__
        └── macros.js
    ├── lib
        └── index.js
    ├── native
        ├── Cargo.toml
        ├── build.rs
        └── src
        │   └── lib.rs
    ├── package.json
    └── yarn.lock


/.circleci/config.yml:
--------------------------------------------------------------------------------
 1 |  version: 2
 2 |  jobs:
 3 |    build:
 4 |      docker:
 5 |        - image: circleci/rust:1-buster-node
 6 |      steps:
 7 |        - checkout
 8 |        - run:
 9 |            name: 'build'
10 |            command: cargo build
11 |         
12 | 


--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
1 | /target/
2 | **/*.rs.bk
3 | Cargo.lock
4 | *.idea
5 | *.iml
6 | CMake*
7 | 


--------------------------------------------------------------------------------
/.travis.yml:
--------------------------------------------------------------------------------
 1 | language: rust
 2 | 
 3 | cache:
 4 |   yarn: true
 5 |   cargo: true
 6 | 
 7 | rust:
 8 |   - stable
 9 |   - beta
10 |   - nightly
11 | 
12 | env:
13 |   matrix:
14 |     - TRAVIS_NODE_VERSION="8"
15 |     - TRAVIS_NODE_VERSION="10"
16 |     - TRAVIS_NODE_VERSION="12"
17 | 
18 | matrix:
19 |   allow_failures:
20 |     - rust: nightly
21 | 
22 | os:
23 |   - linux
24 |   - osx
25 | 
26 | before_install:
27 |   - export PATH="$PATH:$HOME/.cargo/bin"
28 |   - source $HOME/.nvm/nvm.sh
29 |   - nvm install ${TRAVIS_NODE_VERSION}
30 |   - nvm use ${TRAVIS_NODE_VERSION}
31 |   - ./ci/setup.sh
32 | 
33 | script:
34 |   - ./ci/test.sh
35 | 


--------------------------------------------------------------------------------
/CHANGELOG.md:
--------------------------------------------------------------------------------
 1 | Change Log
 2 | ==========
 3 | 
 4 | ## Version 0.3.0
 5 | 
 6 | ### Features
 7 | * support u128 and i128 (where they can safely convert to f64)
 8 | * 32-bit support
 9 | 
10 | ## Version 0.2.0
11 | 
12 | ### Features
13 | 
14 | * Update to neon 0.3.1
15 | * Support for nodeJS 12.*
16 | 
17 | ### BREAKING
18 | 
19 | * Removed support for nodeJS 6.* (end of life)
20 | 
21 | ## Version 0.1.1
22 | 
23 | ### Features
24 | 
25 | * Document how to use `serde_bytes::ByteBuf` with node `Buffer`s
26 | * Allow docs and other attributes on functions in export macro
27 | * add `#[allow(snake_case)]` added by default in export macro
28 | * Better behaviour for `Option<T>` in export macro
29 | 
30 | ```rust,no-run
31 | ...
32 | export! {
33 |     /// Adding docs and attributes here now works
34 |     fn get_length(name: Option<String>) -> Option<u8> {
35 |         name.map(|n| n.len())
36 |     }
37 | 
38 |     /// Makes a `Buffer` node side
39 |     fn get_big_data() -> serde_bytes::ByteBuf {
40 |         let data: Vec<u8> = ...;
41 |         serde_bytes::ByteBuf::from(data)
42 |     }
43 | }
44 | ```
45 | ```javascript
46 | nativeModule.get_length("1")       // Always worked
47 | nativeModule.get_length(null)      // Always worked
48 | nativeModule.get_length(undefined) // Always worked
49 | nativeModule.get_length()          // Works as of v0.1.1
50 | 
51 | nativeModule.get_big_data()        // returns Buffer
52 | ```
53 | 
54 | 
55 | ## Version 0.1.0
56 | 
57 | ### Breaking
58 | 
59 | * Requires neon 0.2
60 | 
61 | ### Other Changes
62 | 
63 | * Add Testing on node 10
64 | * Add License file MIT
65 | 


--------------------------------------------------------------------------------
/Cargo.toml:
--------------------------------------------------------------------------------
 1 | [package]
 2 | name = "neon-serde"
 3 | version = "0.4.0"
 4 | authors = ["Gabriel Castro <dev@GabrielCastro.ca>"]
 5 | description = "Easily serialize object for use with neon"
 6 | license = "MIT"
 7 | repository = "https://github.com/GabrielCastro/neon-serde"
 8 | readme = "readme.md"
 9 | 
10 | [dependencies]
11 | serde = "1"
12 | error-chain = "0.12"
13 | neon = "0.4"
14 | neon-runtime = "0.4"
15 | 
16 | [dependencies.num]
17 | version = "0.2"
18 | default-features = false
19 | 
20 | [dev-dependencies]
21 | serde_derive = "1"
22 | 
23 | [badges]
24 | travis-ci = { repository = "GabrielCastro/neon-serde" }
25 | 


--------------------------------------------------------------------------------
/LICENSE.txt:
--------------------------------------------------------------------------------
 1 | Copyright (c) 2017-2018 Gabriel Castro
 2 | 
 3 | Permission is hereby granted, free of charge, to any person obtaining a copy
 4 | of this software and associated documentation files (the "Software"), to deal
 5 | in the Software without restriction, including without limitation the rights
 6 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 7 | copies of the Software, and to permit persons to whom the Software is
 8 | furnished to do so, subject to the following conditions:
 9 | 
10 | The above copyright notice and this permission notice shall be included in
11 | all copies or substantial portions of the Software.
12 | 
13 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
14 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
15 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
16 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
17 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
18 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
19 | THE SOFTWARE.
20 | 


--------------------------------------------------------------------------------
/ci/setup.sh:
--------------------------------------------------------------------------------
 1 | #!/usr/bin/env bash
 2 | set -euxo pipefail
 3 | 
 4 | cd "$(dirname "$0")/.."
 5 | 
 6 | if [[ "$(uname)" = "Darwin" ]] ; then
 7 |     brew update
 8 |     brew install yarn
 9 | fi
10 | 
11 | if [[ "${TRAVIS_RUST_VERSION:-}" = "nightly" ]] ; then
12 |     cargo install clippy --force
13 |     cargo install rustfmt-nightly --force
14 | fi
15 | 


--------------------------------------------------------------------------------
/ci/test.sh:
--------------------------------------------------------------------------------
 1 | #!/usr/bin/env bash
 2 | set -euxo pipefail
 3 | 
 4 | cd "$(dirname "$0")/.."
 5 | 
 6 | export RUST_BACKTRACE=1
 7 | 
 8 | if [[ "${TRAVIS_RUST_VERSION:-}" = "nightly" ]] ; then
 9 |     cargo fmt -- --write-mode=diff
10 |     cargo clippy
11 | fi
12 | cargo build --verbose --all
13 | cargo test --verbose --all
14 | 
15 | cd test
16 | 
17 | yarn install
18 | yarn run build:debug
19 | yarn test
20 | 
21 | cd ../test_macro
22 | 
23 | yarn install
24 | yarn run build:debug
25 | yarn test
26 | 


--------------------------------------------------------------------------------
/readme.md:
--------------------------------------------------------------------------------
  1 | Neon-serde
  2 | ==========
  3 | 
  4 | [![Build Status](https://travis-ci.org/GabrielCastro/neon-serde.svg?branch=master)](https://travis-ci.org/GabrielCastro/neon-serde)
  5 | [![](https://meritbadge.herokuapp.com/neon-serde)](https://crates.io/crates/neon-serde)
  6 | 
  7 | This crate is a utility to easily convert values between
  8 | 
  9 | A `Handle<JsValue>` from the [neon](https://github.com/neon-bindings/neon) crate
 10 | and any value implementing `serde::{Serialize, Deserialize}`
 11 | 
 12 | ## Versions support
 13 | 
 14 | neon-serde is tested on node
 15 | `8` `10` `12`
 16 | 
 17 | ## Usage
 18 | 
 19 | #### `neon_serde::from_value`
 20 | Convert a `Handle<js::JsValue>` to
 21 | a type implementing `serde::Deserialize`
 22 | 
 23 | #### `neon_serde::to_value`˚
 24 | Convert a value implementing `serde::Serialize` to
 25 | a `Handle<JsValue>`
 26 | 
 27 | ## Export Macro example
 28 | The export! macro allows you to quickly define functions automatically convert thier arguments
 29 | 
 30 | ```rust,no_run
 31 | 
 32 | #[macro_use]
 33 | extern crate neon;
 34 | #[macro_use]
 35 | extern crate neon_serde;
 36 | #[macro_use]
 37 | extern crate serde_derive;
 38 | extern crate serde_bytes;
 39 | 
 40 | #[derive(Deserialize)]
 41 | struct User {
 42 |     name: String,
 43 |     age: u16,
 44 | }
 45 | 
 46 | export! {
 47 | 
 48 |     /// Say hello based on a persons name
 49 |     fn say_hello(name: String) -> String {
 50 |         format!("Hello, {}!", name)
 51 |     }
 52 | 
 53 |     /// Say how old someone is
 54 |     fn greet(user: User) -> String {
 55 |         format!("{} is {} years old", user.name, user.age)
 56 |     }
 57 | 
 58 |     /// Say how old someone is, if they exist
 59 |     fn maybe_say_hello(user: Option<User>) -> Option<String> {
 60 |         user.map(greet)
 61 |     }
 62 | 
 63 |     /// Sorts the bytes in a string
 64 |     /// use `serde_bytes::ByteBuf` to return a `Buffer` in node
 65 |     /// a `Vec<u8>` will be an array
 66 |     fn sort_utf8_bytes(str: String) -> serde_bytes::ByteBuf {
 67 |         let mut bytes = str.into_bytes();
 68 |         bytes.sort();
 69 |         serde_bytes::ByteBuf::from(bytes)
 70 |     }
 71 | 
 72 |     /// using `serde_bytes::ByteBuf` will make passing an array
 73 |     /// of numbers an error
 74 |     ///
 75 |     /// note: `-> ()` is NOT optional
 76 |     fn expect_buffer_only(_buff: serde_bytes::ByteBuf) -> () {
 77 |         // code
 78 |     }
 79 | 
 80 |     /// using `Vec<u8>` not accept a buffer
 81 |     fn expect_array(_buff: Vec<u8>) -> () {
 82 |         // code
 83 |     }
 84 | 
 85 |     /// calculate fibonacci recursively
 86 |     fn fibonacci(n: i32) -> i32 {
 87 |         match n {
 88 |             1 | 2 => 1,
 89 |             n => fibonacci(n - 1) + fibonacci(n - 2)
 90 |         }
 91 |     }
 92 | }
 93 | 
 94 | ```
 95 | 
 96 | 
 97 | ## Direct Usage Example
 98 | 
 99 | ```rust,no_run
100 | extern crate neon_serde;
101 | extern crate neon;
102 | #[macro_use]
103 | extern crate serde_derive;
104 | 
105 | use neon::prelude::*;
106 | 
107 | #[derive(Serialize, Debug, Deserialize)]
108 | struct AnObject {
109 |     a: u32,
110 |     b: Vec<f64>,
111 |     c: String,
112 | }
113 | 
114 | fn deserialize_something(mut cx: FunctionContext) -> JsResult<JsValue> {
115 |     let arg0 = cx.argument::<JsValue>(0)?;
116 | 
117 |     let arg0_value :AnObject = neon_serde::from_value(&mut cx, arg0)?;
118 |     println!("{:?}", arg0_value);
119 | 
120 |     Ok(JsUndefined::new().upcast())
121 | }
122 | 
123 | fn serialize_something(mut cx: FunctionContext) -> JsResult<JsValue> {
124 |     let value = AnObject {
125 |         a: 1,
126 |         b: vec![2f64, 3f64, 4f64],
127 |         c: "a string".into()
128 |     };
129 | 
130 |     let js_value = neon_serde::to_value(&mut cx, &value)?;
131 |     Ok(js_value)
132 | }
133 | ```
134 | 
135 | ## Limitations
136 | 
137 | ### Data ownership
138 | All Deserialize Values must own all their data (they must have the trait `serde::DererializeOwned`)
139 | 


--------------------------------------------------------------------------------
/rustfmt.toml:
--------------------------------------------------------------------------------
1 | reorder_extern_crates = true
2 | reorder_imports = true
3 | reorder_imports_in_group = true
4 | reorder_imported_names = true
5 | 


--------------------------------------------------------------------------------
/src/de.rs:
--------------------------------------------------------------------------------
  1 | //!
  2 | //! Deserialize a `JsValue` into a Rust data structure
  3 | //!
  4 | 
  5 | use errors::Error as LibError;
  6 | use errors::ErrorKind;
  7 | use errors::Result as LibResult;
  8 | use neon::prelude::*;
  9 | use serde;
 10 | use serde::de::Visitor;
 11 | use serde::de::{DeserializeOwned, DeserializeSeed, EnumAccess, MapAccess, SeqAccess, Unexpected,
 12 |                 VariantAccess};
 13 | 
 14 | /// Deserialize an instance of type `T` from a `Handle<JsValue>`
 15 | ///
 16 | /// # Errors
 17 | ///
 18 | /// Can fail for various reasons see `ErrorKind`
 19 | ///
 20 | pub fn from_value<'j, C, T>(cx: &mut C, value: Handle<'j, JsValue>) -> LibResult<T>
 21 | where
 22 |     C: Context<'j>,
 23 |     T: DeserializeOwned + ?Sized,
 24 | {
 25 |     let mut deserializer: Deserializer<C> = Deserializer::new(cx, value);
 26 |     let t = T::deserialize(&mut deserializer)?;
 27 |     Ok(t)
 28 | }
 29 | 
 30 | pub fn from_value_opt<'j, C, T>(cx: &mut C, value: Option<Handle<'j, JsValue>>) -> LibResult<T>
 31 | where
 32 |     C: Context<'j>,
 33 |     T: DeserializeOwned + ?Sized,
 34 | {
 35 |     let unwrapped = value.unwrap_or_else(|| JsUndefined::new().upcast());
 36 |     from_value(cx, unwrapped)
 37 | }
 38 | 
 39 | #[doc(hidden)]
 40 | pub struct Deserializer<'a, 'j, C: Context<'j> + 'a> {
 41 |     cx: &'a mut C,
 42 |     input: Handle<'j, JsValue>,
 43 | }
 44 | 
 45 | #[doc(hidden)]
 46 | impl<'a, 'j, C: Context<'j>> Deserializer<'a, 'j, C> {
 47 |     fn new(cx: &'a mut C, input: Handle<'j, JsValue>) -> Self {
 48 |         Deserializer { cx, input }
 49 |     }
 50 | }
 51 | 
 52 | #[doc(hidden)]
 53 | impl<'x, 'd, 'a, 'j, C: Context<'j>> serde::de::Deserializer<'x> for &'d mut Deserializer<'a, 'j, C> {
 54 |     type Error = LibError;
 55 | 
 56 |     fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error>
 57 |     where
 58 |         V: Visitor<'x>,
 59 |     {
 60 |         if self.input.downcast::<JsNull>().is_ok() || self.input.downcast::<JsUndefined>().is_ok() {
 61 |             visitor.visit_unit()
 62 |         } else if let Ok(val) = self.input.downcast::<JsBoolean>() {
 63 |             visitor.visit_bool(val.value())
 64 |         } else if let Ok(val) = self.input.downcast::<JsString>() {
 65 |             visitor.visit_string(val.value())
 66 |         } else if let Ok(val) = self.input.downcast::<JsNumber>() {
 67 |             let v = val.value();
 68 |             if v.trunc() == v {
 69 |                 visitor.visit_i64(v as i64)
 70 |             } else {
 71 |                 visitor.visit_f64(v)
 72 |             }
 73 |         } else if let Ok(_val) = self.input.downcast::<JsBuffer>() {
 74 |             self.deserialize_bytes(visitor)
 75 |         } else if let Ok(val) = self.input.downcast::<JsArray>() {
 76 |             let mut deserializer = JsArrayAccess::new(self.cx, val);
 77 |             visitor.visit_seq(&mut deserializer)
 78 |         } else if let Ok(val) = self.input.downcast::<JsObject>() {
 79 |             let mut deserializer = JsObjectAccess::new(self.cx, val)?;
 80 |             visitor.visit_map(&mut deserializer)
 81 |         } else {
 82 |             bail!(ErrorKind::NotImplemented(
 83 |                 "unimplemented Deserializer::Deserializer",
 84 |             ));
 85 |         }
 86 |     }
 87 | 
 88 |     fn deserialize_option<V>(self, visitor: V) -> Result<V::Value, Self::Error>
 89 |     where
 90 |         V: Visitor<'x>,
 91 |     {
 92 |         if self.input.downcast::<JsNull>().is_ok() || self.input.downcast::<JsUndefined>().is_ok() {
 93 |             visitor.visit_none()
 94 |         } else {
 95 |             visitor.visit_some(self)
 96 |         }
 97 |     }
 98 | 
 99 |     fn deserialize_enum<V>(
100 |         self,
101 |         _name: &'static str,
102 |         _variants: &'static [&'static str],
103 |         visitor: V,
104 |     ) -> Result<V::Value, Self::Error>
105 |     where
106 |         V: Visitor<'x>,
107 |     {
108 |         if let Ok(val) = self.input.downcast::<JsString>() {
109 |             visitor.visit_enum(JsEnumAccess::new(self.cx, val.value(), None))
110 |         } else if let Ok(val) = self.input.downcast::<JsObject>() {
111 |             let prop_names = val.get_own_property_names(self.cx)?;
112 |             let len = prop_names.len();
113 |             if len != 1 {
114 |                 Err(ErrorKind::InvalidKeyType(format!(
115 |                     "object key with {} properties",
116 |                     len
117 |                 )))?
118 |             }
119 |             let key = prop_names.get(self.cx, 0)?.downcast::<JsString>().or_throw(self.cx)?;
120 |             let enum_value = val.get(self.cx, key)?;
121 |             visitor.visit_enum(JsEnumAccess::new(self.cx, key.value(), Some(enum_value)))
122 |         } else {
123 |             let m = self.input.to_string(self.cx)?.value();
124 |             Err(ErrorKind::InvalidKeyType(m))?
125 |         }
126 |     }
127 | 
128 |     fn deserialize_bytes<V>(self, visitor: V) -> Result<V::Value, Self::Error>
129 |     where
130 |         V: Visitor<'x>,
131 |     {
132 |         let buff = self.input.downcast::<JsBuffer>().or_throw(self.cx)?;
133 |         let copy = self.cx.borrow(&buff, |buff| Vec::from(buff.as_slice()));
134 |         visitor.visit_bytes(&copy)
135 |     }
136 | 
137 |     fn deserialize_byte_buf<V>(self, visitor: V) -> Result<V::Value, Self::Error>
138 |     where
139 |         V: Visitor<'x>,
140 |     {
141 |         let buff = self.input.downcast::<JsBuffer>().or_throw(self.cx)?;
142 |         let copy = self.cx.borrow(&buff, |buff| Vec::from(buff.as_slice()));
143 |         visitor.visit_byte_buf(copy)
144 |     }
145 | 
146 |     fn deserialize_ignored_any<V>(self, visitor: V) -> Result<V::Value, Self::Error>
147 |     where
148 |         V: Visitor<'x>,
149 |     {
150 |         visitor.visit_unit()
151 |     }
152 | 
153 |     forward_to_deserialize_any! {
154 |        <V: Visitor<'x>>
155 |         bool i8 i16 i32 i64 i128 u8 u16 u32 u64 u128 f32 f64 char str string
156 |         unit unit_struct seq tuple tuple_struct map struct identifier
157 |         newtype_struct
158 |     }
159 | }
160 | 
161 | #[doc(hidden)]
162 | struct JsArrayAccess<'a, 'j, C: Context<'j> + 'a> {
163 |     cx: &'a mut C,
164 |     input: Handle<'j, JsArray>,
165 |     idx: u32,
166 |     len: u32,
167 | }
168 | 
169 | #[doc(hidden)]
170 | impl<'a, 'j, C: Context<'j>> JsArrayAccess<'a, 'j, C> {
171 |     fn new(cx: &'a mut C, input: Handle<'j, JsArray>) -> Self {
172 |         JsArrayAccess {
173 |             cx,
174 |             input,
175 |             idx: 0,
176 |             len: input.len(),
177 |         }
178 |     }
179 | }
180 | 
181 | #[doc(hidden)]
182 | impl<'x, 'a, 'j, C: Context<'j>> SeqAccess<'x> for JsArrayAccess<'a, 'j, C> {
183 |     type Error = LibError;
184 | 
185 |     fn next_element_seed<T>(&mut self, seed: T) -> LibResult<Option<T::Value>>
186 |     where
187 |         T: DeserializeSeed<'x>,
188 |     {
189 |         if self.idx >= self.len {
190 |             return Ok(None);
191 |         }
192 |         let v = self.input.get(self.cx, self.idx)?;
193 |         self.idx += 1;
194 | 
195 |         let mut de = Deserializer::new(self.cx, v);
196 |         seed.deserialize(&mut de).map(Some)
197 |     }
198 | }
199 | 
200 | #[doc(hidden)]
201 | struct JsObjectAccess<'a, 'j, C: Context<'j> + 'a> {
202 |     cx: &'a mut C,
203 |     input: Handle<'j, JsObject>,
204 |     prop_names: Handle<'j, JsArray>,
205 |     idx: u32,
206 |     len: u32,
207 | }
208 | 
209 | #[doc(hidden)]
210 | impl<'x, 'a, 'j, C: Context<'j>> JsObjectAccess<'a, 'j, C> {
211 |     fn new(cx: &'a mut C, input: Handle<'j, JsObject>) -> LibResult<Self> {
212 |         let prop_names = input.get_own_property_names(cx)?;
213 |         let len = prop_names.len();
214 | 
215 |         Ok(JsObjectAccess {
216 |             cx,
217 |             input,
218 |             prop_names,
219 |             idx: 0,
220 |             len,
221 |         })
222 |     }
223 | }
224 | 
225 | #[doc(hidden)]
226 | impl<'x, 'a, 'j, C: Context<'j>> MapAccess<'x> for JsObjectAccess<'a, 'j, C> {
227 |     type Error = LibError;
228 | 
229 |     fn next_key_seed<K>(&mut self, seed: K) -> Result<Option<K::Value>, Self::Error>
230 |     where
231 |         K: DeserializeSeed<'x>,
232 |     {
233 |         if self.idx >= self.len {
234 |             return Ok(None);
235 |         }
236 | 
237 |         let prop_name = self.prop_names.get(self.cx, self.idx)?;
238 | 
239 |         let mut de = Deserializer::new(self.cx, prop_name);
240 |         seed.deserialize(&mut de).map(Some)
241 |     }
242 | 
243 |     fn next_value_seed<V>(&mut self, seed: V) -> Result<V::Value, Self::Error>
244 |     where
245 |         V: DeserializeSeed<'x>,
246 |     {
247 |         if self.idx >= self.len {
248 |             return Err(ErrorKind::ArrayIndexOutOfBounds(self.len, self.idx))?;
249 |         }
250 |         let prop_name = self.prop_names.get(self.cx, self.idx)?;
251 |         let value = self.input.get(self.cx, prop_name)?;
252 | 
253 |         self.idx += 1;
254 |         let mut de = Deserializer::new(self.cx, value);
255 |         let res = seed.deserialize(&mut de)?;
256 |         Ok(res)
257 |     }
258 | }
259 | 
260 | #[doc(hidden)]
261 | struct JsEnumAccess<'a, 'j, C: Context<'j> + 'a> {
262 |     cx: &'a mut C,
263 |     variant: String,
264 |     value: Option<Handle<'j, JsValue>>,
265 | }
266 | 
267 | #[doc(hidden)]
268 | impl<'a, 'j, C: Context<'j>> JsEnumAccess<'a, 'j, C> {
269 |     fn new(cx: &'a mut C, key: String, value: Option<Handle<'j, JsValue>>) -> Self {
270 |         JsEnumAccess {
271 |             cx,
272 |             variant: key,
273 |             value,
274 |         }
275 |     }
276 | }
277 | 
278 | #[doc(hidden)]
279 | impl<'x, 'a, 'j, C: Context<'j>> EnumAccess<'x> for JsEnumAccess<'a, 'j, C> {
280 |     type Error = LibError;
281 |     type Variant = JsVariantAccess<'a, 'j, C>;
282 | 
283 |     fn variant_seed<V>(self, seed: V) -> Result<(V::Value, Self::Variant), Self::Error>
284 |     where
285 |         V: DeserializeSeed<'x>,
286 |     {
287 |         use serde::de::IntoDeserializer;
288 |         let variant = self.variant.into_deserializer();
289 |         let variant_access = JsVariantAccess::new(self.cx, self.value);
290 |         seed.deserialize(variant).map(|v| (v, variant_access))
291 |     }
292 | }
293 | 
294 | #[doc(hidden)]
295 | struct JsVariantAccess<'a, 'j, C: Context<'j> + 'a> {
296 |     cx: &'a mut C,
297 |     value: Option<Handle<'j, JsValue>>,
298 | }
299 | 
300 | #[doc(hidden)]
301 | impl<'a, 'j, C: Context<'j>> JsVariantAccess<'a, 'j, C> {
302 |     fn new(cx: &'a mut C, value: Option<Handle<'j, JsValue>>) -> Self {
303 |         JsVariantAccess { cx, value }
304 |     }
305 | }
306 | 
307 | #[doc(hidden)]
308 | impl<'x, 'a, 'j, C: Context<'j>> VariantAccess<'x> for JsVariantAccess<'a, 'j, C> {
309 |     type Error = LibError;
310 | 
311 |     fn unit_variant(self) -> Result<(), Self::Error> {
312 |         match self.value {
313 |             Some(val) => {
314 |                 let mut deserializer = Deserializer::new(self.cx, val);
315 |                 serde::de::Deserialize::deserialize(&mut deserializer)
316 |             }
317 |             None => Ok(()),
318 |         }
319 |     }
320 | 
321 |     fn newtype_variant_seed<T>(self, seed: T) -> Result<T::Value, Self::Error>
322 |     where
323 |         T: DeserializeSeed<'x>,
324 |     {
325 |         match self.value {
326 |             Some(val) => {
327 |                 let mut deserializer = Deserializer::new(self.cx, val);
328 |                 seed.deserialize(&mut deserializer)
329 |             }
330 |             None => Err(serde::de::Error::invalid_type(
331 |                 Unexpected::UnitVariant,
332 |                 &"newtype variant",
333 |             )),
334 |         }
335 |     }
336 | 
337 |     fn tuple_variant<V>(self, _len: usize, visitor: V) -> Result<V::Value, Self::Error>
338 |     where
339 |         V: Visitor<'x>,
340 |     {
341 |         match self.value {
342 |             Some(handle) => {
343 |                 if let Ok(val) = handle.downcast::<JsArray>() {
344 |                     let mut deserializer = JsArrayAccess::new(self.cx, val);
345 |                     visitor.visit_seq(&mut deserializer)
346 |                 } else {
347 |                     Err(serde::de::Error::invalid_type(
348 |                         Unexpected::Other("JsValue"),
349 |                         &"tuple variant",
350 |                     ))
351 |                 }
352 |             },
353 |             None => Err(serde::de::Error::invalid_type(
354 |                 Unexpected::UnitVariant,
355 |                 &"tuple variant",
356 |             )),
357 |         }
358 |     }
359 | 
360 |     fn struct_variant<V>(
361 |         self,
362 |         _fields: &'static [&'static str],
363 |         visitor: V,
364 |     ) -> Result<V::Value, Self::Error>
365 |     where
366 |         V: Visitor<'x>,
367 |     {
368 |         match self.value {
369 |             Some(handle) => {
370 |                 if let Ok(val) = handle.downcast::<JsObject>() {
371 |                     let mut deserializer = JsObjectAccess::new(self.cx, val)?;
372 |                     visitor.visit_map(&mut deserializer)
373 |                 } else {
374 |                     Err(serde::de::Error::invalid_type(
375 |                         Unexpected::Other("JsValue"),
376 |                         &"struct variant",
377 |                     ))
378 |                 }
379 |             },
380 |             _ => Err(serde::de::Error::invalid_type(
381 |                 Unexpected::UnitVariant,
382 |                 &"struct variant",
383 |             )),
384 |         }
385 |     }
386 | }
387 | 


--------------------------------------------------------------------------------
/src/errors.rs:
--------------------------------------------------------------------------------
  1 | //! Defines error handling types used by the create
  2 | //! uses the `error-chain` create for generation
  3 | 
  4 | extern crate neon_runtime;
  5 | 
  6 | use neon;
  7 | use serde::{de, ser};
  8 | use std::convert::From;
  9 | use std::fmt::Display;
 10 | 
 11 | error_chain! {
 12 |     errors {
 13 |         /// nodejs has a hard coded limit on string length
 14 |         /// trying to serialize a string that is too long will result in an error
 15 |         StringTooLong(len: usize) {
 16 |             description("String too long for nodejs")
 17 |             display("String too long for nodejs len: {}", len)
 18 |         }
 19 |         /// when deserializing to a boolean `false` `undefined` `null` `number`
 20 |         /// are valid inputs
 21 |         /// any other types will result in error
 22 |         UnableToCoerce(to_type: &'static str) {
 23 |             description("Unable to coerce")
 24 |             display("Unable to coerce value to type: {}", to_type)
 25 |         }
 26 |         /// occurs when deserializing a char from an empty string
 27 |         EmptyString {
 28 |             description("EmptyString")
 29 |             display("EmptyString")
 30 |         }
 31 |         /// occurs when deserializing a char from a sting with
 32 |         /// more than one character
 33 |         StringTooLongForChar(len: usize) {
 34 |             description("String too long to be a char")
 35 |             display("String too long to be a char expected len: 1 got len: {}", len)
 36 |         }
 37 |         /// occurs when a deserializer expects a `null` or `undefined`
 38 |         /// property and found another type
 39 |         ExpectingNull {
 40 |             description("ExpectingNull")
 41 |             display("ExpectingNull")
 42 |         }
 43 |         /// occurs when deserializing to an enum and the source object has
 44 |         /// a none-1 number of properties
 45 |         InvalidKeyType(key: String) {
 46 |             description("InvalidKeyType")
 47 |             display("key: '{}'", key)
 48 |         }
 49 |         /// an internal deserialization error from an invalid array
 50 |         ArrayIndexOutOfBounds(index: u32, length: u32) {
 51 |             description("ArrayIndexOutOfBounds")
 52 |             display(
 53 |                 "ArrayIndexOutOfBounds: attempt to access ({}) size: ({})",
 54 |                 index,
 55 |                 length
 56 |             )
 57 |         } #[doc(hidden)]
 58 |         /// This type of object is not supported
 59 |         NotImplemented(name: &'static str) {
 60 |             description("Not Implemented")
 61 |             display("Not Implemented: '{}'", name)
 62 |         }
 63 |         /// A JS exception was thrown
 64 |         Js(throw: neon::result::Throw) {
 65 |             description("JS exception")
 66 |             display("JS exception")
 67 |         }
 68 |         // failed to convert something to f64
 69 |         CastError {
 70 |             description("CastError")
 71 |             display("CastError")
 72 |         }
 73 |     }
 74 | }
 75 | 
 76 | impl ser::Error for Error {
 77 |     fn custom<T: Display>(msg: T) -> Self {
 78 |         ErrorKind::Msg(msg.to_string()).into()
 79 |     }
 80 | }
 81 | 
 82 | impl de::Error for Error {
 83 |     fn custom<T: Display>(msg: T) -> Self {
 84 |         ErrorKind::Msg(msg.to_string()).into()
 85 |     }
 86 | }
 87 | 
 88 | #[allow(use_debug)]
 89 | impl From<Error> for neon::result::Throw {
 90 |     fn from(err: Error) -> Self {
 91 |         if let ErrorKind::Js(_) = *err.kind() {
 92 |             return neon::result::Throw;
 93 |         };
 94 |         let msg = format!("{:?}", err);
 95 |         unsafe {
 96 |             neon_runtime::error::throw_error_from_utf8(msg.as_ptr(), msg.len() as i32);
 97 |             neon::result::Throw
 98 |         }
 99 |     }
100 | }
101 | 
102 | impl From<neon::result::Throw> for Error {
103 |     fn from(throw: neon::result::Throw) -> Self {
104 |         ErrorKind::Js(throw).into()
105 |     }
106 | }
107 | 


--------------------------------------------------------------------------------
/src/lib.rs:
--------------------------------------------------------------------------------
  1 | #![allow(unknown_lints)]
  2 | #![deny(unused_variables)]
  3 | #![deny(unused_mut)]
  4 | #![deny(clippy)]
  5 | #![deny(clippy_pedantic)]
  6 | #![allow(stutter)]
  7 | #![recursion_limit = "128"]
  8 | 
  9 | //!
 10 | //! Neon-serde
 11 | //! ==========
 12 | //!
 13 | //! This crate is a utility to easily convert values between
 14 | //!
 15 | //! A `Handle<JsValue>` from the `neon` crate
 16 | //! and any value implementing `serde::{Serialize, Deserialize}`
 17 | //!
 18 | //! ## Usage
 19 | //!
 20 | //! #### `neon_serde::from_value`
 21 | //! Convert a `Handle<js::JsValue>` to
 22 | //! a type implementing `serde::Deserialize`
 23 | //!
 24 | //! #### `neon_serde::to_value`
 25 | //! Convert a value implementing `serde::Serialize` to
 26 | //! a `Handle<JsValue>`
 27 | //!
 28 | //!
 29 | //! ## Example
 30 | //!
 31 | //! ```rust,no_run
 32 | //! # #![allow(dead_code)]
 33 | //! extern crate neon_serde;
 34 | //! extern crate neon;
 35 | //! #[macro_use]
 36 | //! extern crate serde_derive;
 37 | //!
 38 | //! use neon::prelude::*;
 39 | //!
 40 | //! #[derive(Serialize, Debug, Deserialize)]
 41 | //! struct AnObject {
 42 | //!     a: u32,
 43 | //!     b: Vec<f64>,
 44 | //!     c: String,
 45 | //! }
 46 | //!
 47 | //! fn deserialize_something(mut cx: FunctionContext) -> JsResult<JsValue> {
 48 | //!     let arg0 = cx.argument::<JsValue>(0)?;
 49 | //!
 50 | //!     let arg0_value :AnObject = neon_serde::from_value(&mut cx, arg0)?;
 51 | //!     println!("{:?}", arg0_value);
 52 | //!
 53 | //!     Ok(JsUndefined::new().upcast())
 54 | //! }
 55 | //!
 56 | //! fn serialize_something(mut cx: FunctionContext) -> JsResult<JsValue> {
 57 | //!     let value = AnObject {
 58 | //!         a: 1,
 59 | //!         b: vec![2f64, 3f64, 4f64],
 60 | //!         c: "a string".into()
 61 | //!     };
 62 | //!
 63 | //!     let js_value = neon_serde::to_value(&mut cx, &value)?;
 64 | //!     Ok(js_value)
 65 | //! }
 66 | //!
 67 | //! # fn main () {
 68 | //! # }
 69 | //!
 70 | //! ```
 71 | //!
 72 | 
 73 | #[macro_use]
 74 | extern crate error_chain;
 75 | extern crate neon;
 76 | extern crate num;
 77 | #[macro_use]
 78 | extern crate serde;
 79 | 
 80 | pub mod ser;
 81 | pub mod de;
 82 | pub mod errors;
 83 | 
 84 | mod macros;
 85 | 
 86 | pub use de::from_value;
 87 | pub use de::from_value_opt;
 88 | pub use ser::to_value;
 89 | 
 90 | #[cfg(test)]
 91 | mod tests {
 92 |     use super::*;
 93 |     use neon::prelude::*;
 94 | 
 95 |     #[test]
 96 |     fn test_it_compiles() {
 97 |         fn check<'j>(mut cx: FunctionContext<'j>) -> JsResult<'j, JsValue> {
 98 |             let result: () = {
 99 |                 let arg: Handle<'j, JsValue> = cx.argument::<JsValue>(0)?;
100 |                 let () = from_value(&mut cx, arg)?;
101 |                 ()
102 |             };
103 |             let result: Handle<'j, JsValue> = to_value(&mut cx, &result)?;
104 |             Ok(result)
105 |         }
106 | 
107 |         let _ = check;
108 |     }
109 | 
110 |     #[test]
111 |     fn test_it_compiles_2() {
112 |         fn check<'j>(mut cx: FunctionContext<'j>) -> JsResult<'j, JsValue> {
113 |             let result: () = {
114 |                 let arg: Option<Handle<'j, JsValue>> = cx.argument_opt(0);
115 |                 let () = from_value_opt(&mut cx, arg)?;
116 |                 ()
117 |             };
118 |             let result: Handle<'j, JsValue> = to_value(&mut cx, &result)?;
119 |             Ok(result)
120 |         }
121 | 
122 |         let _ = check;
123 |     }
124 | 
125 | }
126 | 


--------------------------------------------------------------------------------
/src/macros.rs:
--------------------------------------------------------------------------------
 1 | //!
 2 | //! Defines macros for easily exporting functions
 3 | //!
 4 | 
 5 | #[macro_export]
 6 | macro_rules! export {
 7 | 
 8 |     ($(
 9 |         $(#[$func_meta:meta])*
10 |         fn $name:ident($( $arg:ident : $atype:ty ),*) -> $ret:ty $code:block
11 |     )*) => (
12 |         $(
13 |             #[allow(non_snake_case)]
14 |             $(#[$func_meta])*
15 |             fn $name($( $arg: $atype ),*) -> $ret $code
16 |         )*
17 | 
18 |         register_module!(mut m, {
19 |             $(
20 |                 m.export_function(stringify!($name), |mut cx| {
21 |                     // Can be done away with a fancier macro
22 |                     let mut _arg_index = 0;
23 | 
24 |                     $(
25 |                         let $arg = cx.argument_opt(_arg_index);
26 |                         let $arg: $atype = $crate::from_value_opt(&mut cx, $arg)?;
27 |                         _arg_index += 1;
28 |                     )*
29 | 
30 |                     let result = $name($( $arg ),*);
31 |                     let handle = $crate::to_value(&mut cx, &result)?;
32 |                     Ok(handle)
33 |                 })?;
34 |             )*
35 |             Ok(())
36 |         });
37 |     )
38 | }
39 | 


--------------------------------------------------------------------------------
/src/ser.rs:
--------------------------------------------------------------------------------
  1 | //!
  2 | //! Serialize a Rust data structure into a `JsValue`
  3 | //!
  4 | 
  5 | use errors::Error;
  6 | use errors::ErrorKind;
  7 | use errors::Result as LibResult;
  8 | use neon::prelude::*;
  9 | use serde::ser::{self, Serialize};
 10 | use std::marker::PhantomData;
 11 | use num;
 12 | 
 13 | fn as_num<T: num::cast::NumCast, OutT: num::cast::NumCast>(n: T) -> LibResult<OutT> {
 14 |     match num::cast::<T, OutT>(n) {
 15 |         Some(n2) => Ok(n2),
 16 |         None => bail!(ErrorKind::CastError)
 17 |     }
 18 | }
 19 | 
 20 | /// Converts a value of type `V` to a `JsValue`
 21 | ///
 22 | /// # Errors
 23 | ///
 24 | /// * `NumberCastError` trying to serialize a `u64` can fail if it overflows in a cast to `f64`
 25 | /// * `StringTooLong` if the string exceeds v8's max string size
 26 | ///
 27 | #[inline]
 28 | pub fn to_value<'j, C, V>(cx: &mut C, value: &V) -> LibResult<Handle<'j, JsValue>>
 29 | where
 30 |     C: Context<'j>,
 31 |     V: Serialize + ?Sized,
 32 | {
 33 |     let serializer = Serializer {
 34 |         cx,
 35 |         ph: PhantomData,
 36 |     };
 37 |     let serialized_value = value.serialize(serializer)?;
 38 |     Ok(serialized_value)
 39 | }
 40 | 
 41 | #[doc(hidden)]
 42 | pub struct Serializer<'a, 'j, C: 'a>
 43 | where
 44 |     C: Context<'j>,
 45 | {
 46 |     cx: &'a mut C,
 47 |     ph: PhantomData<&'j ()>,
 48 | }
 49 | 
 50 | #[doc(hidden)]
 51 | pub struct ArraySerializer<'a, 'j, C: 'a>
 52 | where
 53 |     C: Context<'j>,
 54 | {
 55 |     cx: &'a mut C,
 56 |     array: Handle<'j, JsArray>,
 57 | }
 58 | 
 59 | #[doc(hidden)]
 60 | pub struct TupleVariantSerializer<'a, 'j, C: 'a>
 61 | where
 62 |     C: Context<'j>,
 63 | {
 64 |     outter_object: Handle<'j, JsObject>,
 65 |     inner: ArraySerializer<'a, 'j, C>,
 66 | }
 67 | 
 68 | #[doc(hidden)]
 69 | pub struct MapSerializer<'a, 'j, C: 'a>
 70 | where
 71 |     C: Context<'j>,
 72 | {
 73 |     cx: &'a mut C,
 74 |     object: Handle<'j, JsObject>,
 75 |     key_holder: Handle<'j, JsObject>,
 76 | }
 77 | 
 78 | #[doc(hidden)]
 79 | pub struct StructSerializer<'a, 'j, C: 'a>
 80 | where
 81 |     C: Context<'j>,
 82 | {
 83 |     cx: &'a mut C,
 84 |     object: Handle<'j, JsObject>,
 85 | }
 86 | 
 87 | #[doc(hidden)]
 88 | pub struct StructVariantSerializer<'a, 'j, C: 'a>
 89 | where
 90 |     C: Context<'j>,
 91 | {
 92 |     outer_object: Handle<'j, JsObject>,
 93 |     inner: StructSerializer<'a, 'j, C>,
 94 | }
 95 | 
 96 | #[doc(hidden)]
 97 | impl<'a, 'j, C> ser::Serializer for Serializer<'a, 'j, C>
 98 | where
 99 |     C: Context<'j>,
100 | {
101 |     type Ok = Handle<'j, JsValue>;
102 |     type Error = Error;
103 | 
104 |     type SerializeSeq = ArraySerializer<'a, 'j, C>;
105 |     type SerializeTuple = ArraySerializer<'a, 'j, C>;
106 |     type SerializeTupleStruct = ArraySerializer<'a, 'j, C>;
107 |     type SerializeTupleVariant = TupleVariantSerializer<'a, 'j, C>;
108 |     type SerializeMap = MapSerializer<'a, 'j, C>;
109 |     type SerializeStruct = StructSerializer<'a, 'j, C>;
110 |     type SerializeStructVariant = StructVariantSerializer<'a, 'j, C>;
111 | 
112 |     #[inline]
113 |     fn serialize_bool(self, v: bool) -> Result<Self::Ok, Self::Error> {
114 |         Ok(JsBoolean::new(self.cx, v).upcast())
115 |     }
116 | 
117 |     #[inline]
118 |     fn serialize_i8(self, v: i8) -> Result<Self::Ok, Self::Error> {
119 |         Ok(JsNumber::new(self.cx, as_num::<_, f64>(v)?).upcast())
120 |     }
121 | 
122 |     #[inline]
123 |     fn serialize_i16(self, v: i16) -> Result<Self::Ok, Self::Error> {
124 |         Ok(JsNumber::new(self.cx, as_num::<_, f64>(v)?).upcast())
125 |     }
126 | 
127 |     #[inline]
128 |     fn serialize_i32(self, v: i32) -> Result<Self::Ok, Self::Error> {
129 |         Ok(JsNumber::new(self.cx, as_num::<_, f64>(v)?).upcast())
130 |     }
131 | 
132 |     #[inline]
133 |     fn serialize_i64(self, v: i64) -> Result<Self::Ok, Self::Error> {
134 |         Ok(JsNumber::new(self.cx, as_num::<_, f64>(v)?).upcast())
135 |     }
136 | 
137 |     #[inline]
138 |     fn serialize_i128(self, v: i128) -> Result<Self::Ok, Self::Error> {
139 |         Ok(JsNumber::new(self.cx, as_num::<_, f64>(v)?).upcast())
140 |     }
141 | 
142 | 
143 |     #[inline]
144 |     fn serialize_u8(self, v: u8) -> Result<Self::Ok, Self::Error> {
145 |         Ok(JsNumber::new(self.cx, as_num::<_, f64>(v)?).upcast())
146 |     }
147 | 
148 |     #[inline]
149 |     fn serialize_u16(self, v: u16) -> Result<Self::Ok, Self::Error> {
150 |         Ok(JsNumber::new(self.cx, as_num::<_, f64>(v)?).upcast())
151 |     }
152 | 
153 |     #[inline]
154 |     fn serialize_u32(self, v: u32) -> Result<Self::Ok, Self::Error> {
155 |         Ok(JsNumber::new(self.cx, as_num::<_, f64>(v)?).upcast())
156 |     }
157 | 
158 |     #[inline]
159 |     fn serialize_u64(self, v: u64) -> Result<Self::Ok, Self::Error> {
160 |         Ok(JsNumber::new(self.cx, as_num::<_, f64>(v)?).upcast())
161 |     }
162 | 
163 |     #[inline]
164 |     fn serialize_u128(self, v: u128) -> Result<Self::Ok, Self::Error> {
165 |         Ok(JsNumber::new(self.cx, as_num::<_, f64>(v)?).upcast())
166 |     }
167 | 
168 |     #[inline]
169 |     fn serialize_f32(self, v: f32) -> Result<Self::Ok, Self::Error> {
170 |         Ok(JsNumber::new(self.cx, as_num::<_, f64>(v)?).upcast())
171 |     }
172 | 
173 |     #[inline]
174 |     fn serialize_f64(self, v: f64) -> Result<Self::Ok, Self::Error> {
175 |         Ok(JsNumber::new(self.cx, v).upcast())
176 |     }
177 | 
178 |     fn serialize_char(self, v: char) -> Result<Self::Ok, Self::Error> {
179 |         let mut b = [0; 4];
180 |         let result = v.encode_utf8(&mut b);
181 |         let js_str = JsString::try_new(self.cx, result)
182 |             .map_err(|_| ErrorKind::StringTooLongForChar(4))?;
183 |         Ok(js_str.upcast())
184 |     }
185 | 
186 |     #[inline]
187 |     fn serialize_str(self, v: &str) -> Result<Self::Ok, Self::Error> {
188 |         let len = v.len();
189 |         let js_str = JsString::try_new(self.cx, v).map_err(|_| ErrorKind::StringTooLong(len))?;
190 |         Ok(js_str.upcast())
191 |     }
192 | 
193 |     #[inline]
194 |     fn serialize_bytes(self, v: &[u8]) -> Result<Self::Ok, Self::Error> {
195 |         let mut buff = JsBuffer::new(self.cx, as_num::<_, u32>(v.len())?)?;
196 |         self.cx.borrow_mut(&mut buff, |buff| buff.as_mut_slice().clone_from_slice(v));
197 |         Ok(buff.upcast())
198 |     }
199 | 
200 |     #[inline]
201 |     fn serialize_none(self) -> Result<Self::Ok, Self::Error> {
202 |         Ok(JsNull::new().upcast())
203 |     }
204 | 
205 |     #[inline]
206 |     fn serialize_some<T: ?Sized>(self, value: &T) -> Result<Self::Ok, Self::Error>
207 |     where
208 |         T: Serialize,
209 |     {
210 |         value.serialize(self)
211 |     }
212 | 
213 |     #[inline]
214 |     fn serialize_unit(self) -> Result<Self::Ok, Self::Error> {
215 |         Ok(JsNull::new().upcast())
216 |     }
217 | 
218 |     #[inline]
219 |     fn serialize_unit_struct(self, _name: &'static str) -> Result<Self::Ok, Self::Error> {
220 |         Ok(JsNull::new().upcast())
221 |     }
222 | 
223 |     #[inline]
224 |     fn serialize_unit_variant(
225 |         self,
226 |         _name: &'static str,
227 |         _variant_index: u32,
228 |         variant: &'static str,
229 |     ) -> Result<Self::Ok, Self::Error> {
230 |         self.serialize_str(variant)
231 |     }
232 | 
233 |     #[inline]
234 |     fn serialize_newtype_struct<T: ?Sized>(
235 |         self,
236 |         _name: &'static str,
237 |         value: &T,
238 |     ) -> Result<Self::Ok, Self::Error>
239 |     where
240 |         T: Serialize,
241 |     {
242 |         value.serialize(self)
243 |     }
244 | 
245 |     #[inline]
246 |     fn serialize_newtype_variant<T: ?Sized>(
247 |         self,
248 |         _name: &'static str,
249 |         _variant_index: u32,
250 |         variant: &'static str,
251 |         value: &T,
252 |     ) -> Result<Self::Ok, Self::Error>
253 |     where
254 |         T: Serialize,
255 |     {
256 |         let obj = JsObject::new(&mut *self.cx);
257 |         let value_js = to_value(self.cx, value)?;
258 |         obj.set(self.cx, variant, value_js)?;
259 | 
260 |         Ok(obj.upcast())
261 |     }
262 | 
263 |     #[inline]
264 |     fn serialize_seq(self, _len: Option<usize>) -> Result<Self::SerializeSeq, Self::Error> {
265 |         Ok(ArraySerializer::new(self.cx))
266 |     }
267 | 
268 |     #[inline]
269 |     fn serialize_tuple(self, _len: usize) -> Result<Self::SerializeTuple, Self::Error> {
270 |         Ok(ArraySerializer::new(self.cx))
271 |     }
272 | 
273 |     #[inline]
274 |     fn serialize_tuple_struct(
275 |         self,
276 |         _name: &'static str,
277 |         _len: usize,
278 |     ) -> Result<Self::SerializeTupleStruct, Self::Error> {
279 |         Ok(ArraySerializer::new(self.cx))
280 |     }
281 | 
282 |     #[inline]
283 |     fn serialize_tuple_variant(
284 |         self,
285 |         _name: &'static str,
286 |         _variant_index: u32,
287 |         variant: &'static str,
288 |         _len: usize,
289 |     ) -> Result<Self::SerializeTupleVariant, Self::Error> {
290 |         TupleVariantSerializer::new(self.cx, variant)
291 |     }
292 | 
293 |     #[inline]
294 |     fn serialize_map(self, _len: Option<usize>) -> Result<Self::SerializeMap, Self::Error> {
295 |         Ok(MapSerializer::new(self.cx))
296 |     }
297 | 
298 |     #[inline]
299 |     fn serialize_struct(
300 |         self,
301 |         _name: &'static str,
302 |         _len: usize,
303 |     ) -> Result<Self::SerializeStruct, Self::Error> {
304 |         Ok(StructSerializer::new(self.cx))
305 |     }
306 | 
307 |     #[inline]
308 |     fn serialize_struct_variant(
309 |         self,
310 |         _name: &'static str,
311 |         _variant_index: u32,
312 |         variant: &'static str,
313 |         _len: usize,
314 |     ) -> Result<Self::SerializeStructVariant, Self::Error> {
315 |         StructVariantSerializer::new(self.cx, variant)
316 |     }
317 | }
318 | 
319 | #[doc(hidden)]
320 | impl<'a, 'j, C> ArraySerializer<'a, 'j, C>
321 | where
322 |     C: Context<'j>,
323 | {
324 |     #[inline]
325 |     fn new(cx: &'a mut C) -> Self {
326 |         let array = JsArray::new(cx, 0);
327 |         ArraySerializer { cx, array }
328 |     }
329 | }
330 | 
331 | #[doc(hidden)]
332 | impl<'a, 'j, C> ser::SerializeSeq for ArraySerializer<'a, 'j, C>
333 | where
334 |     C: Context<'j>,
335 | {
336 |     type Ok = Handle<'j, JsValue>;
337 |     type Error = Error;
338 | 
339 |     fn serialize_element<T: ?Sized>(&mut self, value: &T) -> Result<(), Self::Error>
340 |     where
341 |         T: Serialize,
342 |     {
343 |         let value = to_value(self.cx, value)?;
344 | 
345 |         let arr: Handle<'j, JsArray> = self.array;
346 |         let len = arr.len();
347 |         arr.set(self.cx, len, value)?;
348 |         Ok(())
349 |     }
350 | 
351 |     #[inline]
352 |     fn end(self) -> Result<Self::Ok, Self::Error> {
353 |         Ok(self.array.upcast())
354 |     }
355 | }
356 | 
357 | impl<'a, 'j, C> ser::SerializeTuple for ArraySerializer<'a, 'j, C>
358 | where
359 |     C: Context<'j>,
360 | {
361 |     type Ok = Handle<'j, JsValue>;
362 |     type Error = Error;
363 | 
364 |     #[inline]
365 |     fn serialize_element<T: ?Sized>(&mut self, value: &T) -> Result<(), Self::Error>
366 |     where
367 |         T: Serialize,
368 |     {
369 |         ser::SerializeSeq::serialize_element(self, value)
370 |     }
371 | 
372 |     #[inline]
373 |     fn end(self) -> Result<Self::Ok, Self::Error> {
374 |         ser::SerializeSeq::end(self)
375 |     }
376 | }
377 | 
378 | #[doc(hidden)]
379 | impl<'a, 'j, C> ser::SerializeTupleStruct for ArraySerializer<'a, 'j, C>
380 | where
381 |     C: Context<'j>,
382 | {
383 |     type Ok = Handle<'j, JsValue>;
384 |     type Error = Error;
385 | 
386 |     #[inline]
387 |     fn serialize_field<T: ?Sized>(&mut self, value: &T) -> Result<(), Self::Error>
388 |     where
389 |         T: Serialize,
390 |     {
391 |         ser::SerializeSeq::serialize_element(self, value)
392 |     }
393 | 
394 |     #[inline]
395 |     fn end(self) -> Result<Self::Ok, Self::Error> {
396 |         ser::SerializeSeq::end(self)
397 |     }
398 | }
399 | 
400 | #[doc(hidden)]
401 | impl<'a, 'j, C> TupleVariantSerializer<'a, 'j, C>
402 | where
403 |     C: Context<'j>,
404 | {
405 |     fn new(cx: &'a mut C, key: &'static str) -> LibResult<Self> {
406 |         let inner_array = JsArray::new(cx, 0);
407 |         let outter_object = JsObject::new(cx);
408 |         outter_object.set(cx, key, inner_array)?;
409 |         Ok(TupleVariantSerializer {
410 |             outter_object,
411 |             inner: ArraySerializer {
412 |                 cx,
413 |                 array: inner_array,
414 |             },
415 |         })
416 |     }
417 | }
418 | 
419 | #[doc(hidden)]
420 | impl<'a, 'j, C> ser::SerializeTupleVariant for TupleVariantSerializer<'a, 'j, C>
421 | where
422 |     C: Context<'j>,
423 | {
424 |     type Ok = Handle<'j, JsValue>;
425 |     type Error = Error;
426 | 
427 |     #[inline]
428 |     fn serialize_field<T: ?Sized>(&mut self, value: &T) -> Result<(), Self::Error>
429 |     where
430 |         T: Serialize,
431 |     {
432 |         use serde::ser::SerializeSeq;
433 |         self.inner.serialize_element(value)
434 |     }
435 | 
436 |     #[inline]
437 |     fn end(self) -> Result<Self::Ok, Self::Error> {
438 |         Ok(self.outter_object.upcast())
439 |     }
440 | }
441 | 
442 | #[doc(hidden)]
443 | impl<'a, 'j, C> MapSerializer<'a, 'j, C>
444 | where
445 |     C: Context<'j>,
446 | {
447 |     fn new(cx: &'a mut C) -> Self {
448 |         let object = JsObject::new(cx);
449 |         let key_holder = JsObject::new(cx);
450 |         MapSerializer {
451 |             cx,
452 |             object,
453 |             key_holder,
454 |         }
455 |     }
456 | }
457 | 
458 | #[doc(hidden)]
459 | impl<'a, 'j, C> ser::SerializeMap for MapSerializer<'a, 'j, C>
460 | where
461 |     C: Context<'j>,
462 | {
463 |     type Ok = Handle<'j, JsValue>;
464 |     type Error = Error;
465 | 
466 |     fn serialize_key<T: ?Sized>(&mut self, key: &T) -> Result<(), Self::Error>
467 |     where
468 |         T: Serialize,
469 |     {
470 |         let key = to_value(self.cx, key)?;
471 |         self.key_holder.set(self.cx, "key", key)?;
472 |         Ok(())
473 |     }
474 | 
475 |     fn serialize_value<T: ?Sized>(&mut self, value: &T) -> Result<(), Self::Error>
476 |     where
477 |         T: Serialize,
478 |     {
479 |         let key: Handle<'j, JsValue> = self.key_holder.get(&mut *self.cx, "key")?;
480 |         let value_obj = to_value(self.cx, value)?;
481 |         self.object.set(self.cx, key, value_obj)?;
482 |         Ok(())
483 |     }
484 | 
485 |     #[inline]
486 |     fn end(self) -> Result<Self::Ok, Self::Error> {
487 |         Ok(self.object.upcast())
488 |     }
489 | }
490 | 
491 | #[doc(hidden)]
492 | impl<'a, 'j, C> StructSerializer<'a, 'j, C>
493 | where
494 |     C: Context<'j>,
495 | {
496 |     #[inline]
497 |     fn new(cx: &'a mut C) -> Self {
498 |         let object = JsObject::new(cx);
499 |         StructSerializer { cx, object }
500 |     }
501 | }
502 | 
503 | #[doc(hidden)]
504 | impl<'a, 'j, C> ser::SerializeStruct for StructSerializer<'a, 'j, C>
505 | where
506 |     C: Context<'j>,
507 | {
508 |     type Ok = Handle<'j, JsValue>;
509 |     type Error = Error;
510 | 
511 |     #[inline]
512 |     fn serialize_field<T: ?Sized>(
513 |         &mut self,
514 |         key: &'static str,
515 |         value: &T,
516 |     ) -> Result<(), Self::Error>
517 |     where
518 |         T: Serialize,
519 |     {
520 |         let value = to_value(self.cx, value)?;
521 |         self.object.set(self.cx, key, value)?;
522 |         Ok(())
523 |     }
524 | 
525 |     #[inline]
526 |     fn end(self) -> Result<Self::Ok, Self::Error> {
527 |         Ok(self.object.upcast())
528 |     }
529 | }
530 | 
531 | #[doc(hidden)]
532 | impl<'a, 'j, C> StructVariantSerializer<'a, 'j, C>
533 | where
534 |     C: Context<'j>,
535 | {
536 |     fn new(cx: &'a mut C, key: &'static str) -> LibResult<Self> {
537 |         let inner_object = JsObject::new(cx);
538 |         let outter_object = JsObject::new(cx);
539 |         outter_object.set(cx, key, inner_object)?;
540 |         Ok(StructVariantSerializer {
541 |             outer_object: outter_object,
542 |             inner: StructSerializer {
543 |                 cx,
544 |                 object: inner_object,
545 |             },
546 |         })
547 |     }
548 | }
549 | 
550 | #[doc(hidden)]
551 | impl<'a, 'j, C> ser::SerializeStructVariant for StructVariantSerializer<'a, 'j, C>
552 | where
553 |     C: Context<'j>,
554 | {
555 |     type Ok = Handle<'j, JsValue>;
556 |     type Error = Error;
557 | 
558 |     #[inline]
559 |     fn serialize_field<T: ?Sized>(
560 |         &mut self,
561 |         key: &'static str,
562 |         value: &T,
563 |     ) -> Result<(), Self::Error>
564 |     where
565 |         T: Serialize,
566 |     {
567 |         use serde::ser::SerializeStruct;
568 |         self.inner.serialize_field(key, value)
569 |     }
570 | 
571 |     #[inline]
572 |     fn end(self) -> Result<Self::Ok, Self::Error> {
573 |         Ok(self.outer_object.upcast())
574 |     }
575 | }
576 | 


--------------------------------------------------------------------------------
/test/.gitignore:
--------------------------------------------------------------------------------
1 | native/target
2 | native/index.node
3 | native/artifacts.json
4 | **/*~
5 | **/node_modules
6 | **/.DS_Store
7 | 


--------------------------------------------------------------------------------
/test/__tests__/get_values.js:
--------------------------------------------------------------------------------
  1 | const native = require('../native');
  2 | const expect = require('expect');
  3 | 
  4 | describe('all values ok', () => {
  5 |     it('value 32', () => {
  6 |         expect(native.make_num_32()).toBe(32);
  7 |     });
  8 | 
  9 |     it('value 77', () => {
 10 |         expect(native.make_num_77()).toBe(77);
 11 |     });
 12 | 
 13 |     it('value Hello World', () => {
 14 |         expect(native.make_str_hello()).toBe('Hello World');
 15 |     });
 16 | 
 17 |     it('value array', () => {
 18 |         expect(native.make_num_array()).toEqual([0, 1, 2, 3, 4, 5, 6, 7, 8, 9]);
 19 |     });
 20 | 
 21 |     it('value object', () => {
 22 |         expect(native.make_obj()).toEqual({
 23 |             'a': 1,
 24 |             'b': [0.1, 1.1, 2.2, 3.3],
 25 |             'c': 'Hi'
 26 |         });
 27 |     });
 28 | 
 29 |     it('value map', () => {
 30 |         expect(native.make_map()).toEqual({
 31 |             'a': 1,
 32 |             'b': 2,
 33 |             'c': 3,
 34 |         });
 35 |     });
 36 | 
 37 |     it('make object', () => {
 38 |         expect(native.make_object()).toEqual({
 39 |             a: 1,
 40 |             b: [1, 2],
 41 |             c: "abc",
 42 |             d: false,
 43 |             e: null,
 44 |             f: null,
 45 |             g: [9, false, "efg"],
 46 |             h: '\uD83E\uDD37',
 47 |             i: "Empty",
 48 |             j: {Tuple: [27, "hij"]},
 49 |             k: {Struct: { a: 128, b: [9, 8, 7]}},
 50 |             l: "jkl",
 51 |             m: [0,1,2,3,4],
 52 |             o: {Value: ['z', 'y', 'x']},
 53 |             p: [1, 2, 3.5],
 54 |             q: 999,
 55 |             r: 333,
 56 |         });
 57 |     });
 58 | 
 59 |     it('make_buff', () => {
 60 |         const buff = new Buffer([255, 254, 253]);
 61 |         expect(native.make_buff()).toEqual(buff);
 62 |     });
 63 | 
 64 |     it('expect_hello_world', () => {
 65 |         native.expect_hello_world("hello world");
 66 |     });
 67 | 
 68 |     it('expect_obj', () => {
 69 |         const o = {
 70 |             a: 1,
 71 |             b: [1, 2],
 72 |             c: "abc",
 73 |             d: false,
 74 |             e: null,
 75 |             f: null,
 76 |             g: [9, false, "efg"],
 77 |             h: '\uD83E\uDD37',
 78 |             i: "Empty",
 79 |             j: {Tuple: [27, "hij"]},
 80 |             k: {Struct: { a: 128, b: [9, 8, 7]}},
 81 |             l: "jkl",
 82 |             m: [0,1,2,3,4],
 83 |             o: {Value: ['z', 'y', 'x']},
 84 |             p: [1, 2, 3.5],
 85 |             q: 999,
 86 |             r: 333,
 87 |         };
 88 | 
 89 |         o.self = o;
 90 | 
 91 |         native.expect_obj(o);
 92 |     });
 93 | 
 94 |     it('expect_num_array', () => {
 95 |         native.expect_num_array([0, 1, 2, 3]);
 96 |     });
 97 | 
 98 |     it('expect_buffer', () => {
 99 |         native.expect_buffer(new Buffer([252, 251, 250]));
100 |         native.expect_buffer(new Uint8Array([252, 251, 250]));
101 | 
102 |         const version = Number(process.versions.modules);
103 | 
104 |         if (version >= 57) {
105 |             native.expect_buffer(new Uint8ClampedArray([252, 251, 250]));
106 |         }
107 |     });
108 | 
109 |     it('rt_rust_js_rust', () => {
110 |         const obj = native.make_object();
111 |         native.expect_obj(obj);
112 |     });
113 | 
114 |     it('rt_js_rust_js', () => {
115 |         const o = {
116 |             a: 1,
117 |             b: [1, 2],
118 |             c: "abc",
119 |             d: false,
120 |             e: null,
121 |             f: null,
122 |             g: [9, false, "efg"],
123 |             h: '\uD83E\uDD37',
124 |             i: "Empty",
125 |             j: {Tuple: [27, "hij"]},
126 |             k: {Struct: { a: 128, b: [9, 8, 7]}},
127 |             l: "jkl",
128 |             m: [0,1,2,3,4],
129 |             o: {Value: ['z', 'y', 'x']},
130 |             p: [1, 2, 3.5],
131 |             q: 999,
132 |             r: 333,
133 |         };
134 |         const o2 = native.roundtrip_object(o);
135 |         expect(o).toEqual(o2);
136 |     });
137 | });
138 | 
139 | describe('throwing functions', () => {
140 | 
141 |     it('expect_hello_world', () => {
142 |         expect(() => native.expect_hello_world("GoodBye World")).toThrow(/assertion failed:/);
143 |     });
144 | 
145 |     it('expect_obj', () => {
146 |         expect(() => native.expect_obj({})).toThrow(/missing field `a`/);
147 |     });
148 | 
149 |     it('expect_num_array', () => {
150 |         expect(() => native.expect_num_array([0, 0, 0, 0])).toThrow(/assertion failed:/);
151 |     });
152 | 
153 |     it('expect_buffer', () => {
154 |         expect(() => native.expect_buffer()).toThrow(/not enough arguments/);
155 |     });
156 | 
157 |     it('getter that throws', () => {
158 |         const obj = {
159 |             a: 1,
160 |             b: [1,3]
161 |         };
162 |         for (const ch of 'cdefghijklmo') {
163 |             Object.defineProperty(obj, ch, {
164 |                 enumerable: true,
165 |                 configurable: false,
166 |                 get() {
167 |                     throw new Error('Hi There prop ' + ch);
168 |                 }
169 |             })
170 |         }
171 |         expect(() => native.expect_obj(obj))
172 |             .toThrow(/Hi There prop c/);
173 |     })
174 | });
175 | 


--------------------------------------------------------------------------------
/test/lib/index.js:
--------------------------------------------------------------------------------
1 | var addon = require('../native');
2 | 
3 | console.log(addon.hello());
4 | 


--------------------------------------------------------------------------------
/test/native/Cargo.toml:
--------------------------------------------------------------------------------
 1 | [package]
 2 | name = "test"
 3 | version = "0.1.0"
 4 | authors = ["Gabriel Castro <dev@GabrielCastro.ca>"]
 5 | license = "MIT"
 6 | build = "build.rs"
 7 | publish = false
 8 | 
 9 | [lib]
10 | name = "test"
11 | crate-type = ["dylib"]
12 | 
13 | [build-dependencies]
14 | neon-build = "0.4.0"
15 | 
16 | [dependencies]
17 | neon = "0.4.0"
18 | neon-serde = { path = "../../" }
19 | serde_derive = "1.0.106"
20 | serde = "1.0.106"
21 | serde_bytes = "0.11.3"
22 | 
23 | [profile.dev]
24 | codegen-units = 4
25 | lto = false
26 | 
27 | [profile.release]
28 | codegen-units = 4
29 | lto = false
30 | 


--------------------------------------------------------------------------------
/test/native/build.rs:
--------------------------------------------------------------------------------
1 | extern crate neon_build;
2 | 
3 | fn main() {
4 |     neon_build::setup(); // must be called in build.rs
5 | 
6 |     // add project-specific build logic here...
7 | }
8 | 


--------------------------------------------------------------------------------
/test/native/src/lib.rs:
--------------------------------------------------------------------------------
  1 | extern crate neon;
  2 | extern crate neon_serde;
  3 | extern crate serde_bytes;
  4 | #[macro_use]
  5 | extern crate serde_derive;
  6 | 
  7 | use neon::prelude::*;
  8 | 
  9 | #[derive(Serialize, Debug, Deserialize)]
 10 | struct AnObject {
 11 |     a: u32,
 12 |     b: Vec<f64>,
 13 |     c: String,
 14 | }
 15 | 
 16 | #[derive(Serialize, Debug, Deserialize, Eq, PartialEq)]
 17 | struct Inner;
 18 | 
 19 | #[derive(Serialize, Debug, Deserialize, Eq, PartialEq)]
 20 | struct Inner2(i32, bool, String);
 21 | 
 22 | #[derive(Serialize, Debug, Deserialize, Eq, PartialEq)]
 23 | enum TypeEnum {
 24 |     Empty,
 25 |     Tuple(u32, String),
 26 |     Struct { a: u8, b: Vec<u8> },
 27 |     Value(Vec<char>),
 28 | }
 29 | 
 30 | #[derive(Serialize, Debug, Deserialize, PartialEq)]
 31 | struct AnObjectTwo {
 32 |     a: u32,
 33 |     b: Vec<i64>,
 34 |     c: String,
 35 |     d: Option<bool>,
 36 |     e: Option<bool>,
 37 |     f: Inner,
 38 |     g: Inner2,
 39 |     h: char,
 40 |     i: TypeEnum,
 41 |     j: TypeEnum,
 42 |     k: TypeEnum,
 43 |     l: String,
 44 |     m: Vec<u8>,
 45 |     o: TypeEnum,
 46 |     p: Vec<f64>,
 47 |     q: u128,
 48 |     r: i128,
 49 | }
 50 | 
 51 | macro_rules! make_test {
 52 |     ($name:ident, $val:expr) => {
 53 |         fn $name(cx: FunctionContext) -> JsResult<JsValue> {
 54 |             fn inner(mut cx: FunctionContext) -> neon_serde::errors::Result<Handle<JsValue>> {
 55 |                 let value = $val;
 56 | 
 57 |                 let handle = neon_serde::to_value(&mut cx, &value)?;
 58 |                 Ok(handle)
 59 |             }
 60 | 
 61 |             Ok(inner(cx)?)
 62 |         }
 63 |     };
 64 | }
 65 | 
 66 | make_test!(make_num_77, 77i32);
 67 | make_test!(make_num_32, 32u8);
 68 | make_test!(make_str_hello, "Hello World");
 69 | make_test!(make_num_array, vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9]);
 70 | make_test!(
 71 |     make_obj,
 72 |     AnObject {
 73 |         a: 1,
 74 |         b: vec![0.1f64, 1.1, 2.2, 3.3],
 75 |         c: "Hi".into(),
 76 |     }
 77 | );
 78 | make_test!(make_map, {
 79 |     use std::collections::HashMap;
 80 |     let mut map = HashMap::new();
 81 |     map.insert("a", 1);
 82 |     map.insert("b", 2);
 83 |     map.insert("c", 3);
 84 |     map
 85 | });
 86 | 
 87 | make_test!(make_object, {
 88 |     let value = AnObjectTwo {
 89 |         a: 1,
 90 |         b: vec![1, 2],
 91 |         c: "abc".into(),
 92 |         d: Some(false),
 93 |         e: None,
 94 |         f: Inner,
 95 |         g: Inner2(9, false, "efg".into()),
 96 |         h: '🤷',
 97 |         i: TypeEnum::Empty,
 98 |         j: TypeEnum::Tuple(27, "hij".into()),
 99 |         k: TypeEnum::Struct {
100 |             a: 128,
101 |             b: vec![9, 8, 7],
102 |         },
103 |         l: "jkl".into(),
104 |         m: vec![0, 1, 2, 3, 4],
105 |         o: TypeEnum::Value(vec!['z', 'y', 'x']),
106 |         p: vec![1., 2., 3.5],
107 |         q: 999,
108 |         r: 333,
109 |     };
110 |     value
111 | });
112 | 
113 | const NUMBER_BYTES: &'static [u8] = &[255u8, 254, 253];
114 | 
115 | make_test!(make_buff, { serde_bytes::Bytes::new(NUMBER_BYTES) });
116 | 
117 | macro_rules! make_expect {
118 |     ($name:ident, $val:expr, $val_type:ty) => {
119 |         fn $name(cx: FunctionContext) -> JsResult<JsValue> {
120 |             fn inner(mut cx: FunctionContext) -> neon_serde::errors::Result<Handle<JsValue>> {
121 |                 let value = $val;
122 |                 let arg0 = cx.argument::<JsValue>(0)?;
123 | 
124 |                 let de_serialized: $val_type = neon_serde::from_value(&mut cx, arg0)?;
125 |                 assert_eq!(value, de_serialized);
126 |                 Ok(JsUndefined::new().upcast())
127 |             }
128 |             Ok(inner(cx)?)
129 |         }
130 |     };
131 | }
132 | 
133 | make_expect!(expect_hello_world, "hello world", String);
134 | 
135 | make_expect!(
136 |     expect_obj,
137 |     AnObjectTwo {
138 |         a: 1,
139 |         b: vec![1, 2],
140 |         c: "abc".into(),
141 |         d: Some(false),
142 |         e: None,
143 |         f: Inner,
144 |         g: Inner2(9, false, "efg".into()),
145 |         h: '🤷',
146 |         i: TypeEnum::Empty,
147 |         j: TypeEnum::Tuple(27, "hij".into()),
148 |         k: TypeEnum::Struct {
149 |             a: 128,
150 |             b: vec![9, 8, 7],
151 |         },
152 |         l: "jkl".into(),
153 |         m: vec![0, 1, 2, 3, 4],
154 |         o: TypeEnum::Value(vec!['z', 'y', 'x']),
155 |         p: vec![1., 2., 3.5],
156 |         q: 999,
157 |         r: 333
158 |     },
159 |     AnObjectTwo
160 | );
161 | 
162 | make_expect!(expect_num_array, vec![0, 1, 2, 3], Vec<i32>);
163 | 
164 | make_expect!(
165 |     expect_buffer,
166 |     serde_bytes::ByteBuf::from(vec![252u8, 251, 250]),
167 |     serde_bytes::ByteBuf
168 | );
169 | 
170 | fn roundtrip_object(mut cx: FunctionContext) -> JsResult<JsValue> {
171 |     let arg0 = cx.argument::<JsValue>(0)?;
172 | 
173 |     let de_serialized: AnObjectTwo = neon_serde::from_value(&mut cx, arg0)?;
174 |     let handle = neon_serde::to_value(&mut cx, &de_serialized)?;
175 |     Ok(handle)
176 | }
177 | 
178 | register_module!(mut m, {
179 |     m.export_function("make_num_77", make_num_77)?;
180 |     m.export_function("make_num_32", make_num_32)?;
181 |     m.export_function("make_str_hello", make_str_hello)?;
182 |     m.export_function("make_num_array", make_num_array)?;
183 |     m.export_function("make_buff", make_buff)?;
184 |     m.export_function("make_obj", make_obj)?;
185 |     m.export_function("make_object", make_object)?;
186 |     m.export_function("make_map", make_map)?;
187 | 
188 |     m.export_function("expect_hello_world", expect_hello_world)?;
189 |     m.export_function("expect_obj", expect_obj)?;
190 |     m.export_function("expect_num_array", expect_num_array)?;
191 |     m.export_function("expect_buffer", expect_buffer)?;
192 | 
193 |     m.export_function("roundtrip_object", roundtrip_object)?;
194 |     Ok(())
195 | });
196 | 


--------------------------------------------------------------------------------
/test/package.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "name": "test",
 3 |   "version": "0.1.0",
 4 |   "description": "",
 5 |   "main": "lib/index.js",
 6 |   "author": "Gabriel Castro <dev@GabrielCastro.ca>",
 7 |   "license": "MIT",
 8 |   "devDependencies": {
 9 |     "expect": "^24.9.0",
10 |     "mocha": "^6.2.1",
11 |     "neon-cli": "^0.4.0"
12 |   },
13 |   "scripts": {
14 |     "build": "neon build --release",
15 |     "build:debug": "neon build",
16 |     "test": "neon build && mocha __tests__"
17 |   }
18 | }


--------------------------------------------------------------------------------
/test/yarn.lock:
--------------------------------------------------------------------------------
   1 | # THIS IS AN AUTOGENERATED FILE. DO NOT EDIT THIS FILE DIRECTLY.
   2 | # yarn lockfile v1
   3 | 
   4 | 
   5 | "@babel/code-frame@^7.0.0":
   6 |   version "7.5.5"
   7 |   resolved "https://registry.yarnpkg.com/@babel/code-frame/-/code-frame-7.5.5.tgz#bc0782f6d69f7b7d49531219699b988f669a8f9d"
   8 |   integrity sha512-27d4lZoomVyo51VegxI20xZPuSHusqbQag/ztrBC7wegWoQ1nLREPVSKSW8byhTlzTKyNE4ifaTA6lCp7JjpFw==
   9 |   dependencies:
  10 |     "@babel/highlight" "^7.0.0"
  11 | 
  12 | "@babel/highlight@^7.0.0":
  13 |   version "7.5.0"
  14 |   resolved "https://registry.yarnpkg.com/@babel/highlight/-/highlight-7.5.0.tgz#56d11312bd9248fa619591d02472be6e8cb32540"
  15 |   integrity sha512-7dV4eu9gBxoM0dAnj/BCFDW9LFU0zvTrkq0ugM7pnHEgguOEeOz1so2ZghEdzviYzQEED0r4EAgpsBChKy1TRQ==
  16 |   dependencies:
  17 |     chalk "^2.0.0"
  18 |     esutils "^2.0.2"
  19 |     js-tokens "^4.0.0"
  20 | 
  21 | "@jest/console@^24.9.0":
  22 |   version "24.9.0"
  23 |   resolved "https://registry.yarnpkg.com/@jest/console/-/console-24.9.0.tgz#79b1bc06fb74a8cfb01cbdedf945584b1b9707f0"
  24 |   integrity sha512-Zuj6b8TnKXi3q4ymac8EQfc3ea/uhLeCGThFqXeC8H9/raaH8ARPUTdId+XyGd03Z4In0/VjD2OYFcBF09fNLQ==
  25 |   dependencies:
  26 |     "@jest/source-map" "^24.9.0"
  27 |     chalk "^2.0.1"
  28 |     slash "^2.0.0"
  29 | 
  30 | "@jest/source-map@^24.9.0":
  31 |   version "24.9.0"
  32 |   resolved "https://registry.yarnpkg.com/@jest/source-map/-/source-map-24.9.0.tgz#0e263a94430be4b41da683ccc1e6bffe2a191714"
  33 |   integrity sha512-/Xw7xGlsZb4MJzNDgB7PW5crou5JqWiBQaz6xyPd3ArOg2nfn/PunV8+olXbbEZzNl591o5rWKE9BRDaFAuIBg==
  34 |   dependencies:
  35 |     callsites "^3.0.0"
  36 |     graceful-fs "^4.1.15"
  37 |     source-map "^0.6.0"
  38 | 
  39 | "@jest/test-result@^24.9.0":
  40 |   version "24.9.0"
  41 |   resolved "https://registry.yarnpkg.com/@jest/test-result/-/test-result-24.9.0.tgz#11796e8aa9dbf88ea025757b3152595ad06ba0ca"
  42 |   integrity sha512-XEFrHbBonBJ8dGp2JmF8kP/nQI/ImPpygKHwQ/SY+es59Z3L5PI4Qb9TQQMAEeYsThG1xF0k6tmG0tIKATNiiA==
  43 |   dependencies:
  44 |     "@jest/console" "^24.9.0"
  45 |     "@jest/types" "^24.9.0"
  46 |     "@types/istanbul-lib-coverage" "^2.0.0"
  47 | 
  48 | "@jest/types@^24.9.0":
  49 |   version "24.9.0"
  50 |   resolved "https://registry.yarnpkg.com/@jest/types/-/types-24.9.0.tgz#63cb26cb7500d069e5a389441a7c6ab5e909fc59"
  51 |   integrity sha512-XKK7ze1apu5JWQ5eZjHITP66AX+QsLlbaJRBGYr8pNzwcAE2JVkwnf0yqjHTsDRcjR0mujy/NmZMXw5kl+kGBw==
  52 |   dependencies:
  53 |     "@types/istanbul-lib-coverage" "^2.0.0"
  54 |     "@types/istanbul-reports" "^1.1.1"
  55 |     "@types/yargs" "^13.0.0"
  56 | 
  57 | "@types/istanbul-lib-coverage@*", "@types/istanbul-lib-coverage@^2.0.0":
  58 |   version "2.0.1"
  59 |   resolved "https://registry.yarnpkg.com/@types/istanbul-lib-coverage/-/istanbul-lib-coverage-2.0.1.tgz#42995b446db9a48a11a07ec083499a860e9138ff"
  60 |   integrity sha512-hRJD2ahnnpLgsj6KWMYSrmXkM3rm2Dl1qkx6IOFD5FnuNPXJIG5L0dhgKXCYTRMGzU4n0wImQ/xfmRc4POUFlg==
  61 | 
  62 | "@types/istanbul-lib-report@*":
  63 |   version "1.1.1"
  64 |   resolved "https://registry.yarnpkg.com/@types/istanbul-lib-report/-/istanbul-lib-report-1.1.1.tgz#e5471e7fa33c61358dd38426189c037a58433b8c"
  65 |   integrity sha512-3BUTyMzbZa2DtDI2BkERNC6jJw2Mr2Y0oGI7mRxYNBPxppbtEK1F66u3bKwU2g+wxwWI7PAoRpJnOY1grJqzHg==
  66 |   dependencies:
  67 |     "@types/istanbul-lib-coverage" "*"
  68 | 
  69 | "@types/istanbul-reports@^1.1.1":
  70 |   version "1.1.1"
  71 |   resolved "https://registry.yarnpkg.com/@types/istanbul-reports/-/istanbul-reports-1.1.1.tgz#7a8cbf6a406f36c8add871625b278eaf0b0d255a"
  72 |   integrity sha512-UpYjBi8xefVChsCoBpKShdxTllC9pwISirfoZsUa2AAdQg/Jd2KQGtSbw+ya7GPo7x/wAPlH6JBhKhAsXUEZNA==
  73 |   dependencies:
  74 |     "@types/istanbul-lib-coverage" "*"
  75 |     "@types/istanbul-lib-report" "*"
  76 | 
  77 | "@types/stack-utils@^1.0.1":
  78 |   version "1.0.1"
  79 |   resolved "https://registry.yarnpkg.com/@types/stack-utils/-/stack-utils-1.0.1.tgz#0a851d3bd96498fa25c33ab7278ed3bd65f06c3e"
  80 |   integrity sha512-l42BggppR6zLmpfU6fq9HEa2oGPEI8yrSPL3GITjfRInppYFahObbIQOQK3UGxEnyQpltZLaPe75046NOZQikw==
  81 | 
  82 | "@types/yargs-parser@*":
  83 |   version "13.0.0"
  84 |   resolved "https://registry.yarnpkg.com/@types/yargs-parser/-/yargs-parser-13.0.0.tgz#453743c5bbf9f1bed61d959baab5b06be029b2d0"
  85 |   integrity sha512-wBlsw+8n21e6eTd4yVv8YD/E3xq0O6nNnJIquutAsFGE7EyMKz7W6RNT6BRu1SmdgmlCZ9tb0X+j+D6HGr8pZw==
  86 | 
  87 | "@types/yargs@^13.0.0":
  88 |   version "13.0.2"
  89 |   resolved "https://registry.yarnpkg.com/@types/yargs/-/yargs-13.0.2.tgz#a64674fc0149574ecd90ba746e932b5a5f7b3653"
  90 |   integrity sha512-lwwgizwk/bIIU+3ELORkyuOgDjCh7zuWDFqRtPPhhVgq9N1F7CvLNKg1TX4f2duwtKQ0p044Au9r1PLIXHrIzQ==
  91 |   dependencies:
  92 |     "@types/yargs-parser" "*"
  93 | 
  94 | ansi-colors@3.2.3:
  95 |   version "3.2.3"
  96 |   resolved "https://registry.yarnpkg.com/ansi-colors/-/ansi-colors-3.2.3.tgz#57d35b8686e851e2cc04c403f1c00203976a1813"
  97 |   integrity sha512-LEHHyuhlPY3TmuUYMh2oz89lTShfvgbmzaBcxve9t/9Wuy7Dwf4yoAKcND7KFT1HAQfqZ12qtc+DUrBMeKF9nw==
  98 | 
  99 | ansi-escape-sequences@^4.0.0:
 100 |   version "4.1.0"
 101 |   resolved "https://registry.yarnpkg.com/ansi-escape-sequences/-/ansi-escape-sequences-4.1.0.tgz#2483c8773f50dd9174dd9557e92b1718f1816097"
 102 |   integrity sha512-dzW9kHxH011uBsidTXd14JXgzye/YLb2LzeKZ4bsgl/Knwx8AtbSFkkGxagdNOoh0DlqHCmfiEjWKBaqjOanVw==
 103 |   dependencies:
 104 |     array-back "^3.0.1"
 105 | 
 106 | ansi-escapes@^3.0.0:
 107 |   version "3.2.0"
 108 |   resolved "https://registry.yarnpkg.com/ansi-escapes/-/ansi-escapes-3.2.0.tgz#8780b98ff9dbf5638152d1f1fe5c1d7b4442976b"
 109 |   integrity sha512-cBhpre4ma+U0T1oM5fXg7Dy1Jw7zzwv7lt/GoCpr+hDQJoYnKVPLL4dCvSEFMmQurOQvSrwT7SL/DAlhBI97RQ==
 110 | 
 111 | ansi-regex@^3.0.0:
 112 |   version "3.0.0"
 113 |   resolved "https://registry.yarnpkg.com/ansi-regex/-/ansi-regex-3.0.0.tgz#ed0317c322064f79466c02966bddb605ab37d998"
 114 |   integrity sha1-7QMXwyIGT3lGbAKWa922Bas32Zg=
 115 | 
 116 | ansi-regex@^4.0.0, ansi-regex@^4.1.0:
 117 |   version "4.1.0"
 118 |   resolved "https://registry.yarnpkg.com/ansi-regex/-/ansi-regex-4.1.0.tgz#8b9f8f08cf1acb843756a839ca8c7e3168c51997"
 119 |   integrity sha512-1apePfXM1UOSqw0o9IiFAovVz9M5S1Dg+4TrDwfMewQ6p/rmMueb7tWZjQ1rx4Loy1ArBggoqGpfqqdI4rondg==
 120 | 
 121 | ansi-styles@^3.1.0, ansi-styles@^3.2.0, ansi-styles@^3.2.1:
 122 |   version "3.2.1"
 123 |   resolved "https://registry.yarnpkg.com/ansi-styles/-/ansi-styles-3.2.1.tgz#41fbb20243e50b12be0f04b8dedbf07520ce841d"
 124 |   integrity sha512-VT0ZI6kZRdTh8YyJw3SMbYm/u+NqfsAxEpWO0Pf9sq8/e94WxxOpPKx9FR1FlyCtOVDNOQ+8ntlqFxiRc+r5qA==
 125 |   dependencies:
 126 |     color-convert "^1.9.0"
 127 | 
 128 | argparse@^1.0.7:
 129 |   version "1.0.10"
 130 |   resolved "https://registry.yarnpkg.com/argparse/-/argparse-1.0.10.tgz#bcd6791ea5ae09725e17e5ad988134cd40b3d911"
 131 |   integrity sha512-o5Roy6tNG4SL/FOkCAN6RzjiakZS25RLYFrcMttJqbdd8BWrnA+fGz57iN5Pb06pvBGvl5gQ0B48dJlslXvoTg==
 132 |   dependencies:
 133 |     sprintf-js "~1.0.2"
 134 | 
 135 | arr-diff@^4.0.0:
 136 |   version "4.0.0"
 137 |   resolved "https://registry.yarnpkg.com/arr-diff/-/arr-diff-4.0.0.tgz#d6461074febfec71e7e15235761a329a5dc7c520"
 138 |   integrity sha1-1kYQdP6/7HHn4VI1dhoyml3HxSA=
 139 | 
 140 | arr-flatten@^1.1.0:
 141 |   version "1.1.0"
 142 |   resolved "https://registry.yarnpkg.com/arr-flatten/-/arr-flatten-1.1.0.tgz#36048bbff4e7b47e136644316c99669ea5ae91f1"
 143 |   integrity sha512-L3hKV5R/p5o81R7O02IGnwpDmkp6E982XhtbuwSe3O4qOtMMMtodicASA1Cny2U+aCXcNpml+m4dPsvsJ3jatg==
 144 | 
 145 | arr-union@^3.1.0:
 146 |   version "3.1.0"
 147 |   resolved "https://registry.yarnpkg.com/arr-union/-/arr-union-3.1.0.tgz#e39b09aea9def866a8f206e288af63919bae39c4"
 148 |   integrity sha1-45sJrqne+Gao8gbiiK9jkZuuOcQ=
 149 | 
 150 | array-back@^1.0.3, array-back@^1.0.4:
 151 |   version "1.0.4"
 152 |   resolved "https://registry.yarnpkg.com/array-back/-/array-back-1.0.4.tgz#644ba7f095f7ffcf7c43b5f0dc39d3c1f03c063b"
 153 |   integrity sha1-ZEun8JX3/898Q7Xw3DnTwfA8Bjs=
 154 |   dependencies:
 155 |     typical "^2.6.0"
 156 | 
 157 | array-back@^2.0.0:
 158 |   version "2.0.0"
 159 |   resolved "https://registry.yarnpkg.com/array-back/-/array-back-2.0.0.tgz#6877471d51ecc9c9bfa6136fb6c7d5fe69748022"
 160 |   integrity sha512-eJv4pLLufP3g5kcZry0j6WXpIbzYw9GUB4mVJZno9wfwiBxbizTnHCw3VJb07cBihbFX48Y7oSrW9y+gt4glyw==
 161 |   dependencies:
 162 |     typical "^2.6.1"
 163 | 
 164 | array-back@^3.0.1:
 165 |   version "3.1.0"
 166 |   resolved "https://registry.yarnpkg.com/array-back/-/array-back-3.1.0.tgz#b8859d7a508871c9a7b2cf42f99428f65e96bfb0"
 167 |   integrity sha512-TkuxA4UCOvxuDK6NZYXCalszEzj+TLszyASooky+i742l9TqsOdYCMJJupxRic61hwquNtppB3hgcuq9SVSH1Q==
 168 | 
 169 | array-unique@^0.3.2:
 170 |   version "0.3.2"
 171 |   resolved "https://registry.yarnpkg.com/array-unique/-/array-unique-0.3.2.tgz#a894b75d4bc4f6cd679ef3244a9fd8f46ae2d428"
 172 |   integrity sha1-qJS3XUvE9s1nnvMkSp/Y9Gri1Cg=
 173 | 
 174 | assign-symbols@^1.0.0:
 175 |   version "1.0.0"
 176 |   resolved "https://registry.yarnpkg.com/assign-symbols/-/assign-symbols-1.0.0.tgz#59667f41fadd4f20ccbc2bb96b8d4f7f78ec0367"
 177 |   integrity sha1-WWZ/QfrdTyDMvCu5a41Pf3jsA2c=
 178 | 
 179 | atob@^2.1.1:
 180 |   version "2.1.2"
 181 |   resolved "https://registry.yarnpkg.com/atob/-/atob-2.1.2.tgz#6d9517eb9e030d2436666651e86bd9f6f13533c9"
 182 |   integrity sha512-Wm6ukoaOGJi/73p/cl2GvLjTI5JM1k/O14isD73YML8StrH/7/lRFgmg8nICZgD3bZZvjwCGxtMOD3wWNAu8cg==
 183 | 
 184 | balanced-match@^1.0.0:
 185 |   version "1.0.0"
 186 |   resolved "https://registry.yarnpkg.com/balanced-match/-/balanced-match-1.0.0.tgz#89b4d199ab2bee49de164ea02b89ce462d71b767"
 187 |   integrity sha1-ibTRmasr7kneFk6gK4nORi1xt2c=
 188 | 
 189 | base@^0.11.1:
 190 |   version "0.11.2"
 191 |   resolved "https://registry.yarnpkg.com/base/-/base-0.11.2.tgz#7bde5ced145b6d551a90db87f83c558b4eb48a8f"
 192 |   integrity sha512-5T6P4xPgpp0YDFvSWwEZ4NoE3aM4QBQXDzmVbraCkFj8zHM+mba8SyqB5DbZWyR7mYHo6Y7BdQo3MoA4m0TeQg==
 193 |   dependencies:
 194 |     cache-base "^1.0.1"
 195 |     class-utils "^0.3.5"
 196 |     component-emitter "^1.2.1"
 197 |     define-property "^1.0.0"
 198 |     isobject "^3.0.1"
 199 |     mixin-deep "^1.2.0"
 200 |     pascalcase "^0.1.1"
 201 | 
 202 | brace-expansion@^1.1.7:
 203 |   version "1.1.11"
 204 |   resolved "https://registry.yarnpkg.com/brace-expansion/-/brace-expansion-1.1.11.tgz#3c7fcbf529d87226f3d2f52b966ff5271eb441dd"
 205 |   integrity sha512-iCuPHDFgrHX7H2vEI/5xpz07zSHB00TpugqhmYtVmMO6518mCuRMoOYFldEBl0g187ufozdaHgWKcYFb61qGiA==
 206 |   dependencies:
 207 |     balanced-match "^1.0.0"
 208 |     concat-map "0.0.1"
 209 | 
 210 | braces@^2.3.1:
 211 |   version "2.3.2"
 212 |   resolved "https://registry.yarnpkg.com/braces/-/braces-2.3.2.tgz#5979fd3f14cd531565e5fa2df1abfff1dfaee729"
 213 |   integrity sha512-aNdbnj9P8PjdXU4ybaWLK2IF3jc/EoDYbC7AazW6to3TRsfXxscC9UXOB5iDiEQrkyIbWp2SLQda4+QAa7nc3w==
 214 |   dependencies:
 215 |     arr-flatten "^1.1.0"
 216 |     array-unique "^0.3.2"
 217 |     extend-shallow "^2.0.1"
 218 |     fill-range "^4.0.0"
 219 |     isobject "^3.0.1"
 220 |     repeat-element "^1.1.2"
 221 |     snapdragon "^0.8.1"
 222 |     snapdragon-node "^2.0.1"
 223 |     split-string "^3.0.2"
 224 |     to-regex "^3.0.1"
 225 | 
 226 | browser-stdout@1.3.1:
 227 |   version "1.3.1"
 228 |   resolved "https://registry.yarnpkg.com/browser-stdout/-/browser-stdout-1.3.1.tgz#baa559ee14ced73452229bad7326467c61fabd60"
 229 |   integrity sha512-qhAVI1+Av2X7qelOfAIYwXONood6XlZE/fXaBSmW/T5SzLAmCgzi+eiWE7fUvbHaeNBQH13UftjpXxsfLkMpgw==
 230 | 
 231 | builtins@^1.0.3:
 232 |   version "1.0.3"
 233 |   resolved "https://registry.yarnpkg.com/builtins/-/builtins-1.0.3.tgz#cb94faeb61c8696451db36534e1422f94f0aee88"
 234 |   integrity sha1-y5T662HIaWRR2zZTThQi+U8K7og=
 235 | 
 236 | cache-base@^1.0.1:
 237 |   version "1.0.1"
 238 |   resolved "https://registry.yarnpkg.com/cache-base/-/cache-base-1.0.1.tgz#0a7f46416831c8b662ee36fe4e7c59d76f666ab2"
 239 |   integrity sha512-AKcdTnFSWATd5/GCPRxr2ChwIJ85CeyrEyjRHlKxQ56d4XJMGym0uAiKn0xbLOGOl3+yRpOTi484dVCEc5AUzQ==
 240 |   dependencies:
 241 |     collection-visit "^1.0.0"
 242 |     component-emitter "^1.2.1"
 243 |     get-value "^2.0.6"
 244 |     has-value "^1.0.0"
 245 |     isobject "^3.0.1"
 246 |     set-value "^2.0.0"
 247 |     to-object-path "^0.3.0"
 248 |     union-value "^1.0.0"
 249 |     unset-value "^1.0.0"
 250 | 
 251 | callsites@^3.0.0:
 252 |   version "3.1.0"
 253 |   resolved "https://registry.yarnpkg.com/callsites/-/callsites-3.1.0.tgz#b3630abd8943432f54b3f0519238e33cd7df2f73"
 254 |   integrity sha512-P8BjAsXvZS+VIDUI11hHCQEv74YT67YUi5JJFNWIqL235sBmjX4+qx9Muvls5ivyNENctx46xQLQ3aTuE7ssaQ==
 255 | 
 256 | camelcase@^5.0.0:
 257 |   version "5.3.1"
 258 |   resolved "https://registry.yarnpkg.com/camelcase/-/camelcase-5.3.1.tgz#e3c9b31569e106811df242f715725a1f4c494320"
 259 |   integrity sha512-L28STB170nwWS63UjtlEOE3dldQApaJXZkOI1uMFfzf3rRuPegHaHesyee+YxQ+W6SvRDQV6UrdOdRiR153wJg==
 260 | 
 261 | chalk@^2.0.0, chalk@^2.0.1:
 262 |   version "2.4.2"
 263 |   resolved "https://registry.yarnpkg.com/chalk/-/chalk-2.4.2.tgz#cd42541677a54333cf541a49108c1432b44c9424"
 264 |   integrity sha512-Mti+f9lpJNcwF4tWV8/OrTTtF1gZi+f8FqlyAdouralcFWFQWF2+NgCHShjkCb+IFBLq9buZwE1xckQU4peSuQ==
 265 |   dependencies:
 266 |     ansi-styles "^3.2.1"
 267 |     escape-string-regexp "^1.0.5"
 268 |     supports-color "^5.3.0"
 269 | 
 270 | chalk@~2.1.0:
 271 |   version "2.1.0"
 272 |   resolved "https://registry.yarnpkg.com/chalk/-/chalk-2.1.0.tgz#ac5becf14fa21b99c6c92ca7a7d7cfd5b17e743e"
 273 |   integrity sha512-LUHGS/dge4ujbXMJrnihYMcL4AoOweGnw9Tp3kQuqy1Kx5c1qKjqvMJZ6nVJPMWJtKCTN72ZogH3oeSO9g9rXQ==
 274 |   dependencies:
 275 |     ansi-styles "^3.1.0"
 276 |     escape-string-regexp "^1.0.5"
 277 |     supports-color "^4.0.0"
 278 | 
 279 | chardet@^0.4.0:
 280 |   version "0.4.2"
 281 |   resolved "https://registry.yarnpkg.com/chardet/-/chardet-0.4.2.tgz#b5473b33dc97c424e5d98dc87d55d4d8a29c8bf2"
 282 |   integrity sha1-tUc7M9yXxCTl2Y3IfVXU2KKci/I=
 283 | 
 284 | class-utils@^0.3.5:
 285 |   version "0.3.6"
 286 |   resolved "https://registry.yarnpkg.com/class-utils/-/class-utils-0.3.6.tgz#f93369ae8b9a7ce02fd41faad0ca83033190c463"
 287 |   integrity sha512-qOhPa/Fj7s6TY8H8esGu5QNpMMQxz79h+urzrNYN6mn+9BnxlDGf5QZ+XeCDsxSjPqsSR56XOZOJmpeurnLMeg==
 288 |   dependencies:
 289 |     arr-union "^3.1.0"
 290 |     define-property "^0.2.5"
 291 |     isobject "^3.0.0"
 292 |     static-extend "^0.1.1"
 293 | 
 294 | cli-cursor@^2.1.0:
 295 |   version "2.1.0"
 296 |   resolved "https://registry.yarnpkg.com/cli-cursor/-/cli-cursor-2.1.0.tgz#b35dac376479facc3e94747d41d0d0f5238ffcb5"
 297 |   integrity sha1-s12sN2R5+sw+lHR9QdDQ9SOP/LU=
 298 |   dependencies:
 299 |     restore-cursor "^2.0.0"
 300 | 
 301 | cli-width@^2.0.0:
 302 |   version "2.2.0"
 303 |   resolved "https://registry.yarnpkg.com/cli-width/-/cli-width-2.2.0.tgz#ff19ede8a9a5e579324147b0c11f0fbcbabed639"
 304 |   integrity sha1-/xnt6Kml5XkyQUewwR8PvLq+1jk=
 305 | 
 306 | cliui@^5.0.0:
 307 |   version "5.0.0"
 308 |   resolved "https://registry.yarnpkg.com/cliui/-/cliui-5.0.0.tgz#deefcfdb2e800784aa34f46fa08e06851c7bbbc5"
 309 |   integrity sha512-PYeGSEmmHM6zvoef2w8TPzlrnNpXIjTipYK780YswmIP9vjxmd6Y2a3CB2Ks6/AU8NHjZugXvo8w3oWM2qnwXA==
 310 |   dependencies:
 311 |     string-width "^3.1.0"
 312 |     strip-ansi "^5.2.0"
 313 |     wrap-ansi "^5.1.0"
 314 | 
 315 | collection-visit@^1.0.0:
 316 |   version "1.0.0"
 317 |   resolved "https://registry.yarnpkg.com/collection-visit/-/collection-visit-1.0.0.tgz#4bc0373c164bc3291b4d368c829cf1a80a59dca0"
 318 |   integrity sha1-S8A3PBZLwykbTTaMgpzxqApZ3KA=
 319 |   dependencies:
 320 |     map-visit "^1.0.0"
 321 |     object-visit "^1.0.0"
 322 | 
 323 | color-convert@^1.9.0:
 324 |   version "1.9.3"
 325 |   resolved "https://registry.yarnpkg.com/color-convert/-/color-convert-1.9.3.tgz#bb71850690e1f136567de629d2d5471deda4c1e8"
 326 |   integrity sha512-QfAUtd+vFdAtFQcC8CCyYt1fYWxSqAiK2cSD6zDB8N3cpsEBAvRxp9zOGg6G/SHHJYAT88/az/IuDGALsNVbGg==
 327 |   dependencies:
 328 |     color-name "1.1.3"
 329 | 
 330 | color-name@1.1.3:
 331 |   version "1.1.3"
 332 |   resolved "https://registry.yarnpkg.com/color-name/-/color-name-1.1.3.tgz#a7d0558bd89c42f795dd42328f740831ca53bc25"
 333 |   integrity sha1-p9BVi9icQveV3UIyj3QIMcpTvCU=
 334 | 
 335 | command-line-args@^4.0.2:
 336 |   version "4.0.7"
 337 |   resolved "https://registry.yarnpkg.com/command-line-args/-/command-line-args-4.0.7.tgz#f8d1916ecb90e9e121eda6428e41300bfb64cc46"
 338 |   integrity sha512-aUdPvQRAyBvQd2n7jXcsMDz68ckBJELXNzBybCHOibUWEg0mWTnaYCSRU8h9R+aNRSvDihJtssSRCiDRpLaezA==
 339 |   dependencies:
 340 |     array-back "^2.0.0"
 341 |     find-replace "^1.0.3"
 342 |     typical "^2.6.1"
 343 | 
 344 | command-line-commands@^2.0.0:
 345 |   version "2.0.1"
 346 |   resolved "https://registry.yarnpkg.com/command-line-commands/-/command-line-commands-2.0.1.tgz#c58aa13dc78c06038ed67077e57ad09a6f858f46"
 347 |   integrity sha512-m8c2p1DrNd2ruIAggxd/y6DgygQayf6r8RHwchhXryaLF8I6koYjoYroVP+emeROE9DXN5b9sP1Gh+WtvTTdtQ==
 348 |   dependencies:
 349 |     array-back "^2.0.0"
 350 | 
 351 | command-line-usage@^4.0.0:
 352 |   version "4.1.0"
 353 |   resolved "https://registry.yarnpkg.com/command-line-usage/-/command-line-usage-4.1.0.tgz#a6b3b2e2703b4dcf8bd46ae19e118a9a52972882"
 354 |   integrity sha512-MxS8Ad995KpdAC0Jopo/ovGIroV/m0KHwzKfXxKag6FHOkGsH8/lv5yjgablcRxCJJC0oJeUMuO/gmaq+Wq46g==
 355 |   dependencies:
 356 |     ansi-escape-sequences "^4.0.0"
 357 |     array-back "^2.0.0"
 358 |     table-layout "^0.4.2"
 359 |     typical "^2.6.1"
 360 | 
 361 | commander@~2.20.0:
 362 |   version "2.20.0"
 363 |   resolved "https://registry.yarnpkg.com/commander/-/commander-2.20.0.tgz#d58bb2b5c1ee8f87b0d340027e9e94e222c5a422"
 364 |   integrity sha512-7j2y+40w61zy6YC2iRNpUe/NwhNyoXrYpHMrSunaMG64nRnaf96zO/KMQR4OyN/UnE5KLyEBnKHd4aG3rskjpQ==
 365 | 
 366 | component-emitter@^1.2.1:
 367 |   version "1.3.0"
 368 |   resolved "https://registry.yarnpkg.com/component-emitter/-/component-emitter-1.3.0.tgz#16e4070fba8ae29b679f2215853ee181ab2eabc0"
 369 |   integrity sha512-Rd3se6QB+sO1TwqZjscQrurpEPIfO0/yYnSin6Q/rD3mOutHvUrCAhJub3r90uNb+SESBuE0QYoB90YdfatsRg==
 370 | 
 371 | concat-map@0.0.1:
 372 |   version "0.0.1"
 373 |   resolved "https://registry.yarnpkg.com/concat-map/-/concat-map-0.0.1.tgz#d8a96bd77fd68df7793a73036a3ba0d5405d477b"
 374 |   integrity sha1-2Klr13/Wjfd5OnMDajug1UBdR3s=
 375 | 
 376 | copy-descriptor@^0.1.0:
 377 |   version "0.1.1"
 378 |   resolved "https://registry.yarnpkg.com/copy-descriptor/-/copy-descriptor-0.1.1.tgz#676f6eb3c39997c2ee1ac3a924fd6124748f578d"
 379 |   integrity sha1-Z29us8OZl8LuGsOpJP1hJHSPV40=
 380 | 
 381 | debug@3.2.6:
 382 |   version "3.2.6"
 383 |   resolved "https://registry.yarnpkg.com/debug/-/debug-3.2.6.tgz#e83d17de16d8a7efb7717edbe5fb10135eee629b"
 384 |   integrity sha512-mel+jf7nrtEl5Pn1Qx46zARXKDpBbvzezse7p7LqINmdoIk8PYP5SySaxEmYv6TZ0JyEKA1hsCId6DIhgITtWQ==
 385 |   dependencies:
 386 |     ms "^2.1.1"
 387 | 
 388 | debug@^2.2.0, debug@^2.3.3:
 389 |   version "2.6.9"
 390 |   resolved "https://registry.yarnpkg.com/debug/-/debug-2.6.9.tgz#5d128515df134ff327e90a4c93f4e077a536341f"
 391 |   integrity sha512-bC7ElrdJaJnPbAP+1EotYvqZsb3ecl5wi6Bfi6BJTUcNowp6cvspg0jXznRTKDjm/E7AdgFBVeAPVMNcKGsHMA==
 392 |   dependencies:
 393 |     ms "2.0.0"
 394 | 
 395 | decamelize@^1.2.0:
 396 |   version "1.2.0"
 397 |   resolved "https://registry.yarnpkg.com/decamelize/-/decamelize-1.2.0.tgz#f6534d15148269b20352e7bee26f501f9a191290"
 398 |   integrity sha1-9lNNFRSCabIDUue+4m9QH5oZEpA=
 399 | 
 400 | decode-uri-component@^0.2.0:
 401 |   version "0.2.0"
 402 |   resolved "https://registry.yarnpkg.com/decode-uri-component/-/decode-uri-component-0.2.0.tgz#eb3913333458775cb84cd1a1fae062106bb87545"
 403 |   integrity sha1-6zkTMzRYd1y4TNGh+uBiEGu4dUU=
 404 | 
 405 | deep-extend@~0.6.0:
 406 |   version "0.6.0"
 407 |   resolved "https://registry.yarnpkg.com/deep-extend/-/deep-extend-0.6.0.tgz#c4fa7c95404a17a9c3e8ca7e1537312b736330ac"
 408 |   integrity sha512-LOHxIOaPYdHlJRtCQfDIVZtfw/ufM8+rVj649RIHzcm/vGwQRXFt6OPqIFWsm2XEMrNIEtWR64sY1LEKD2vAOA==
 409 | 
 410 | define-properties@^1.1.2:
 411 |   version "1.1.3"
 412 |   resolved "https://registry.yarnpkg.com/define-properties/-/define-properties-1.1.3.tgz#cf88da6cbee26fe6db7094f61d870cbd84cee9f1"
 413 |   integrity sha512-3MqfYKj2lLzdMSf8ZIZE/V+Zuy+BgD6f164e8K2w7dgnpKArBDerGYpM46IYYcjnkdPNMjPk9A6VFB8+3SKlXQ==
 414 |   dependencies:
 415 |     object-keys "^1.0.12"
 416 | 
 417 | define-property@^0.2.5:
 418 |   version "0.2.5"
 419 |   resolved "https://registry.yarnpkg.com/define-property/-/define-property-0.2.5.tgz#c35b1ef918ec3c990f9a5bc57be04aacec5c8116"
 420 |   integrity sha1-w1se+RjsPJkPmlvFe+BKrOxcgRY=
 421 |   dependencies:
 422 |     is-descriptor "^0.1.0"
 423 | 
 424 | define-property@^1.0.0:
 425 |   version "1.0.0"
 426 |   resolved "https://registry.yarnpkg.com/define-property/-/define-property-1.0.0.tgz#769ebaaf3f4a63aad3af9e8d304c9bbe79bfb0e6"
 427 |   integrity sha1-dp66rz9KY6rTr56NMEybvnm/sOY=
 428 |   dependencies:
 429 |     is-descriptor "^1.0.0"
 430 | 
 431 | define-property@^2.0.2:
 432 |   version "2.0.2"
 433 |   resolved "https://registry.yarnpkg.com/define-property/-/define-property-2.0.2.tgz#d459689e8d654ba77e02a817f8710d702cb16e9d"
 434 |   integrity sha512-jwK2UV4cnPpbcG7+VRARKTZPUWowwXA8bzH5NP6ud0oeAxyYPuGZUAC7hMugpCdz4BeSZl2Dl9k66CHJ/46ZYQ==
 435 |   dependencies:
 436 |     is-descriptor "^1.0.2"
 437 |     isobject "^3.0.1"
 438 | 
 439 | diff-sequences@^24.9.0:
 440 |   version "24.9.0"
 441 |   resolved "https://registry.yarnpkg.com/diff-sequences/-/diff-sequences-24.9.0.tgz#5715d6244e2aa65f48bba0bc972db0b0b11e95b5"
 442 |   integrity sha512-Dj6Wk3tWyTE+Fo1rW8v0Xhwk80um6yFYKbuAxc9c3EZxIHFDYwbi34Uk42u1CdnIiVorvt4RmlSDjIPyzGC2ew==
 443 | 
 444 | diff@3.5.0:
 445 |   version "3.5.0"
 446 |   resolved "https://registry.yarnpkg.com/diff/-/diff-3.5.0.tgz#800c0dd1e0a8bfbc95835c202ad220fe317e5a12"
 447 |   integrity sha512-A46qtFgd+g7pDZinpnwiRJtxbC1hpgf0uzP3iG89scHk0AUC7A1TGxf5OiiOUv/JMZR8GOt8hL900hV0bOy5xA==
 448 | 
 449 | emoji-regex@^7.0.1:
 450 |   version "7.0.3"
 451 |   resolved "https://registry.yarnpkg.com/emoji-regex/-/emoji-regex-7.0.3.tgz#933a04052860c85e83c122479c4748a8e4c72156"
 452 |   integrity sha512-CwBLREIQ7LvYFB0WyRvwhq5N5qPhc6PMjD6bYggFlI5YyDgl+0vxq5VHbMOFqLg7hfWzmu8T5Z1QofhmTIhItA==
 453 | 
 454 | es-abstract@^1.5.1:
 455 |   version "1.13.0"
 456 |   resolved "https://registry.yarnpkg.com/es-abstract/-/es-abstract-1.13.0.tgz#ac86145fdd5099d8dd49558ccba2eaf9b88e24e9"
 457 |   integrity sha512-vDZfg/ykNxQVwup/8E1BZhVzFfBxs9NqMzGcvIJrqg5k2/5Za2bWo40dK2J1pgLngZ7c+Shh8lwYtLGyrwPutg==
 458 |   dependencies:
 459 |     es-to-primitive "^1.2.0"
 460 |     function-bind "^1.1.1"
 461 |     has "^1.0.3"
 462 |     is-callable "^1.1.4"
 463 |     is-regex "^1.0.4"
 464 |     object-keys "^1.0.12"
 465 | 
 466 | es-to-primitive@^1.2.0:
 467 |   version "1.2.0"
 468 |   resolved "https://registry.yarnpkg.com/es-to-primitive/-/es-to-primitive-1.2.0.tgz#edf72478033456e8dda8ef09e00ad9650707f377"
 469 |   integrity sha512-qZryBOJjV//LaxLTV6UC//WewneB3LcXOL9NP++ozKVXsIIIpm/2c13UDiD9Jp2eThsecw9m3jPqDwTyobcdbg==
 470 |   dependencies:
 471 |     is-callable "^1.1.4"
 472 |     is-date-object "^1.0.1"
 473 |     is-symbol "^1.0.2"
 474 | 
 475 | escape-string-regexp@1.0.5, escape-string-regexp@^1.0.5:
 476 |   version "1.0.5"
 477 |   resolved "https://registry.yarnpkg.com/escape-string-regexp/-/escape-string-regexp-1.0.5.tgz#1b61c0562190a8dff6ae3bb2cf0200ca130b86d4"
 478 |   integrity sha1-G2HAViGQqN/2rjuyzwIAyhMLhtQ=
 479 | 
 480 | esprima@^4.0.0:
 481 |   version "4.0.1"
 482 |   resolved "https://registry.yarnpkg.com/esprima/-/esprima-4.0.1.tgz#13b04cdb3e6c5d19df91ab6987a8695619b0aa71"
 483 |   integrity sha512-eGuFFw7Upda+g4p+QHvnW0RyTX/SVeJBDM/gCtMARO0cLuT2HcEKnTPvhjV6aGeqrCB/sbNop0Kszm0jsaWU4A==
 484 | 
 485 | esutils@^2.0.2:
 486 |   version "2.0.3"
 487 |   resolved "https://registry.yarnpkg.com/esutils/-/esutils-2.0.3.tgz#74d2eb4de0b8da1293711910d50775b9b710ef64"
 488 |   integrity sha512-kVscqXk4OCp68SZ0dkgEKVi6/8ij300KBWTJq32P/dYeWTSwK41WyTxalN1eRmA5Z9UU/LX9D7FWSmV9SAYx6g==
 489 | 
 490 | expand-brackets@^2.1.4:
 491 |   version "2.1.4"
 492 |   resolved "https://registry.yarnpkg.com/expand-brackets/-/expand-brackets-2.1.4.tgz#b77735e315ce30f6b6eff0f83b04151a22449622"
 493 |   integrity sha1-t3c14xXOMPa27/D4OwQVGiJEliI=
 494 |   dependencies:
 495 |     debug "^2.3.3"
 496 |     define-property "^0.2.5"
 497 |     extend-shallow "^2.0.1"
 498 |     posix-character-classes "^0.1.0"
 499 |     regex-not "^1.0.0"
 500 |     snapdragon "^0.8.1"
 501 |     to-regex "^3.0.1"
 502 | 
 503 | expect@^24.9.0:
 504 |   version "24.9.0"
 505 |   resolved "https://registry.yarnpkg.com/expect/-/expect-24.9.0.tgz#b75165b4817074fa4a157794f46fe9f1ba15b6ca"
 506 |   integrity sha512-wvVAx8XIol3Z5m9zvZXiyZOQ+sRJqNTIm6sGjdWlaZIeupQGO3WbYI+15D/AmEwZywL6wtJkbAbJtzkOfBuR0Q==
 507 |   dependencies:
 508 |     "@jest/types" "^24.9.0"
 509 |     ansi-styles "^3.2.0"
 510 |     jest-get-type "^24.9.0"
 511 |     jest-matcher-utils "^24.9.0"
 512 |     jest-message-util "^24.9.0"
 513 |     jest-regex-util "^24.9.0"
 514 | 
 515 | extend-shallow@^2.0.1:
 516 |   version "2.0.1"
 517 |   resolved "https://registry.yarnpkg.com/extend-shallow/-/extend-shallow-2.0.1.tgz#51af7d614ad9a9f610ea1bafbb989d6b1c56890f"
 518 |   integrity sha1-Ua99YUrZqfYQ6huvu5idaxxWiQ8=
 519 |   dependencies:
 520 |     is-extendable "^0.1.0"
 521 | 
 522 | extend-shallow@^3.0.0, extend-shallow@^3.0.2:
 523 |   version "3.0.2"
 524 |   resolved "https://registry.yarnpkg.com/extend-shallow/-/extend-shallow-3.0.2.tgz#26a71aaf073b39fb2127172746131c2704028db8"
 525 |   integrity sha1-Jqcarwc7OfshJxcnRhMcJwQCjbg=
 526 |   dependencies:
 527 |     assign-symbols "^1.0.0"
 528 |     is-extendable "^1.0.1"
 529 | 
 530 | external-editor@^2.0.4:
 531 |   version "2.2.0"
 532 |   resolved "https://registry.yarnpkg.com/external-editor/-/external-editor-2.2.0.tgz#045511cfd8d133f3846673d1047c154e214ad3d5"
 533 |   integrity sha512-bSn6gvGxKt+b7+6TKEv1ZycHleA7aHhRHyAqJyp5pbUFuYYNIzpZnQDk7AsYckyWdEnTeAnay0aCy2aV6iTk9A==
 534 |   dependencies:
 535 |     chardet "^0.4.0"
 536 |     iconv-lite "^0.4.17"
 537 |     tmp "^0.0.33"
 538 | 
 539 | extglob@^2.0.4:
 540 |   version "2.0.4"
 541 |   resolved "https://registry.yarnpkg.com/extglob/-/extglob-2.0.4.tgz#ad00fe4dc612a9232e8718711dc5cb5ab0285543"
 542 |   integrity sha512-Nmb6QXkELsuBr24CJSkilo6UHHgbekK5UiZgfE6UHD3Eb27YC6oD+bhcT+tJ6cl8dmsgdQxnWlcry8ksBIBLpw==
 543 |   dependencies:
 544 |     array-unique "^0.3.2"
 545 |     define-property "^1.0.0"
 546 |     expand-brackets "^2.1.4"
 547 |     extend-shallow "^2.0.1"
 548 |     fragment-cache "^0.2.1"
 549 |     regex-not "^1.0.0"
 550 |     snapdragon "^0.8.1"
 551 |     to-regex "^3.0.1"
 552 | 
 553 | figures@^2.0.0:
 554 |   version "2.0.0"
 555 |   resolved "https://registry.yarnpkg.com/figures/-/figures-2.0.0.tgz#3ab1a2d2a62c8bfb431a0c94cb797a2fce27c962"
 556 |   integrity sha1-OrGi0qYsi/tDGgyUy3l6L84nyWI=
 557 |   dependencies:
 558 |     escape-string-regexp "^1.0.5"
 559 | 
 560 | fill-range@^4.0.0:
 561 |   version "4.0.0"
 562 |   resolved "https://registry.yarnpkg.com/fill-range/-/fill-range-4.0.0.tgz#d544811d428f98eb06a63dc402d2403c328c38f7"
 563 |   integrity sha1-1USBHUKPmOsGpj3EAtJAPDKMOPc=
 564 |   dependencies:
 565 |     extend-shallow "^2.0.1"
 566 |     is-number "^3.0.0"
 567 |     repeat-string "^1.6.1"
 568 |     to-regex-range "^2.1.0"
 569 | 
 570 | find-replace@^1.0.3:
 571 |   version "1.0.3"
 572 |   resolved "https://registry.yarnpkg.com/find-replace/-/find-replace-1.0.3.tgz#b88e7364d2d9c959559f388c66670d6130441fa0"
 573 |   integrity sha1-uI5zZNLZyVlVnziMZmcNYTBEH6A=
 574 |   dependencies:
 575 |     array-back "^1.0.4"
 576 |     test-value "^2.1.0"
 577 | 
 578 | find-up@3.0.0, find-up@^3.0.0:
 579 |   version "3.0.0"
 580 |   resolved "https://registry.yarnpkg.com/find-up/-/find-up-3.0.0.tgz#49169f1d7993430646da61ecc5ae355c21c97b73"
 581 |   integrity sha512-1yD6RmLI1XBfxugvORwlck6f75tYL+iR0jqwsOrOxMZyGYqUuDhJ0l4AXdO1iX/FTs9cBAMEk1gWSEx1kSbylg==
 582 |   dependencies:
 583 |     locate-path "^3.0.0"
 584 | 
 585 | flat@^4.1.0:
 586 |   version "4.1.0"
 587 |   resolved "https://registry.yarnpkg.com/flat/-/flat-4.1.0.tgz#090bec8b05e39cba309747f1d588f04dbaf98db2"
 588 |   integrity sha512-Px/TiLIznH7gEDlPXcUD4KnBusa6kR6ayRUVcnEAbreRIuhkqow/mun59BuRXwoYk7ZQOLW1ZM05ilIvK38hFw==
 589 |   dependencies:
 590 |     is-buffer "~2.0.3"
 591 | 
 592 | for-in@^1.0.2:
 593 |   version "1.0.2"
 594 |   resolved "https://registry.yarnpkg.com/for-in/-/for-in-1.0.2.tgz#81068d295a8142ec0ac726c6e2200c30fb6d5e80"
 595 |   integrity sha1-gQaNKVqBQuwKxybG4iAMMPttXoA=
 596 | 
 597 | fragment-cache@^0.2.1:
 598 |   version "0.2.1"
 599 |   resolved "https://registry.yarnpkg.com/fragment-cache/-/fragment-cache-0.2.1.tgz#4290fad27f13e89be7f33799c6bc5a0abfff0d19"
 600 |   integrity sha1-QpD60n8T6Jvn8zeZxrxaCr//DRk=
 601 |   dependencies:
 602 |     map-cache "^0.2.2"
 603 | 
 604 | fs.realpath@^1.0.0:
 605 |   version "1.0.0"
 606 |   resolved "https://registry.yarnpkg.com/fs.realpath/-/fs.realpath-1.0.0.tgz#1504ad2523158caa40db4a2787cb01411994ea4f"
 607 |   integrity sha1-FQStJSMVjKpA20onh8sBQRmU6k8=
 608 | 
 609 | function-bind@^1.1.1:
 610 |   version "1.1.1"
 611 |   resolved "https://registry.yarnpkg.com/function-bind/-/function-bind-1.1.1.tgz#a56899d3ea3c9bab874bb9773b7c5ede92f4895d"
 612 |   integrity sha512-yIovAzMX49sF8Yl58fSCWJ5svSLuaibPxXQJFLmBObTuCr0Mf1KiPopGM9NiFjiYBCbfaa2Fh6breQ6ANVTI0A==
 613 | 
 614 | get-caller-file@^2.0.1:
 615 |   version "2.0.5"
 616 |   resolved "https://registry.yarnpkg.com/get-caller-file/-/get-caller-file-2.0.5.tgz#4f94412a82db32f36e3b0b9741f8a97feb031f7e"
 617 |   integrity sha512-DyFP3BM/3YHTQOCUL/w0OZHR0lpKeGrxotcHWcqNEdnltqFwXVfhEBQ94eIo34AfQpo0rGki4cyIiftY06h2Fg==
 618 | 
 619 | get-value@^2.0.3, get-value@^2.0.6:
 620 |   version "2.0.6"
 621 |   resolved "https://registry.yarnpkg.com/get-value/-/get-value-2.0.6.tgz#dc15ca1c672387ca76bd37ac0a395ba2042a2c28"
 622 |   integrity sha1-3BXKHGcjh8p2vTesCjlbogQqLCg=
 623 | 
 624 | git-config@0.0.7:
 625 |   version "0.0.7"
 626 |   resolved "https://registry.yarnpkg.com/git-config/-/git-config-0.0.7.tgz#a9c8a3ef07a776c3d72261356d8b727b62202b28"
 627 |   integrity sha1-qcij7wendsPXImE1bYtye2IgKyg=
 628 |   dependencies:
 629 |     iniparser "~1.0.5"
 630 | 
 631 | glob@7.1.3:
 632 |   version "7.1.3"
 633 |   resolved "https://registry.yarnpkg.com/glob/-/glob-7.1.3.tgz#3960832d3f1574108342dafd3a67b332c0969df1"
 634 |   integrity sha512-vcfuiIxogLV4DlGBHIUOwI0IbrJ8HWPc4MU7HzviGeNho/UJDfi6B5p3sHeWIQ0KGIU0Jpxi5ZHxemQfLkkAwQ==
 635 |   dependencies:
 636 |     fs.realpath "^1.0.0"
 637 |     inflight "^1.0.4"
 638 |     inherits "2"
 639 |     minimatch "^3.0.4"
 640 |     once "^1.3.0"
 641 |     path-is-absolute "^1.0.0"
 642 | 
 643 | glob@^7.1.3:
 644 |   version "7.1.4"
 645 |   resolved "https://registry.yarnpkg.com/glob/-/glob-7.1.4.tgz#aa608a2f6c577ad357e1ae5a5c26d9a8d1969255"
 646 |   integrity sha512-hkLPepehmnKk41pUGm3sYxoFs/umurYfYJCerbXEyFIWcAzvpipAgVkBqqT9RBKMGjnq6kMuyYwha6csxbiM1A==
 647 |   dependencies:
 648 |     fs.realpath "^1.0.0"
 649 |     inflight "^1.0.4"
 650 |     inherits "2"
 651 |     minimatch "^3.0.4"
 652 |     once "^1.3.0"
 653 |     path-is-absolute "^1.0.0"
 654 | 
 655 | graceful-fs@^4.1.15:
 656 |   version "4.2.2"
 657 |   resolved "https://registry.yarnpkg.com/graceful-fs/-/graceful-fs-4.2.2.tgz#6f0952605d0140c1cfdb138ed005775b92d67b02"
 658 |   integrity sha512-IItsdsea19BoLC7ELy13q1iJFNmd7ofZH5+X/pJr90/nRoPEX0DJo1dHDbgtYWOhJhcCgMDTOw84RZ72q6lB+Q==
 659 | 
 660 | growl@1.10.5:
 661 |   version "1.10.5"
 662 |   resolved "https://registry.yarnpkg.com/growl/-/growl-1.10.5.tgz#f2735dc2283674fa67478b10181059355c369e5e"
 663 |   integrity sha512-qBr4OuELkhPenW6goKVXiv47US3clb3/IbuWF9KNKEijAy9oeHxU9IgzjvJhHkUzhaj7rOUD7+YGWqUjLp5oSA==
 664 | 
 665 | handlebars@^4.1.0:
 666 |   version "4.1.2"
 667 |   resolved "https://registry.yarnpkg.com/handlebars/-/handlebars-4.1.2.tgz#b6b37c1ced0306b221e094fc7aca3ec23b131b67"
 668 |   integrity sha512-nvfrjqvt9xQ8Z/w0ijewdD/vvWDTOweBUm96NTr66Wfvo1mJenBLwcYmPs3TIBP5ruzYGD7Hx/DaM9RmhroGPw==
 669 |   dependencies:
 670 |     neo-async "^2.6.0"
 671 |     optimist "^0.6.1"
 672 |     source-map "^0.6.1"
 673 |   optionalDependencies:
 674 |     uglify-js "^3.1.4"
 675 | 
 676 | has-flag@^2.0.0:
 677 |   version "2.0.0"
 678 |   resolved "https://registry.yarnpkg.com/has-flag/-/has-flag-2.0.0.tgz#e8207af1cc7b30d446cc70b734b5e8be18f88d51"
 679 |   integrity sha1-6CB68cx7MNRGzHC3NLXovhj4jVE=
 680 | 
 681 | has-flag@^3.0.0:
 682 |   version "3.0.0"
 683 |   resolved "https://registry.yarnpkg.com/has-flag/-/has-flag-3.0.0.tgz#b5d454dc2199ae225699f3467e5a07f3b955bafd"
 684 |   integrity sha1-tdRU3CGZriJWmfNGfloH87lVuv0=
 685 | 
 686 | has-symbols@^1.0.0:
 687 |   version "1.0.0"
 688 |   resolved "https://registry.yarnpkg.com/has-symbols/-/has-symbols-1.0.0.tgz#ba1a8f1af2a0fc39650f5c850367704122063b44"
 689 |   integrity sha1-uhqPGvKg/DllD1yFA2dwQSIGO0Q=
 690 | 
 691 | has-value@^0.3.1:
 692 |   version "0.3.1"
 693 |   resolved "https://registry.yarnpkg.com/has-value/-/has-value-0.3.1.tgz#7b1f58bada62ca827ec0a2078025654845995e1f"
 694 |   integrity sha1-ex9YutpiyoJ+wKIHgCVlSEWZXh8=
 695 |   dependencies:
 696 |     get-value "^2.0.3"
 697 |     has-values "^0.1.4"
 698 |     isobject "^2.0.0"
 699 | 
 700 | has-value@^1.0.0:
 701 |   version "1.0.0"
 702 |   resolved "https://registry.yarnpkg.com/has-value/-/has-value-1.0.0.tgz#18b281da585b1c5c51def24c930ed29a0be6b177"
 703 |   integrity sha1-GLKB2lhbHFxR3vJMkw7SmgvmsXc=
 704 |   dependencies:
 705 |     get-value "^2.0.6"
 706 |     has-values "^1.0.0"
 707 |     isobject "^3.0.0"
 708 | 
 709 | has-values@^0.1.4:
 710 |   version "0.1.4"
 711 |   resolved "https://registry.yarnpkg.com/has-values/-/has-values-0.1.4.tgz#6d61de95d91dfca9b9a02089ad384bff8f62b771"
 712 |   integrity sha1-bWHeldkd/Km5oCCJrThL/49it3E=
 713 | 
 714 | has-values@^1.0.0:
 715 |   version "1.0.0"
 716 |   resolved "https://registry.yarnpkg.com/has-values/-/has-values-1.0.0.tgz#95b0b63fec2146619a6fe57fe75628d5a39efe4f"
 717 |   integrity sha1-lbC2P+whRmGab+V/51Yo1aOe/k8=
 718 |   dependencies:
 719 |     is-number "^3.0.0"
 720 |     kind-of "^4.0.0"
 721 | 
 722 | has@^1.0.1, has@^1.0.3:
 723 |   version "1.0.3"
 724 |   resolved "https://registry.yarnpkg.com/has/-/has-1.0.3.tgz#722d7cbfc1f6aa8241f16dd814e011e1f41e8796"
 725 |   integrity sha512-f2dvO0VU6Oej7RkWJGrehjbzMAjFp5/VKPp5tTpWIV4JHHZK1/BxbFRtf/siA2SWTe09caDmVtYYzWEIbBS4zw==
 726 |   dependencies:
 727 |     function-bind "^1.1.1"
 728 | 
 729 | he@1.2.0:
 730 |   version "1.2.0"
 731 |   resolved "https://registry.yarnpkg.com/he/-/he-1.2.0.tgz#84ae65fa7eafb165fddb61566ae14baf05664f0f"
 732 |   integrity sha512-F/1DnUGPopORZi0ni+CvrCgHQ5FyEAHRLSApuYWMmrbSwoN2Mn/7k+Gl38gJnR7yyDZk6WLXwiGod1JOWNDKGw==
 733 | 
 734 | iconv-lite@^0.4.17:
 735 |   version "0.4.24"
 736 |   resolved "https://registry.yarnpkg.com/iconv-lite/-/iconv-lite-0.4.24.tgz#2022b4b25fbddc21d2f524974a474aafe733908b"
 737 |   integrity sha512-v3MXnZAcvnywkTUEZomIActle7RXXeedOR31wwl7VlyoXO4Qi9arvSenNQWne1TcRwhCL1HwLI21bEqdpj8/rA==
 738 |   dependencies:
 739 |     safer-buffer ">= 2.1.2 < 3"
 740 | 
 741 | inflight@^1.0.4:
 742 |   version "1.0.6"
 743 |   resolved "https://registry.yarnpkg.com/inflight/-/inflight-1.0.6.tgz#49bd6331d7d02d0c09bc910a1075ba8165b56df9"
 744 |   integrity sha1-Sb1jMdfQLQwJvJEKEHW6gWW1bfk=
 745 |   dependencies:
 746 |     once "^1.3.0"
 747 |     wrappy "1"
 748 | 
 749 | inherits@2:
 750 |   version "2.0.4"
 751 |   resolved "https://registry.yarnpkg.com/inherits/-/inherits-2.0.4.tgz#0fa2c64f932917c3433a0ded55363aae37416b7c"
 752 |   integrity sha512-k/vGaX4/Yla3WzyMCvTQOXYeIHvqOKtnqBduzTHpzpQZzAskKMhZ2K+EnBiSM9zGSoIFeMpXKxa4dYeZIQqewQ==
 753 | 
 754 | iniparser@~1.0.5:
 755 |   version "1.0.5"
 756 |   resolved "https://registry.yarnpkg.com/iniparser/-/iniparser-1.0.5.tgz#836d6befe6dfbfcee0bccf1cf9f2acc7027f783d"
 757 |   integrity sha1-g21r7+bfv87gvM8c+fKsxwJ/eD0=
 758 | 
 759 | inquirer@^3.0.6:
 760 |   version "3.3.0"
 761 |   resolved "https://registry.yarnpkg.com/inquirer/-/inquirer-3.3.0.tgz#9dd2f2ad765dcab1ff0443b491442a20ba227dc9"
 762 |   integrity sha512-h+xtnyk4EwKvFWHrUYsWErEVR+igKtLdchu+o0Z1RL7VU/jVMFbYir2bp6bAj8efFNxWqHX0dIss6fJQ+/+qeQ==
 763 |   dependencies:
 764 |     ansi-escapes "^3.0.0"
 765 |     chalk "^2.0.0"
 766 |     cli-cursor "^2.1.0"
 767 |     cli-width "^2.0.0"
 768 |     external-editor "^2.0.4"
 769 |     figures "^2.0.0"
 770 |     lodash "^4.3.0"
 771 |     mute-stream "0.0.7"
 772 |     run-async "^2.2.0"
 773 |     rx-lite "^4.0.8"
 774 |     rx-lite-aggregates "^4.0.8"
 775 |     string-width "^2.1.0"
 776 |     strip-ansi "^4.0.0"
 777 |     through "^2.3.6"
 778 | 
 779 | is-accessor-descriptor@^0.1.6:
 780 |   version "0.1.6"
 781 |   resolved "https://registry.yarnpkg.com/is-accessor-descriptor/-/is-accessor-descriptor-0.1.6.tgz#a9e12cb3ae8d876727eeef3843f8a0897b5c98d6"
 782 |   integrity sha1-qeEss66Nh2cn7u84Q/igiXtcmNY=
 783 |   dependencies:
 784 |     kind-of "^3.0.2"
 785 | 
 786 | is-accessor-descriptor@^1.0.0:
 787 |   version "1.0.0"
 788 |   resolved "https://registry.yarnpkg.com/is-accessor-descriptor/-/is-accessor-descriptor-1.0.0.tgz#169c2f6d3df1f992618072365c9b0ea1f6878656"
 789 |   integrity sha512-m5hnHTkcVsPfqx3AKlyttIPb7J+XykHvJP2B9bZDjlhLIoEq4XoK64Vg7boZlVWYK6LUY94dYPEE7Lh0ZkZKcQ==
 790 |   dependencies:
 791 |     kind-of "^6.0.0"
 792 | 
 793 | is-buffer@^1.1.5:
 794 |   version "1.1.6"
 795 |   resolved "https://registry.yarnpkg.com/is-buffer/-/is-buffer-1.1.6.tgz#efaa2ea9daa0d7ab2ea13a97b2b8ad51fefbe8be"
 796 |   integrity sha512-NcdALwpXkTm5Zvvbk7owOUSvVvBKDgKP5/ewfXEznmQFfs4ZRmanOeKBTjRVjka3QFoN6XJ+9F3USqfHqTaU5w==
 797 | 
 798 | is-buffer@~2.0.3:
 799 |   version "2.0.4"
 800 |   resolved "https://registry.yarnpkg.com/is-buffer/-/is-buffer-2.0.4.tgz#3e572f23c8411a5cfd9557c849e3665e0b290623"
 801 |   integrity sha512-Kq1rokWXOPXWuaMAqZiJW4XxsmD9zGx9q4aePabbn3qCRGedtH7Cm+zV8WETitMfu1wdh+Rvd6w5egwSngUX2A==
 802 | 
 803 | is-callable@^1.1.4:
 804 |   version "1.1.4"
 805 |   resolved "https://registry.yarnpkg.com/is-callable/-/is-callable-1.1.4.tgz#1e1adf219e1eeb684d691f9d6a05ff0d30a24d75"
 806 |   integrity sha512-r5p9sxJjYnArLjObpjA4xu5EKI3CuKHkJXMhT7kwbpUyIFD1n5PMAsoPvWnvtZiNz7LjkYDRZhd7FlI0eMijEA==
 807 | 
 808 | is-data-descriptor@^0.1.4:
 809 |   version "0.1.4"
 810 |   resolved "https://registry.yarnpkg.com/is-data-descriptor/-/is-data-descriptor-0.1.4.tgz#0b5ee648388e2c860282e793f1856fec3f301b56"
 811 |   integrity sha1-C17mSDiOLIYCgueT8YVv7D8wG1Y=
 812 |   dependencies:
 813 |     kind-of "^3.0.2"
 814 | 
 815 | is-data-descriptor@^1.0.0:
 816 |   version "1.0.0"
 817 |   resolved "https://registry.yarnpkg.com/is-data-descriptor/-/is-data-descriptor-1.0.0.tgz#d84876321d0e7add03990406abbbbd36ba9268c7"
 818 |   integrity sha512-jbRXy1FmtAoCjQkVmIVYwuuqDFUbaOeDjmed1tOGPrsMhtJA4rD9tkgA0F1qJ3gRFRXcHYVkdeaP50Q5rE/jLQ==
 819 |   dependencies:
 820 |     kind-of "^6.0.0"
 821 | 
 822 | is-date-object@^1.0.1:
 823 |   version "1.0.1"
 824 |   resolved "https://registry.yarnpkg.com/is-date-object/-/is-date-object-1.0.1.tgz#9aa20eb6aeebbff77fbd33e74ca01b33581d3a16"
 825 |   integrity sha1-mqIOtq7rv/d/vTPnTKAbM1gdOhY=
 826 | 
 827 | is-descriptor@^0.1.0:
 828 |   version "0.1.6"
 829 |   resolved "https://registry.yarnpkg.com/is-descriptor/-/is-descriptor-0.1.6.tgz#366d8240dde487ca51823b1ab9f07a10a78251ca"
 830 |   integrity sha512-avDYr0SB3DwO9zsMov0gKCESFYqCnE4hq/4z3TdUlukEy5t9C0YRq7HLrsN52NAcqXKaepeCD0n+B0arnVG3Hg==
 831 |   dependencies:
 832 |     is-accessor-descriptor "^0.1.6"
 833 |     is-data-descriptor "^0.1.4"
 834 |     kind-of "^5.0.0"
 835 | 
 836 | is-descriptor@^1.0.0, is-descriptor@^1.0.2:
 837 |   version "1.0.2"
 838 |   resolved "https://registry.yarnpkg.com/is-descriptor/-/is-descriptor-1.0.2.tgz#3b159746a66604b04f8c81524ba365c5f14d86ec"
 839 |   integrity sha512-2eis5WqQGV7peooDyLmNEPUrps9+SXX5c9pL3xEB+4e9HnGuDa7mB7kHxHw4CbqS9k1T2hOH3miL8n8WtiYVtg==
 840 |   dependencies:
 841 |     is-accessor-descriptor "^1.0.0"
 842 |     is-data-descriptor "^1.0.0"
 843 |     kind-of "^6.0.2"
 844 | 
 845 | is-extendable@^0.1.0, is-extendable@^0.1.1:
 846 |   version "0.1.1"
 847 |   resolved "https://registry.yarnpkg.com/is-extendable/-/is-extendable-0.1.1.tgz#62b110e289a471418e3ec36a617d472e301dfc89"
 848 |   integrity sha1-YrEQ4omkcUGOPsNqYX1HLjAd/Ik=
 849 | 
 850 | is-extendable@^1.0.1:
 851 |   version "1.0.1"
 852 |   resolved "https://registry.yarnpkg.com/is-extendable/-/is-extendable-1.0.1.tgz#a7470f9e426733d81bd81e1155264e3a3507cab4"
 853 |   integrity sha512-arnXMxT1hhoKo9k1LZdmlNyJdDDfy2v0fXjFlmok4+i8ul/6WlbVge9bhM74OpNPQPMGUToDtz+KXa1PneJxOA==
 854 |   dependencies:
 855 |     is-plain-object "^2.0.4"
 856 | 
 857 | is-fullwidth-code-point@^2.0.0:
 858 |   version "2.0.0"
 859 |   resolved "https://registry.yarnpkg.com/is-fullwidth-code-point/-/is-fullwidth-code-point-2.0.0.tgz#a3b30a5c4f199183167aaab93beefae3ddfb654f"
 860 |   integrity sha1-o7MKXE8ZkYMWeqq5O+764937ZU8=
 861 | 
 862 | is-number@^3.0.0:
 863 |   version "3.0.0"
 864 |   resolved "https://registry.yarnpkg.com/is-number/-/is-number-3.0.0.tgz#24fd6201a4782cf50561c810276afc7d12d71195"
 865 |   integrity sha1-JP1iAaR4LPUFYcgQJ2r8fRLXEZU=
 866 |   dependencies:
 867 |     kind-of "^3.0.2"
 868 | 
 869 | is-plain-object@^2.0.3, is-plain-object@^2.0.4:
 870 |   version "2.0.4"
 871 |   resolved "https://registry.yarnpkg.com/is-plain-object/-/is-plain-object-2.0.4.tgz#2c163b3fafb1b606d9d17928f05c2a1c38e07677"
 872 |   integrity sha512-h5PpgXkWitc38BBMYawTYMWJHFZJVnBquFE57xFpjB8pJFiF6gZ+bU+WyI/yqXiFR5mdLsgYNaPe8uao6Uv9Og==
 873 |   dependencies:
 874 |     isobject "^3.0.1"
 875 | 
 876 | is-promise@^2.1.0:
 877 |   version "2.1.0"
 878 |   resolved "https://registry.yarnpkg.com/is-promise/-/is-promise-2.1.0.tgz#79a2a9ece7f096e80f36d2b2f3bc16c1ff4bf3fa"
 879 |   integrity sha1-eaKp7OfwlugPNtKy87wWwf9L8/o=
 880 | 
 881 | is-regex@^1.0.4:
 882 |   version "1.0.4"
 883 |   resolved "https://registry.yarnpkg.com/is-regex/-/is-regex-1.0.4.tgz#5517489b547091b0930e095654ced25ee97e9491"
 884 |   integrity sha1-VRdIm1RwkbCTDglWVM7SXul+lJE=
 885 |   dependencies:
 886 |     has "^1.0.1"
 887 | 
 888 | is-symbol@^1.0.2:
 889 |   version "1.0.2"
 890 |   resolved "https://registry.yarnpkg.com/is-symbol/-/is-symbol-1.0.2.tgz#a055f6ae57192caee329e7a860118b497a950f38"
 891 |   integrity sha512-HS8bZ9ox60yCJLH9snBpIwv9pYUAkcuLhSA1oero1UB5y9aiQpRA8y2ex945AOtCZL1lJDeIk3G5LthswI46Lw==
 892 |   dependencies:
 893 |     has-symbols "^1.0.0"
 894 | 
 895 | is-windows@^1.0.2:
 896 |   version "1.0.2"
 897 |   resolved "https://registry.yarnpkg.com/is-windows/-/is-windows-1.0.2.tgz#d1850eb9791ecd18e6182ce12a30f396634bb19d"
 898 |   integrity sha512-eXK1UInq2bPmjyX6e3VHIzMLobc4J94i4AWn+Hpq3OU5KkrRC96OAcR3PRJ/pGu6m8TRnBHP9dkXQVsT/COVIA==
 899 | 
 900 | isarray@1.0.0:
 901 |   version "1.0.0"
 902 |   resolved "https://registry.yarnpkg.com/isarray/-/isarray-1.0.0.tgz#bb935d48582cba168c06834957a54a3e07124f11"
 903 |   integrity sha1-u5NdSFgsuhaMBoNJV6VKPgcSTxE=
 904 | 
 905 | isexe@^2.0.0:
 906 |   version "2.0.0"
 907 |   resolved "https://registry.yarnpkg.com/isexe/-/isexe-2.0.0.tgz#e8fbf374dc556ff8947a10dcb0572d633f2cfa10"
 908 |   integrity sha1-6PvzdNxVb/iUehDcsFctYz8s+hA=
 909 | 
 910 | isobject@^2.0.0:
 911 |   version "2.1.0"
 912 |   resolved "https://registry.yarnpkg.com/isobject/-/isobject-2.1.0.tgz#f065561096a3f1da2ef46272f815c840d87e0c89"
 913 |   integrity sha1-8GVWEJaj8dou9GJy+BXIQNh+DIk=
 914 |   dependencies:
 915 |     isarray "1.0.0"
 916 | 
 917 | isobject@^3.0.0, isobject@^3.0.1:
 918 |   version "3.0.1"
 919 |   resolved "https://registry.yarnpkg.com/isobject/-/isobject-3.0.1.tgz#4e431e92b11a9731636aa1f9c8d1ccbcfdab78df"
 920 |   integrity sha1-TkMekrEalzFjaqH5yNHMvP2reN8=
 921 | 
 922 | jest-diff@^24.9.0:
 923 |   version "24.9.0"
 924 |   resolved "https://registry.yarnpkg.com/jest-diff/-/jest-diff-24.9.0.tgz#931b7d0d5778a1baf7452cb816e325e3724055da"
 925 |   integrity sha512-qMfrTs8AdJE2iqrTp0hzh7kTd2PQWrsFyj9tORoKmu32xjPjeE4NyjVRDz8ybYwqS2ik8N4hsIpiVTyFeo2lBQ==
 926 |   dependencies:
 927 |     chalk "^2.0.1"
 928 |     diff-sequences "^24.9.0"
 929 |     jest-get-type "^24.9.0"
 930 |     pretty-format "^24.9.0"
 931 | 
 932 | jest-get-type@^24.9.0:
 933 |   version "24.9.0"
 934 |   resolved "https://registry.yarnpkg.com/jest-get-type/-/jest-get-type-24.9.0.tgz#1684a0c8a50f2e4901b6644ae861f579eed2ef0e"
 935 |   integrity sha512-lUseMzAley4LhIcpSP9Jf+fTrQ4a1yHQwLNeeVa2cEmbCGeoZAtYPOIv8JaxLD/sUpKxetKGP+gsHl8f8TSj8Q==
 936 | 
 937 | jest-matcher-utils@^24.9.0:
 938 |   version "24.9.0"
 939 |   resolved "https://registry.yarnpkg.com/jest-matcher-utils/-/jest-matcher-utils-24.9.0.tgz#f5b3661d5e628dffe6dd65251dfdae0e87c3a073"
 940 |   integrity sha512-OZz2IXsu6eaiMAwe67c1T+5tUAtQyQx27/EMEkbFAGiw52tB9em+uGbzpcgYVpA8wl0hlxKPZxrly4CXU/GjHA==
 941 |   dependencies:
 942 |     chalk "^2.0.1"
 943 |     jest-diff "^24.9.0"
 944 |     jest-get-type "^24.9.0"
 945 |     pretty-format "^24.9.0"
 946 | 
 947 | jest-message-util@^24.9.0:
 948 |   version "24.9.0"
 949 |   resolved "https://registry.yarnpkg.com/jest-message-util/-/jest-message-util-24.9.0.tgz#527f54a1e380f5e202a8d1149b0ec872f43119e3"
 950 |   integrity sha512-oCj8FiZ3U0hTP4aSui87P4L4jC37BtQwUMqk+zk/b11FR19BJDeZsZAvIHutWnmtw7r85UmR3CEWZ0HWU2mAlw==
 951 |   dependencies:
 952 |     "@babel/code-frame" "^7.0.0"
 953 |     "@jest/test-result" "^24.9.0"
 954 |     "@jest/types" "^24.9.0"
 955 |     "@types/stack-utils" "^1.0.1"
 956 |     chalk "^2.0.1"
 957 |     micromatch "^3.1.10"
 958 |     slash "^2.0.0"
 959 |     stack-utils "^1.0.1"
 960 | 
 961 | jest-regex-util@^24.9.0:
 962 |   version "24.9.0"
 963 |   resolved "https://registry.yarnpkg.com/jest-regex-util/-/jest-regex-util-24.9.0.tgz#c13fb3380bde22bf6575432c493ea8fe37965636"
 964 |   integrity sha512-05Cmb6CuxaA+Ys6fjr3PhvV3bGQmO+2p2La4hFbU+W5uOc479f7FdLXUWXw4pYMAhhSZIuKHwSXSu6CsSBAXQA==
 965 | 
 966 | js-tokens@^4.0.0:
 967 |   version "4.0.0"
 968 |   resolved "https://registry.yarnpkg.com/js-tokens/-/js-tokens-4.0.0.tgz#19203fb59991df98e3a287050d4647cdeaf32499"
 969 |   integrity sha512-RdJUflcE3cUzKiMqQgsCu06FPu9UdIJO0beYbPhHN4k6apgJtifcoCtT9bcxOpYBtpD2kCM6Sbzg4CausW/PKQ==
 970 | 
 971 | js-yaml@3.13.1:
 972 |   version "3.13.1"
 973 |   resolved "https://registry.yarnpkg.com/js-yaml/-/js-yaml-3.13.1.tgz#aff151b30bfdfa8e49e05da22e7415e9dfa37847"
 974 |   integrity sha512-YfbcO7jXDdyj0DGxYVSlSeQNHbD7XPWvrVWeVUujrQEoZzWJIRrCPoyk6kL6IAjAG2IolMK4T0hNUe0HOUs5Jw==
 975 |   dependencies:
 976 |     argparse "^1.0.7"
 977 |     esprima "^4.0.0"
 978 | 
 979 | kind-of@^3.0.2, kind-of@^3.0.3, kind-of@^3.2.0:
 980 |   version "3.2.2"
 981 |   resolved "https://registry.yarnpkg.com/kind-of/-/kind-of-3.2.2.tgz#31ea21a734bab9bbb0f32466d893aea51e4a3c64"
 982 |   integrity sha1-MeohpzS6ubuw8yRm2JOupR5KPGQ=
 983 |   dependencies:
 984 |     is-buffer "^1.1.5"
 985 | 
 986 | kind-of@^4.0.0:
 987 |   version "4.0.0"
 988 |   resolved "https://registry.yarnpkg.com/kind-of/-/kind-of-4.0.0.tgz#20813df3d712928b207378691a45066fae72dd57"
 989 |   integrity sha1-IIE989cSkosgc3hpGkUGb65y3Vc=
 990 |   dependencies:
 991 |     is-buffer "^1.1.5"
 992 | 
 993 | kind-of@^5.0.0:
 994 |   version "5.1.0"
 995 |   resolved "https://registry.yarnpkg.com/kind-of/-/kind-of-5.1.0.tgz#729c91e2d857b7a419a1f9aa65685c4c33f5845d"
 996 |   integrity sha512-NGEErnH6F2vUuXDh+OlbcKW7/wOcfdRHaZ7VWtqCztfHri/++YKmP51OdWeGPuqCOba6kk2OTe5d02VmTB80Pw==
 997 | 
 998 | kind-of@^6.0.0, kind-of@^6.0.2:
 999 |   version "6.0.2"
1000 |   resolved "https://registry.yarnpkg.com/kind-of/-/kind-of-6.0.2.tgz#01146b36a6218e64e58f3a8d66de5d7fc6f6d051"
1001 |   integrity sha512-s5kLOcnH0XqDO+FvuaLX8DDjZ18CGFk7VygH40QoKPUQhW4e2rvM0rwUq0t8IQDOwYSeLK01U90OjzBTme2QqA==
1002 | 
1003 | locate-path@^3.0.0:
1004 |   version "3.0.0"
1005 |   resolved "https://registry.yarnpkg.com/locate-path/-/locate-path-3.0.0.tgz#dbec3b3ab759758071b58fe59fc41871af21400e"
1006 |   integrity sha512-7AO748wWnIhNqAuaty2ZWHkQHRSNfPVIsPIfwEOWO22AmaoVrWavlOcMR5nzTLNYvp36X220/maaRsrec1G65A==
1007 |   dependencies:
1008 |     p-locate "^3.0.0"
1009 |     path-exists "^3.0.0"
1010 | 
1011 | lodash.padend@^4.6.1:
1012 |   version "4.6.1"
1013 |   resolved "https://registry.yarnpkg.com/lodash.padend/-/lodash.padend-4.6.1.tgz#53ccba047d06e158d311f45da625f4e49e6f166e"
1014 |   integrity sha1-U8y6BH0G4VjTEfRdpiX05J5vFm4=
1015 | 
1016 | lodash@^4.17.15, lodash@^4.3.0:
1017 |   version "4.17.15"
1018 |   resolved "https://registry.yarnpkg.com/lodash/-/lodash-4.17.15.tgz#b447f6670a0455bbfeedd11392eff330ea097548"
1019 |   integrity sha512-8xOcRHvCjnocdS5cpwXQXVzmmh5e5+saE2QGoeQmbKmRS6J3VQppPOIt0MnmE+4xlZoumy0GPG0D0MVIQbNA1A==
1020 | 
1021 | log-symbols@2.2.0:
1022 |   version "2.2.0"
1023 |   resolved "https://registry.yarnpkg.com/log-symbols/-/log-symbols-2.2.0.tgz#5740e1c5d6f0dfda4ad9323b5332107ef6b4c40a"
1024 |   integrity sha512-VeIAFslyIerEJLXHziedo2basKbMKtTw3vfn5IzG0XTjhAVEJyNHnL2p7vc+wBDSdQuUpNw3M2u6xb9QsAY5Eg==
1025 |   dependencies:
1026 |     chalk "^2.0.1"
1027 | 
1028 | map-cache@^0.2.2:
1029 |   version "0.2.2"
1030 |   resolved "https://registry.yarnpkg.com/map-cache/-/map-cache-0.2.2.tgz#c32abd0bd6525d9b051645bb4f26ac5dc98a0dbf"
1031 |   integrity sha1-wyq9C9ZSXZsFFkW7TyasXcmKDb8=
1032 | 
1033 | map-visit@^1.0.0:
1034 |   version "1.0.0"
1035 |   resolved "https://registry.yarnpkg.com/map-visit/-/map-visit-1.0.0.tgz#ecdca8f13144e660f1b5bd41f12f3479d98dfb8f"
1036 |   integrity sha1-7Nyo8TFE5mDxtb1B8S80edmN+48=
1037 |   dependencies:
1038 |     object-visit "^1.0.0"
1039 | 
1040 | micromatch@^3.1.10:
1041 |   version "3.1.10"
1042 |   resolved "https://registry.yarnpkg.com/micromatch/-/micromatch-3.1.10.tgz#70859bc95c9840952f359a068a3fc49f9ecfac23"
1043 |   integrity sha512-MWikgl9n9M3w+bpsY3He8L+w9eF9338xRl8IAO5viDizwSzziFEyUzo2xrrloB64ADbTf8uA8vRqqttDTOmccg==
1044 |   dependencies:
1045 |     arr-diff "^4.0.0"
1046 |     array-unique "^0.3.2"
1047 |     braces "^2.3.1"
1048 |     define-property "^2.0.2"
1049 |     extend-shallow "^3.0.2"
1050 |     extglob "^2.0.4"
1051 |     fragment-cache "^0.2.1"
1052 |     kind-of "^6.0.2"
1053 |     nanomatch "^1.2.9"
1054 |     object.pick "^1.3.0"
1055 |     regex-not "^1.0.0"
1056 |     snapdragon "^0.8.1"
1057 |     to-regex "^3.0.2"
1058 | 
1059 | mimic-fn@^1.0.0:
1060 |   version "1.2.0"
1061 |   resolved "https://registry.yarnpkg.com/mimic-fn/-/mimic-fn-1.2.0.tgz#820c86a39334640e99516928bd03fca88057d022"
1062 |   integrity sha512-jf84uxzwiuiIVKiOLpfYk7N46TSy8ubTonmneY9vrpHNAnp0QBt2BxWV9dO3/j+BoVAb+a5G6YDPW3M5HOdMWQ==
1063 | 
1064 | minimatch@3.0.4, minimatch@^3.0.4:
1065 |   version "3.0.4"
1066 |   resolved "https://registry.yarnpkg.com/minimatch/-/minimatch-3.0.4.tgz#5166e286457f03306064be5497e8dbb0c3d32083"
1067 |   integrity sha512-yJHVQEhyqPLUTgt9B83PXu6W3rx4MvvHvSUvToogpwoGDOUQ+yDrR0HRot+yOCdCO7u4hX3pWft6kWBBcqh0UA==
1068 |   dependencies:
1069 |     brace-expansion "^1.1.7"
1070 | 
1071 | minimist@0.0.8:
1072 |   version "0.0.8"
1073 |   resolved "https://registry.yarnpkg.com/minimist/-/minimist-0.0.8.tgz#857fcabfc3397d2625b8228262e86aa7a011b05d"
1074 |   integrity sha1-hX/Kv8M5fSYluCKCYuhqp6ARsF0=
1075 | 
1076 | minimist@~0.0.1:
1077 |   version "0.0.10"
1078 |   resolved "https://registry.yarnpkg.com/minimist/-/minimist-0.0.10.tgz#de3f98543dbf96082be48ad1a0c7cda836301dcf"
1079 |   integrity sha1-3j+YVD2/lggr5IrRoMfNqDYwHc8=
1080 | 
1081 | mixin-deep@^1.2.0:
1082 |   version "1.3.2"
1083 |   resolved "https://registry.yarnpkg.com/mixin-deep/-/mixin-deep-1.3.2.tgz#1120b43dc359a785dce65b55b82e257ccf479566"
1084 |   integrity sha512-WRoDn//mXBiJ1H40rqa3vH0toePwSsGb45iInWlTySa+Uu4k3tYUSxa2v1KqAiLtvlrSzaExqS1gtk96A9zvEA==
1085 |   dependencies:
1086 |     for-in "^1.0.2"
1087 |     is-extendable "^1.0.1"
1088 | 
1089 | mkdirp@0.5.1, mkdirp@^0.5.1, mkdirp@~0.5.0:
1090 |   version "0.5.1"
1091 |   resolved "https://registry.yarnpkg.com/mkdirp/-/mkdirp-0.5.1.tgz#30057438eac6cf7f8c4767f38648d6697d75c903"
1092 |   integrity sha1-MAV0OOrGz3+MR2fzhkjWaX11yQM=
1093 |   dependencies:
1094 |     minimist "0.0.8"
1095 | 
1096 | mocha@^6.2.1:
1097 |   version "6.2.1"
1098 |   resolved "https://registry.yarnpkg.com/mocha/-/mocha-6.2.1.tgz#da941c99437da9bac412097859ff99543969f94c"
1099 |   integrity sha512-VCcWkLHwk79NYQc8cxhkmI8IigTIhsCwZ6RTxQsqK6go4UvEhzJkYuHm8B2YtlSxcYq2fY+ucr4JBwoD6ci80A==
1100 |   dependencies:
1101 |     ansi-colors "3.2.3"
1102 |     browser-stdout "1.3.1"
1103 |     debug "3.2.6"
1104 |     diff "3.5.0"
1105 |     escape-string-regexp "1.0.5"
1106 |     find-up "3.0.0"
1107 |     glob "7.1.3"
1108 |     growl "1.10.5"
1109 |     he "1.2.0"
1110 |     js-yaml "3.13.1"
1111 |     log-symbols "2.2.0"
1112 |     minimatch "3.0.4"
1113 |     mkdirp "0.5.1"
1114 |     ms "2.1.1"
1115 |     node-environment-flags "1.0.5"
1116 |     object.assign "4.1.0"
1117 |     strip-json-comments "2.0.1"
1118 |     supports-color "6.0.0"
1119 |     which "1.3.1"
1120 |     wide-align "1.1.3"
1121 |     yargs "13.3.0"
1122 |     yargs-parser "13.1.1"
1123 |     yargs-unparser "1.6.0"
1124 | 
1125 | ms@2.0.0:
1126 |   version "2.0.0"
1127 |   resolved "https://registry.yarnpkg.com/ms/-/ms-2.0.0.tgz#5608aeadfc00be6c2901df5f9861788de0d597c8"
1128 |   integrity sha1-VgiurfwAvmwpAd9fmGF4jeDVl8g=
1129 | 
1130 | ms@2.1.1:
1131 |   version "2.1.1"
1132 |   resolved "https://registry.yarnpkg.com/ms/-/ms-2.1.1.tgz#30a5864eb3ebb0a66f2ebe6d727af06a09d86e0a"
1133 |   integrity sha512-tgp+dl5cGk28utYktBsrFqA7HKgrhgPsg6Z/EfhWI4gl1Hwq8B/GmY/0oXZ6nF8hDVesS/FpnYaD/kOWhYQvyg==
1134 | 
1135 | ms@^2.1.1:
1136 |   version "2.1.2"
1137 |   resolved "https://registry.yarnpkg.com/ms/-/ms-2.1.2.tgz#d09d1f357b443f493382a8eb3ccd183872ae6009"
1138 |   integrity sha512-sGkPx+VjMtmA6MX27oA4FBFELFCZZ4S4XqeGOXCv68tT+jb3vk/RyaKWP0PTKyWtmLSM0b+adUTEvbs1PEaH2w==
1139 | 
1140 | mute-stream@0.0.7:
1141 |   version "0.0.7"
1142 |   resolved "https://registry.yarnpkg.com/mute-stream/-/mute-stream-0.0.7.tgz#3075ce93bc21b8fab43e1bc4da7e8115ed1e7bab"
1143 |   integrity sha1-MHXOk7whuPq0PhvE2n6BFe0ee6s=
1144 | 
1145 | nanomatch@^1.2.9:
1146 |   version "1.2.13"
1147 |   resolved "https://registry.yarnpkg.com/nanomatch/-/nanomatch-1.2.13.tgz#b87a8aa4fc0de8fe6be88895b38983ff265bd119"
1148 |   integrity sha512-fpoe2T0RbHwBTBUOftAfBPaDEi06ufaUai0mE6Yn1kacc3SnTErfb/h+X94VXzI64rKFHYImXSvdwGGCmwOqCA==
1149 |   dependencies:
1150 |     arr-diff "^4.0.0"
1151 |     array-unique "^0.3.2"
1152 |     define-property "^2.0.2"
1153 |     extend-shallow "^3.0.2"
1154 |     fragment-cache "^0.2.1"
1155 |     is-windows "^1.0.2"
1156 |     kind-of "^6.0.2"
1157 |     object.pick "^1.3.0"
1158 |     regex-not "^1.0.0"
1159 |     snapdragon "^0.8.1"
1160 |     to-regex "^3.0.1"
1161 | 
1162 | neo-async@^2.6.0:
1163 |   version "2.6.1"
1164 |   resolved "https://registry.yarnpkg.com/neo-async/-/neo-async-2.6.1.tgz#ac27ada66167fa8849a6addd837f6b189ad2081c"
1165 |   integrity sha512-iyam8fBuCUpWeKPGpaNMetEocMt364qkCsfL9JuhjXX6dRnguRVOfk2GZaDpPjcOKiiXCPINZC1GczQ7iTq3Zw==
1166 | 
1167 | neon-cli@^0.4.0:
1168 |   version "0.4.0"
1169 |   resolved "https://registry.yarnpkg.com/neon-cli/-/neon-cli-0.4.0.tgz#d89e0a55b8db577324af70470e2b4e67157205f6"
1170 |   integrity sha512-66HhHb8rk+zHSG64CI6jhyOQqpibBAald8ObdQPCjXcCjzSEVnkQHutUE8dyNlHRNT7xLfrZGkDbtwrYh2p+6w==
1171 |   dependencies:
1172 |     chalk "~2.1.0"
1173 |     command-line-args "^4.0.2"
1174 |     command-line-commands "^2.0.0"
1175 |     command-line-usage "^4.0.0"
1176 |     git-config "0.0.7"
1177 |     handlebars "^4.1.0"
1178 |     inquirer "^3.0.6"
1179 |     mkdirp "^0.5.1"
1180 |     quickly-copy-file "^1.0.0"
1181 |     rimraf "^2.6.1"
1182 |     rsvp "^4.6.1"
1183 |     semver "^5.1.0"
1184 |     toml "^2.3.0"
1185 |     ts-typed-json "^0.2.2"
1186 |     validate-npm-package-license "^3.0.1"
1187 |     validate-npm-package-name "^3.0.0"
1188 | 
1189 | node-environment-flags@1.0.5:
1190 |   version "1.0.5"
1191 |   resolved "https://registry.yarnpkg.com/node-environment-flags/-/node-environment-flags-1.0.5.tgz#fa930275f5bf5dae188d6192b24b4c8bbac3d76a"
1192 |   integrity sha512-VNYPRfGfmZLx0Ye20jWzHUjyTW/c+6Wq+iLhDzUI4XmhrDd9l/FozXV3F2xOaXjvp0co0+v1YSR3CMP6g+VvLQ==
1193 |   dependencies:
1194 |     object.getownpropertydescriptors "^2.0.3"
1195 |     semver "^5.7.0"
1196 | 
1197 | object-copy@^0.1.0:
1198 |   version "0.1.0"
1199 |   resolved "https://registry.yarnpkg.com/object-copy/-/object-copy-0.1.0.tgz#7e7d858b781bd7c991a41ba975ed3812754e998c"
1200 |   integrity sha1-fn2Fi3gb18mRpBupde04EnVOmYw=
1201 |   dependencies:
1202 |     copy-descriptor "^0.1.0"
1203 |     define-property "^0.2.5"
1204 |     kind-of "^3.0.3"
1205 | 
1206 | object-keys@^1.0.11, object-keys@^1.0.12:
1207 |   version "1.1.1"
1208 |   resolved "https://registry.yarnpkg.com/object-keys/-/object-keys-1.1.1.tgz#1c47f272df277f3b1daf061677d9c82e2322c60e"
1209 |   integrity sha512-NuAESUOUMrlIXOfHKzD6bpPu3tYt3xvjNdRIQ+FeT0lNb4K8WR70CaDxhuNguS2XG+GjkyMwOzsN5ZktImfhLA==
1210 | 
1211 | object-visit@^1.0.0:
1212 |   version "1.0.1"
1213 |   resolved "https://registry.yarnpkg.com/object-visit/-/object-visit-1.0.1.tgz#f79c4493af0c5377b59fe39d395e41042dd045bb"
1214 |   integrity sha1-95xEk68MU3e1n+OdOV5BBC3QRbs=
1215 |   dependencies:
1216 |     isobject "^3.0.0"
1217 | 
1218 | object.assign@4.1.0:
1219 |   version "4.1.0"
1220 |   resolved "https://registry.yarnpkg.com/object.assign/-/object.assign-4.1.0.tgz#968bf1100d7956bb3ca086f006f846b3bc4008da"
1221 |   integrity sha512-exHJeq6kBKj58mqGyTQ9DFvrZC/eR6OwxzoM9YRoGBqrXYonaFyGiFMuc9VZrXf7DarreEwMpurG3dd+CNyW5w==
1222 |   dependencies:
1223 |     define-properties "^1.1.2"
1224 |     function-bind "^1.1.1"
1225 |     has-symbols "^1.0.0"
1226 |     object-keys "^1.0.11"
1227 | 
1228 | object.getownpropertydescriptors@^2.0.3:
1229 |   version "2.0.3"
1230 |   resolved "https://registry.yarnpkg.com/object.getownpropertydescriptors/-/object.getownpropertydescriptors-2.0.3.tgz#8758c846f5b407adab0f236e0986f14b051caa16"
1231 |   integrity sha1-h1jIRvW0B62rDyNuCYbxSwUcqhY=
1232 |   dependencies:
1233 |     define-properties "^1.1.2"
1234 |     es-abstract "^1.5.1"
1235 | 
1236 | object.pick@^1.3.0:
1237 |   version "1.3.0"
1238 |   resolved "https://registry.yarnpkg.com/object.pick/-/object.pick-1.3.0.tgz#87a10ac4c1694bd2e1cbf53591a66141fb5dd747"
1239 |   integrity sha1-h6EKxMFpS9Lhy/U1kaZhQftd10c=
1240 |   dependencies:
1241 |     isobject "^3.0.1"
1242 | 
1243 | once@^1.3.0:
1244 |   version "1.4.0"
1245 |   resolved "https://registry.yarnpkg.com/once/-/once-1.4.0.tgz#583b1aa775961d4b113ac17d9c50baef9dd76bd1"
1246 |   integrity sha1-WDsap3WWHUsROsF9nFC6753Xa9E=
1247 |   dependencies:
1248 |     wrappy "1"
1249 | 
1250 | onetime@^2.0.0:
1251 |   version "2.0.1"
1252 |   resolved "https://registry.yarnpkg.com/onetime/-/onetime-2.0.1.tgz#067428230fd67443b2794b22bba528b6867962d4"
1253 |   integrity sha1-BnQoIw/WdEOyeUsiu6UotoZ5YtQ=
1254 |   dependencies:
1255 |     mimic-fn "^1.0.0"
1256 | 
1257 | optimist@^0.6.1:
1258 |   version "0.6.1"
1259 |   resolved "https://registry.yarnpkg.com/optimist/-/optimist-0.6.1.tgz#da3ea74686fa21a19a111c326e90eb15a0196686"
1260 |   integrity sha1-2j6nRob6IaGaERwybpDrFaAZZoY=
1261 |   dependencies:
1262 |     minimist "~0.0.1"
1263 |     wordwrap "~0.0.2"
1264 | 
1265 | os-tmpdir@~1.0.2:
1266 |   version "1.0.2"
1267 |   resolved "https://registry.yarnpkg.com/os-tmpdir/-/os-tmpdir-1.0.2.tgz#bbe67406c79aa85c5cfec766fe5734555dfa1274"
1268 |   integrity sha1-u+Z0BseaqFxc/sdm/lc0VV36EnQ=
1269 | 
1270 | p-limit@^2.0.0:
1271 |   version "2.2.1"
1272 |   resolved "https://registry.yarnpkg.com/p-limit/-/p-limit-2.2.1.tgz#aa07a788cc3151c939b5131f63570f0dd2009537"
1273 |   integrity sha512-85Tk+90UCVWvbDavCLKPOLC9vvY8OwEX/RtKF+/1OADJMVlFfEHOiMTPVyxg7mk/dKa+ipdHm0OUkTvCpMTuwg==
1274 |   dependencies:
1275 |     p-try "^2.0.0"
1276 | 
1277 | p-locate@^3.0.0:
1278 |   version "3.0.0"
1279 |   resolved "https://registry.yarnpkg.com/p-locate/-/p-locate-3.0.0.tgz#322d69a05c0264b25997d9f40cd8a891ab0064a4"
1280 |   integrity sha512-x+12w/To+4GFfgJhBEpiDcLozRJGegY+Ei7/z0tSLkMmxGZNybVMSfWj9aJn8Z5Fc7dBUNJOOVgPv2H7IwulSQ==
1281 |   dependencies:
1282 |     p-limit "^2.0.0"
1283 | 
1284 | p-try@^2.0.0:
1285 |   version "2.2.0"
1286 |   resolved "https://registry.yarnpkg.com/p-try/-/p-try-2.2.0.tgz#cb2868540e313d61de58fafbe35ce9004d5540e6"
1287 |   integrity sha512-R4nPAVTAU0B9D35/Gk3uJf/7XYbQcyohSKdvAxIRSNghFl4e71hVoGnBNQz9cWaXxO2I10KTC+3jMdvvoKw6dQ==
1288 | 
1289 | pascalcase@^0.1.1:
1290 |   version "0.1.1"
1291 |   resolved "https://registry.yarnpkg.com/pascalcase/-/pascalcase-0.1.1.tgz#b363e55e8006ca6fe21784d2db22bd15d7917f14"
1292 |   integrity sha1-s2PlXoAGym/iF4TS2yK9FdeRfxQ=
1293 | 
1294 | path-exists@^3.0.0:
1295 |   version "3.0.0"
1296 |   resolved "https://registry.yarnpkg.com/path-exists/-/path-exists-3.0.0.tgz#ce0ebeaa5f78cb18925ea7d810d7b59b010fd515"
1297 |   integrity sha1-zg6+ql94yxiSXqfYENe1mwEP1RU=
1298 | 
1299 | path-is-absolute@^1.0.0:
1300 |   version "1.0.1"
1301 |   resolved "https://registry.yarnpkg.com/path-is-absolute/-/path-is-absolute-1.0.1.tgz#174b9268735534ffbc7ace6bf53a5a9e1b5c5f5f"
1302 |   integrity sha1-F0uSaHNVNP+8es5r9TpanhtcX18=
1303 | 
1304 | posix-character-classes@^0.1.0:
1305 |   version "0.1.1"
1306 |   resolved "https://registry.yarnpkg.com/posix-character-classes/-/posix-character-classes-0.1.1.tgz#01eac0fe3b5af71a2a6c02feabb8c1fef7e00eab"
1307 |   integrity sha1-AerA/jta9xoqbAL+q7jB/vfgDqs=
1308 | 
1309 | pretty-format@^24.9.0:
1310 |   version "24.9.0"
1311 |   resolved "https://registry.yarnpkg.com/pretty-format/-/pretty-format-24.9.0.tgz#12fac31b37019a4eea3c11aa9a959eb7628aa7c9"
1312 |   integrity sha512-00ZMZUiHaJrNfk33guavqgvfJS30sLYf0f8+Srklv0AMPodGGHcoHgksZ3OThYnIvOd+8yMCn0YiEOogjlgsnA==
1313 |   dependencies:
1314 |     "@jest/types" "^24.9.0"
1315 |     ansi-regex "^4.0.0"
1316 |     ansi-styles "^3.2.0"
1317 |     react-is "^16.8.4"
1318 | 
1319 | quickly-copy-file@^1.0.0:
1320 |   version "1.0.0"
1321 |   resolved "https://registry.yarnpkg.com/quickly-copy-file/-/quickly-copy-file-1.0.0.tgz#9f8ff066230510ee7422b0121472b093a8690859"
1322 |   integrity sha1-n4/wZiMFEO50IrASFHKwk6hpCFk=
1323 |   dependencies:
1324 |     mkdirp "~0.5.0"
1325 | 
1326 | react-is@^16.8.4:
1327 |   version "16.9.0"
1328 |   resolved "https://registry.yarnpkg.com/react-is/-/react-is-16.9.0.tgz#21ca9561399aad0ff1a7701c01683e8ca981edcb"
1329 |   integrity sha512-tJBzzzIgnnRfEm046qRcURvwQnZVXmuCbscxUO5RWrGTXpon2d4c8mI0D8WE6ydVIm29JiLB6+RslkIvym9Rjw==
1330 | 
1331 | reduce-flatten@^1.0.1:
1332 |   version "1.0.1"
1333 |   resolved "https://registry.yarnpkg.com/reduce-flatten/-/reduce-flatten-1.0.1.tgz#258c78efd153ddf93cb561237f61184f3696e327"
1334 |   integrity sha1-JYx479FT3fk8tWEjf2EYTzaW4yc=
1335 | 
1336 | regex-not@^1.0.0, regex-not@^1.0.2:
1337 |   version "1.0.2"
1338 |   resolved "https://registry.yarnpkg.com/regex-not/-/regex-not-1.0.2.tgz#1f4ece27e00b0b65e0247a6810e6a85d83a5752c"
1339 |   integrity sha512-J6SDjUgDxQj5NusnOtdFxDwN/+HWykR8GELwctJ7mdqhcyy1xEc4SRFHUXvxTp661YaVKAjfRLZ9cCqS6tn32A==
1340 |   dependencies:
1341 |     extend-shallow "^3.0.2"
1342 |     safe-regex "^1.1.0"
1343 | 
1344 | repeat-element@^1.1.2:
1345 |   version "1.1.3"
1346 |   resolved "https://registry.yarnpkg.com/repeat-element/-/repeat-element-1.1.3.tgz#782e0d825c0c5a3bb39731f84efee6b742e6b1ce"
1347 |   integrity sha512-ahGq0ZnV5m5XtZLMb+vP76kcAM5nkLqk0lpqAuojSKGgQtn4eRi4ZZGm2olo2zKFH+sMsWaqOCW1dqAnOru72g==
1348 | 
1349 | repeat-string@^1.6.1:
1350 |   version "1.6.1"
1351 |   resolved "https://registry.yarnpkg.com/repeat-string/-/repeat-string-1.6.1.tgz#8dcae470e1c88abc2d600fff4a776286da75e637"
1352 |   integrity sha1-jcrkcOHIirwtYA//Sndihtp15jc=
1353 | 
1354 | require-directory@^2.1.1:
1355 |   version "2.1.1"
1356 |   resolved "https://registry.yarnpkg.com/require-directory/-/require-directory-2.1.1.tgz#8c64ad5fd30dab1c976e2344ffe7f792a6a6df42"
1357 |   integrity sha1-jGStX9MNqxyXbiNE/+f3kqam30I=
1358 | 
1359 | require-main-filename@^2.0.0:
1360 |   version "2.0.0"
1361 |   resolved "https://registry.yarnpkg.com/require-main-filename/-/require-main-filename-2.0.0.tgz#d0b329ecc7cc0f61649f62215be69af54aa8989b"
1362 |   integrity sha512-NKN5kMDylKuldxYLSUfrbo5Tuzh4hd+2E8NPPX02mZtn1VuREQToYe/ZdlJy+J3uCpfaiGF05e7B8W0iXbQHmg==
1363 | 
1364 | resolve-url@^0.2.1:
1365 |   version "0.2.1"
1366 |   resolved "https://registry.yarnpkg.com/resolve-url/-/resolve-url-0.2.1.tgz#2c637fe77c893afd2a663fe21aa9080068e2052a"
1367 |   integrity sha1-LGN/53yJOv0qZj/iGqkIAGjiBSo=
1368 | 
1369 | restore-cursor@^2.0.0:
1370 |   version "2.0.0"
1371 |   resolved "https://registry.yarnpkg.com/restore-cursor/-/restore-cursor-2.0.0.tgz#9f7ee287f82fd326d4fd162923d62129eee0dfaf"
1372 |   integrity sha1-n37ih/gv0ybU/RYpI9YhKe7g368=
1373 |   dependencies:
1374 |     onetime "^2.0.0"
1375 |     signal-exit "^3.0.2"
1376 | 
1377 | ret@~0.1.10:
1378 |   version "0.1.15"
1379 |   resolved "https://registry.yarnpkg.com/ret/-/ret-0.1.15.tgz#b8a4825d5bdb1fc3f6f53c2bc33f81388681c7bc"
1380 |   integrity sha512-TTlYpa+OL+vMMNG24xSlQGEJ3B/RzEfUlLct7b5G/ytav+wPrplCpVMFuwzXbkecJrb6IYo1iFb0S9v37754mg==
1381 | 
1382 | rimraf@^2.6.1:
1383 |   version "2.7.1"
1384 |   resolved "https://registry.yarnpkg.com/rimraf/-/rimraf-2.7.1.tgz#35797f13a7fdadc566142c29d4f07ccad483e3ec"
1385 |   integrity sha512-uWjbaKIK3T1OSVptzX7Nl6PvQ3qAGtKEtVRjRuazjfL3Bx5eI409VZSqgND+4UNnmzLVdPj9FqFJNPqBZFve4w==
1386 |   dependencies:
1387 |     glob "^7.1.3"
1388 | 
1389 | rsvp@^3.5.0:
1390 |   version "3.6.2"
1391 |   resolved "https://registry.yarnpkg.com/rsvp/-/rsvp-3.6.2.tgz#2e96491599a96cde1b515d5674a8f7a91452926a"
1392 |   integrity sha512-OfWGQTb9vnwRjwtA2QwpG2ICclHC3pgXZO5xt8H2EfgDquO0qVdSb5T88L4qJVAEugbS56pAuV4XZM58UX8ulw==
1393 | 
1394 | rsvp@^4.6.1:
1395 |   version "4.8.5"
1396 |   resolved "https://registry.yarnpkg.com/rsvp/-/rsvp-4.8.5.tgz#c8f155311d167f68f21e168df71ec5b083113734"
1397 |   integrity sha512-nfMOlASu9OnRJo1mbEk2cz0D56a1MBNrJ7orjRZQG10XDyuvwksKbuXNp6qa+kbn839HwjwhBzhFmdsaEAfauA==
1398 | 
1399 | run-async@^2.2.0:
1400 |   version "2.3.0"
1401 |   resolved "https://registry.yarnpkg.com/run-async/-/run-async-2.3.0.tgz#0371ab4ae0bdd720d4166d7dfda64ff7a445a6c0"
1402 |   integrity sha1-A3GrSuC91yDUFm19/aZP96RFpsA=
1403 |   dependencies:
1404 |     is-promise "^2.1.0"
1405 | 
1406 | rx-lite-aggregates@^4.0.8:
1407 |   version "4.0.8"
1408 |   resolved "https://registry.yarnpkg.com/rx-lite-aggregates/-/rx-lite-aggregates-4.0.8.tgz#753b87a89a11c95467c4ac1626c4efc4e05c67be"
1409 |   integrity sha1-dTuHqJoRyVRnxKwWJsTvxOBcZ74=
1410 |   dependencies:
1411 |     rx-lite "*"
1412 | 
1413 | rx-lite@*, rx-lite@^4.0.8:
1414 |   version "4.0.8"
1415 |   resolved "https://registry.yarnpkg.com/rx-lite/-/rx-lite-4.0.8.tgz#0b1e11af8bc44836f04a6407e92da42467b79444"
1416 |   integrity sha1-Cx4Rr4vESDbwSmQH6S2kJGe3lEQ=
1417 | 
1418 | safe-regex@^1.1.0:
1419 |   version "1.1.0"
1420 |   resolved "https://registry.yarnpkg.com/safe-regex/-/safe-regex-1.1.0.tgz#40a3669f3b077d1e943d44629e157dd48023bf2e"
1421 |   integrity sha1-QKNmnzsHfR6UPURinhV91IAjvy4=
1422 |   dependencies:
1423 |     ret "~0.1.10"
1424 | 
1425 | "safer-buffer@>= 2.1.2 < 3":
1426 |   version "2.1.2"
1427 |   resolved "https://registry.yarnpkg.com/safer-buffer/-/safer-buffer-2.1.2.tgz#44fa161b0187b9549dd84bb91802f9bd8385cd6a"
1428 |   integrity sha512-YZo3K82SD7Riyi0E1EQPojLz7kpepnSQI9IyPbHHg1XXXevb5dJI7tpyN2ADxGcQbHG7vcyRHk0cbwqcQriUtg==
1429 | 
1430 | semver@^5.1.0, semver@^5.7.0:
1431 |   version "5.7.1"
1432 |   resolved "https://registry.yarnpkg.com/semver/-/semver-5.7.1.tgz#a954f931aeba508d307bbf069eff0c01c96116f7"
1433 |   integrity sha512-sauaDf/PZdVgrLTNYHRtpXa1iRiKcaebiKQ1BJdpQlWH2lCvexQdX55snPFyK7QzpudqbCI0qXFfOasHdyNDGQ==
1434 | 
1435 | set-blocking@^2.0.0:
1436 |   version "2.0.0"
1437 |   resolved "https://registry.yarnpkg.com/set-blocking/-/set-blocking-2.0.0.tgz#045f9782d011ae9a6803ddd382b24392b3d890f7"
1438 |   integrity sha1-BF+XgtARrppoA93TgrJDkrPYkPc=
1439 | 
1440 | set-value@^2.0.0, set-value@^2.0.1:
1441 |   version "2.0.1"
1442 |   resolved "https://registry.yarnpkg.com/set-value/-/set-value-2.0.1.tgz#a18d40530e6f07de4228c7defe4227af8cad005b"
1443 |   integrity sha512-JxHc1weCN68wRY0fhCoXpyK55m/XPHafOmK4UWD7m2CI14GMcFypt4w/0+NV5f/ZMby2F6S2wwA7fgynh9gWSw==
1444 |   dependencies:
1445 |     extend-shallow "^2.0.1"
1446 |     is-extendable "^0.1.1"
1447 |     is-plain-object "^2.0.3"
1448 |     split-string "^3.0.1"
1449 | 
1450 | signal-exit@^3.0.2:
1451 |   version "3.0.2"
1452 |   resolved "https://registry.yarnpkg.com/signal-exit/-/signal-exit-3.0.2.tgz#b5fdc08f1287ea1178628e415e25132b73646c6d"
1453 |   integrity sha1-tf3AjxKH6hF4Yo5BXiUTK3NkbG0=
1454 | 
1455 | slash@^2.0.0:
1456 |   version "2.0.0"
1457 |   resolved "https://registry.yarnpkg.com/slash/-/slash-2.0.0.tgz#de552851a1759df3a8f206535442f5ec4ddeab44"
1458 |   integrity sha512-ZYKh3Wh2z1PpEXWr0MpSBZ0V6mZHAQfYevttO11c51CaWjGTaadiKZ+wVt1PbMlDV5qhMFslpZCemhwOK7C89A==
1459 | 
1460 | snapdragon-node@^2.0.1:
1461 |   version "2.1.1"
1462 |   resolved "https://registry.yarnpkg.com/snapdragon-node/-/snapdragon-node-2.1.1.tgz#6c175f86ff14bdb0724563e8f3c1b021a286853b"
1463 |   integrity sha512-O27l4xaMYt/RSQ5TR3vpWCAB5Kb/czIcqUFOM/C4fYcLnbZUc1PkjTAMjof2pBWaSTwOUd6qUHcFGVGj7aIwnw==
1464 |   dependencies:
1465 |     define-property "^1.0.0"
1466 |     isobject "^3.0.0"
1467 |     snapdragon-util "^3.0.1"
1468 | 
1469 | snapdragon-util@^3.0.1:
1470 |   version "3.0.1"
1471 |   resolved "https://registry.yarnpkg.com/snapdragon-util/-/snapdragon-util-3.0.1.tgz#f956479486f2acd79700693f6f7b805e45ab56e2"
1472 |   integrity sha512-mbKkMdQKsjX4BAL4bRYTj21edOf8cN7XHdYUJEe+Zn99hVEYcMvKPct1IqNe7+AZPirn8BCDOQBHQZknqmKlZQ==
1473 |   dependencies:
1474 |     kind-of "^3.2.0"
1475 | 
1476 | snapdragon@^0.8.1:
1477 |   version "0.8.2"
1478 |   resolved "https://registry.yarnpkg.com/snapdragon/-/snapdragon-0.8.2.tgz#64922e7c565b0e14204ba1aa7d6964278d25182d"
1479 |   integrity sha512-FtyOnWN/wCHTVXOMwvSv26d+ko5vWlIDD6zoUJ7LW8vh+ZBC8QdljveRP+crNrtBwioEUWy/4dMtbBjA4ioNlg==
1480 |   dependencies:
1481 |     base "^0.11.1"
1482 |     debug "^2.2.0"
1483 |     define-property "^0.2.5"
1484 |     extend-shallow "^2.0.1"
1485 |     map-cache "^0.2.2"
1486 |     source-map "^0.5.6"
1487 |     source-map-resolve "^0.5.0"
1488 |     use "^3.1.0"
1489 | 
1490 | source-map-resolve@^0.5.0:
1491 |   version "0.5.2"
1492 |   resolved "https://registry.yarnpkg.com/source-map-resolve/-/source-map-resolve-0.5.2.tgz#72e2cc34095543e43b2c62b2c4c10d4a9054f259"
1493 |   integrity sha512-MjqsvNwyz1s0k81Goz/9vRBe9SZdB09Bdw+/zYyO+3CuPk6fouTaxscHkgtE8jKvf01kVfl8riHzERQ/kefaSA==
1494 |   dependencies:
1495 |     atob "^2.1.1"
1496 |     decode-uri-component "^0.2.0"
1497 |     resolve-url "^0.2.1"
1498 |     source-map-url "^0.4.0"
1499 |     urix "^0.1.0"
1500 | 
1501 | source-map-url@^0.4.0:
1502 |   version "0.4.0"
1503 |   resolved "https://registry.yarnpkg.com/source-map-url/-/source-map-url-0.4.0.tgz#3e935d7ddd73631b97659956d55128e87b5084a3"
1504 |   integrity sha1-PpNdfd1zYxuXZZlW1VEo6HtQhKM=
1505 | 
1506 | source-map@^0.5.6:
1507 |   version "0.5.7"
1508 |   resolved "https://registry.yarnpkg.com/source-map/-/source-map-0.5.7.tgz#8a039d2d1021d22d1ea14c80d8ea468ba2ef3fcc"
1509 |   integrity sha1-igOdLRAh0i0eoUyA2OpGi6LvP8w=
1510 | 
1511 | source-map@^0.6.0, source-map@^0.6.1, source-map@~0.6.1:
1512 |   version "0.6.1"
1513 |   resolved "https://registry.yarnpkg.com/source-map/-/source-map-0.6.1.tgz#74722af32e9614e9c287a8d0bbde48b5e2f1a263"
1514 |   integrity sha512-UjgapumWlbMhkBgzT7Ykc5YXUT46F0iKu8SGXq0bcwP5dz/h0Plj6enJqjz1Zbq2l5WaqYnrVbwWOWMyF3F47g==
1515 | 
1516 | spdx-correct@^3.0.0:
1517 |   version "3.1.0"
1518 |   resolved "https://registry.yarnpkg.com/spdx-correct/-/spdx-correct-3.1.0.tgz#fb83e504445268f154b074e218c87c003cd31df4"
1519 |   integrity sha512-lr2EZCctC2BNR7j7WzJ2FpDznxky1sjfxvvYEyzxNyb6lZXHODmEoJeFu4JupYlkfha1KZpJyoqiJ7pgA1qq8Q==
1520 |   dependencies:
1521 |     spdx-expression-parse "^3.0.0"
1522 |     spdx-license-ids "^3.0.0"
1523 | 
1524 | spdx-exceptions@^2.1.0:
1525 |   version "2.2.0"
1526 |   resolved "https://registry.yarnpkg.com/spdx-exceptions/-/spdx-exceptions-2.2.0.tgz#2ea450aee74f2a89bfb94519c07fcd6f41322977"
1527 |   integrity sha512-2XQACfElKi9SlVb1CYadKDXvoajPgBVPn/gOQLrTvHdElaVhr7ZEbqJaRnJLVNeaI4cMEAgVCeBMKF6MWRDCRA==
1528 | 
1529 | spdx-expression-parse@^3.0.0:
1530 |   version "3.0.0"
1531 |   resolved "https://registry.yarnpkg.com/spdx-expression-parse/-/spdx-expression-parse-3.0.0.tgz#99e119b7a5da00e05491c9fa338b7904823b41d0"
1532 |   integrity sha512-Yg6D3XpRD4kkOmTpdgbUiEJFKghJH03fiC1OPll5h/0sO6neh2jqRDVHOQ4o/LMea0tgCkbMgea5ip/e+MkWyg==
1533 |   dependencies:
1534 |     spdx-exceptions "^2.1.0"
1535 |     spdx-license-ids "^3.0.0"
1536 | 
1537 | spdx-license-ids@^3.0.0:
1538 |   version "3.0.5"
1539 |   resolved "https://registry.yarnpkg.com/spdx-license-ids/-/spdx-license-ids-3.0.5.tgz#3694b5804567a458d3c8045842a6358632f62654"
1540 |   integrity sha512-J+FWzZoynJEXGphVIS+XEh3kFSjZX/1i9gFBaWQcB+/tmpe2qUsSBABpcxqxnAxFdiUFEgAX1bjYGQvIZmoz9Q==
1541 | 
1542 | split-string@^3.0.1, split-string@^3.0.2:
1543 |   version "3.1.0"
1544 |   resolved "https://registry.yarnpkg.com/split-string/-/split-string-3.1.0.tgz#7cb09dda3a86585705c64b39a6466038682e8fe2"
1545 |   integrity sha512-NzNVhJDYpwceVVii8/Hu6DKfD2G+NrQHlS/V/qgv763EYudVwEcMQNxd2lh+0VrUByXN/oJkl5grOhYWvQUYiw==
1546 |   dependencies:
1547 |     extend-shallow "^3.0.0"
1548 | 
1549 | sprintf-js@~1.0.2:
1550 |   version "1.0.3"
1551 |   resolved "https://registry.yarnpkg.com/sprintf-js/-/sprintf-js-1.0.3.tgz#04e6926f662895354f3dd015203633b857297e2c"
1552 |   integrity sha1-BOaSb2YolTVPPdAVIDYzuFcpfiw=
1553 | 
1554 | stack-utils@^1.0.1:
1555 |   version "1.0.2"
1556 |   resolved "https://registry.yarnpkg.com/stack-utils/-/stack-utils-1.0.2.tgz#33eba3897788558bebfc2db059dc158ec36cebb8"
1557 |   integrity sha512-MTX+MeG5U994cazkjd/9KNAapsHnibjMLnfXodlkXw76JEea0UiNzrqidzo1emMwk7w5Qhc9jd4Bn9TBb1MFwA==
1558 | 
1559 | static-extend@^0.1.1:
1560 |   version "0.1.2"
1561 |   resolved "https://registry.yarnpkg.com/static-extend/-/static-extend-0.1.2.tgz#60809c39cbff55337226fd5e0b520f341f1fb5c6"
1562 |   integrity sha1-YICcOcv/VTNyJv1eC1IPNB8ftcY=
1563 |   dependencies:
1564 |     define-property "^0.2.5"
1565 |     object-copy "^0.1.0"
1566 | 
1567 | "string-width@^1.0.2 || 2", string-width@^2.1.0:
1568 |   version "2.1.1"
1569 |   resolved "https://registry.yarnpkg.com/string-width/-/string-width-2.1.1.tgz#ab93f27a8dc13d28cac815c462143a6d9012ae9e"
1570 |   integrity sha512-nOqH59deCq9SRHlxq1Aw85Jnt4w6KvLKqWVik6oA9ZklXLNIOlqg4F2yrT1MVaTjAqvVwdfeZ7w7aCvJD7ugkw==
1571 |   dependencies:
1572 |     is-fullwidth-code-point "^2.0.0"
1573 |     strip-ansi "^4.0.0"
1574 | 
1575 | string-width@^3.0.0, string-width@^3.1.0:
1576 |   version "3.1.0"
1577 |   resolved "https://registry.yarnpkg.com/string-width/-/string-width-3.1.0.tgz#22767be21b62af1081574306f69ac51b62203961"
1578 |   integrity sha512-vafcv6KjVZKSgz06oM/H6GDBrAtz8vdhQakGjFIvNrHA6y3HCF1CInLy+QLq8dTJPQ1b+KDUqDFctkdRW44e1w==
1579 |   dependencies:
1580 |     emoji-regex "^7.0.1"
1581 |     is-fullwidth-code-point "^2.0.0"
1582 |     strip-ansi "^5.1.0"
1583 | 
1584 | strip-ansi@^4.0.0:
1585 |   version "4.0.0"
1586 |   resolved "https://registry.yarnpkg.com/strip-ansi/-/strip-ansi-4.0.0.tgz#a8479022eb1ac368a871389b635262c505ee368f"
1587 |   integrity sha1-qEeQIusaw2iocTibY1JixQXuNo8=
1588 |   dependencies:
1589 |     ansi-regex "^3.0.0"
1590 | 
1591 | strip-ansi@^5.0.0, strip-ansi@^5.1.0, strip-ansi@^5.2.0:
1592 |   version "5.2.0"
1593 |   resolved "https://registry.yarnpkg.com/strip-ansi/-/strip-ansi-5.2.0.tgz#8c9a536feb6afc962bdfa5b104a5091c1ad9c0ae"
1594 |   integrity sha512-DuRs1gKbBqsMKIZlrffwlug8MHkcnpjs5VPmL1PAh+mA30U0DTotfDZ0d2UUsXpPmPmMMJ6W773MaA3J+lbiWA==
1595 |   dependencies:
1596 |     ansi-regex "^4.1.0"
1597 | 
1598 | strip-json-comments@2.0.1:
1599 |   version "2.0.1"
1600 |   resolved "https://registry.yarnpkg.com/strip-json-comments/-/strip-json-comments-2.0.1.tgz#3c531942e908c2697c0ec344858c286c7ca0a60a"
1601 |   integrity sha1-PFMZQukIwml8DsNEhYwobHygpgo=
1602 | 
1603 | supports-color@6.0.0:
1604 |   version "6.0.0"
1605 |   resolved "https://registry.yarnpkg.com/supports-color/-/supports-color-6.0.0.tgz#76cfe742cf1f41bb9b1c29ad03068c05b4c0e40a"
1606 |   integrity sha512-on9Kwidc1IUQo+bQdhi8+Tijpo0e1SS6RoGo2guUwn5vdaxw8RXOF9Vb2ws+ihWOmh4JnCJOvaziZWP1VABaLg==
1607 |   dependencies:
1608 |     has-flag "^3.0.0"
1609 | 
1610 | supports-color@^4.0.0:
1611 |   version "4.5.0"
1612 |   resolved "https://registry.yarnpkg.com/supports-color/-/supports-color-4.5.0.tgz#be7a0de484dec5c5cddf8b3d59125044912f635b"
1613 |   integrity sha1-vnoN5ITexcXN34s9WRJQRJEvY1s=
1614 |   dependencies:
1615 |     has-flag "^2.0.0"
1616 | 
1617 | supports-color@^5.3.0:
1618 |   version "5.5.0"
1619 |   resolved "https://registry.yarnpkg.com/supports-color/-/supports-color-5.5.0.tgz#e2e69a44ac8772f78a1ec0b35b689df6530efc8f"
1620 |   integrity sha512-QjVjwdXIt408MIiAqCX4oUKsgU2EqAGzs2Ppkm4aQYbjm+ZEWEcW4SfFNTr4uMNZma0ey4f5lgLrkB0aX0QMow==
1621 |   dependencies:
1622 |     has-flag "^3.0.0"
1623 | 
1624 | table-layout@^0.4.2:
1625 |   version "0.4.5"
1626 |   resolved "https://registry.yarnpkg.com/table-layout/-/table-layout-0.4.5.tgz#d906de6a25fa09c0c90d1d08ecd833ecedcb7378"
1627 |   integrity sha512-zTvf0mcggrGeTe/2jJ6ECkJHAQPIYEwDoqsiqBjI24mvRmQbInK5jq33fyypaCBxX08hMkfmdOqj6haT33EqWw==
1628 |   dependencies:
1629 |     array-back "^2.0.0"
1630 |     deep-extend "~0.6.0"
1631 |     lodash.padend "^4.6.1"
1632 |     typical "^2.6.1"
1633 |     wordwrapjs "^3.0.0"
1634 | 
1635 | test-value@^2.1.0:
1636 |   version "2.1.0"
1637 |   resolved "https://registry.yarnpkg.com/test-value/-/test-value-2.1.0.tgz#11da6ff670f3471a73b625ca4f3fdcf7bb748291"
1638 |   integrity sha1-Edpv9nDzRxpztiXKTz/c97t0gpE=
1639 |   dependencies:
1640 |     array-back "^1.0.3"
1641 |     typical "^2.6.0"
1642 | 
1643 | through@^2.3.6:
1644 |   version "2.3.8"
1645 |   resolved "https://registry.yarnpkg.com/through/-/through-2.3.8.tgz#0dd4c9ffaabc357960b1b724115d7e0e86a2e1f5"
1646 |   integrity sha1-DdTJ/6q8NXlgsbckEV1+Doai4fU=
1647 | 
1648 | tmp@^0.0.33:
1649 |   version "0.0.33"
1650 |   resolved "https://registry.yarnpkg.com/tmp/-/tmp-0.0.33.tgz#6d34335889768d21b2bcda0aa277ced3b1bfadf9"
1651 |   integrity sha512-jRCJlojKnZ3addtTOjdIqoRuPEKBvNXcGYqzO6zWZX8KfKEpnGY5jfggJQ3EjKuu8D4bJRr0y+cYJFmYbImXGw==
1652 |   dependencies:
1653 |     os-tmpdir "~1.0.2"
1654 | 
1655 | to-object-path@^0.3.0:
1656 |   version "0.3.0"
1657 |   resolved "https://registry.yarnpkg.com/to-object-path/-/to-object-path-0.3.0.tgz#297588b7b0e7e0ac08e04e672f85c1f4999e17af"
1658 |   integrity sha1-KXWIt7Dn4KwI4E5nL4XB9JmeF68=
1659 |   dependencies:
1660 |     kind-of "^3.0.2"
1661 | 
1662 | to-regex-range@^2.1.0:
1663 |   version "2.1.1"
1664 |   resolved "https://registry.yarnpkg.com/to-regex-range/-/to-regex-range-2.1.1.tgz#7c80c17b9dfebe599e27367e0d4dd5590141db38"
1665 |   integrity sha1-fIDBe53+vlmeJzZ+DU3VWQFB2zg=
1666 |   dependencies:
1667 |     is-number "^3.0.0"
1668 |     repeat-string "^1.6.1"
1669 | 
1670 | to-regex@^3.0.1, to-regex@^3.0.2:
1671 |   version "3.0.2"
1672 |   resolved "https://registry.yarnpkg.com/to-regex/-/to-regex-3.0.2.tgz#13cfdd9b336552f30b51f33a8ae1b42a7a7599ce"
1673 |   integrity sha512-FWtleNAtZ/Ki2qtqej2CXTOayOH9bHDQF+Q48VpWyDXjbYxA4Yz8iDB31zXOBUlOHHKidDbqGVrTUvQMPmBGBw==
1674 |   dependencies:
1675 |     define-property "^2.0.2"
1676 |     extend-shallow "^3.0.2"
1677 |     regex-not "^1.0.2"
1678 |     safe-regex "^1.1.0"
1679 | 
1680 | toml@^2.3.0:
1681 |   version "2.3.6"
1682 |   resolved "https://registry.yarnpkg.com/toml/-/toml-2.3.6.tgz#25b0866483a9722474895559088b436fd11f861b"
1683 |   integrity sha512-gVweAectJU3ebq//Ferr2JUY4WKSDe5N+z0FvjDncLGyHmIDoxgY/2Ie4qfEIDm4IS7OA6Rmdm7pdEEdMcV/xQ==
1684 | 
1685 | ts-typed-json@^0.2.2:
1686 |   version "0.2.2"
1687 |   resolved "https://registry.yarnpkg.com/ts-typed-json/-/ts-typed-json-0.2.2.tgz#53184bee893e45991b73c8c463a38b59e27cd47e"
1688 |   integrity sha1-UxhL7ok+RZkbc8jEY6OLWeJ81H4=
1689 |   dependencies:
1690 |     rsvp "^3.5.0"
1691 | 
1692 | typical@^2.6.0, typical@^2.6.1:
1693 |   version "2.6.1"
1694 |   resolved "https://registry.yarnpkg.com/typical/-/typical-2.6.1.tgz#5c080e5d661cbbe38259d2e70a3c7253e873881d"
1695 |   integrity sha1-XAgOXWYcu+OCWdLnCjxyU+hziB0=
1696 | 
1697 | uglify-js@^3.1.4:
1698 |   version "3.6.0"
1699 |   resolved "https://registry.yarnpkg.com/uglify-js/-/uglify-js-3.6.0.tgz#704681345c53a8b2079fb6cec294b05ead242ff5"
1700 |   integrity sha512-W+jrUHJr3DXKhrsS7NUVxn3zqMOFn0hL/Ei6v0anCIMoKC93TjcflTagwIHLW7SfMFfiQuktQyFVCFHGUE0+yg==
1701 |   dependencies:
1702 |     commander "~2.20.0"
1703 |     source-map "~0.6.1"
1704 | 
1705 | union-value@^1.0.0:
1706 |   version "1.0.1"
1707 |   resolved "https://registry.yarnpkg.com/union-value/-/union-value-1.0.1.tgz#0b6fe7b835aecda61c6ea4d4f02c14221e109847"
1708 |   integrity sha512-tJfXmxMeWYnczCVs7XAEvIV7ieppALdyepWMkHkwciRpZraG/xwT+s2JN8+pr1+8jCRf80FFzvr+MpQeeoF4Xg==
1709 |   dependencies:
1710 |     arr-union "^3.1.0"
1711 |     get-value "^2.0.6"
1712 |     is-extendable "^0.1.1"
1713 |     set-value "^2.0.1"
1714 | 
1715 | unset-value@^1.0.0:
1716 |   version "1.0.0"
1717 |   resolved "https://registry.yarnpkg.com/unset-value/-/unset-value-1.0.0.tgz#8376873f7d2335179ffb1e6fc3a8ed0dfc8ab559"
1718 |   integrity sha1-g3aHP30jNRef+x5vw6jtDfyKtVk=
1719 |   dependencies:
1720 |     has-value "^0.3.1"
1721 |     isobject "^3.0.0"
1722 | 
1723 | urix@^0.1.0:
1724 |   version "0.1.0"
1725 |   resolved "https://registry.yarnpkg.com/urix/-/urix-0.1.0.tgz#da937f7a62e21fec1fd18d49b35c2935067a6c72"
1726 |   integrity sha1-2pN/emLiH+wf0Y1Js1wpNQZ6bHI=
1727 | 
1728 | use@^3.1.0:
1729 |   version "3.1.1"
1730 |   resolved "https://registry.yarnpkg.com/use/-/use-3.1.1.tgz#d50c8cac79a19fbc20f2911f56eb973f4e10070f"
1731 |   integrity sha512-cwESVXlO3url9YWlFW/TA9cshCEhtu7IKJ/p5soJ/gGpj7vbvFrAY/eIioQ6Dw23KjZhYgiIo8HOs1nQ2vr/oQ==
1732 | 
1733 | validate-npm-package-license@^3.0.1:
1734 |   version "3.0.4"
1735 |   resolved "https://registry.yarnpkg.com/validate-npm-package-license/-/validate-npm-package-license-3.0.4.tgz#fc91f6b9c7ba15c857f4cb2c5defeec39d4f410a"
1736 |   integrity sha512-DpKm2Ui/xN7/HQKCtpZxoRWBhZ9Z0kqtygG8XCgNQ8ZlDnxuQmWhj566j8fN4Cu3/JmbhsDo7fcAJq4s9h27Ew==
1737 |   dependencies:
1738 |     spdx-correct "^3.0.0"
1739 |     spdx-expression-parse "^3.0.0"
1740 | 
1741 | validate-npm-package-name@^3.0.0:
1742 |   version "3.0.0"
1743 |   resolved "https://registry.yarnpkg.com/validate-npm-package-name/-/validate-npm-package-name-3.0.0.tgz#5fa912d81eb7d0c74afc140de7317f0ca7df437e"
1744 |   integrity sha1-X6kS2B630MdK/BQN5zF/DKffQ34=
1745 |   dependencies:
1746 |     builtins "^1.0.3"
1747 | 
1748 | which-module@^2.0.0:
1749 |   version "2.0.0"
1750 |   resolved "https://registry.yarnpkg.com/which-module/-/which-module-2.0.0.tgz#d9ef07dce77b9902b8a3a8fa4b31c3e3f7e6e87a"
1751 |   integrity sha1-2e8H3Od7mQK4o6j6SzHD4/fm6Ho=
1752 | 
1753 | which@1.3.1:
1754 |   version "1.3.1"
1755 |   resolved "https://registry.yarnpkg.com/which/-/which-1.3.1.tgz#a45043d54f5805316da8d62f9f50918d3da70b0a"
1756 |   integrity sha512-HxJdYWq1MTIQbJ3nw0cqssHoTNU267KlrDuGZ1WYlxDStUtKUhOaJmh112/TZmHxxUfuJqPXSOm7tDyas0OSIQ==
1757 |   dependencies:
1758 |     isexe "^2.0.0"
1759 | 
1760 | wide-align@1.1.3:
1761 |   version "1.1.3"
1762 |   resolved "https://registry.yarnpkg.com/wide-align/-/wide-align-1.1.3.tgz#ae074e6bdc0c14a431e804e624549c633b000457"
1763 |   integrity sha512-QGkOQc8XL6Bt5PwnsExKBPuMKBxnGxWWW3fU55Xt4feHozMUhdUMaBCk290qpm/wG5u/RSKzwdAC4i51YigihA==
1764 |   dependencies:
1765 |     string-width "^1.0.2 || 2"
1766 | 
1767 | wordwrap@~0.0.2:
1768 |   version "0.0.3"
1769 |   resolved "https://registry.yarnpkg.com/wordwrap/-/wordwrap-0.0.3.tgz#a3d5da6cd5c0bc0008d37234bbaf1bed63059107"
1770 |   integrity sha1-o9XabNXAvAAI03I0u68b7WMFkQc=
1771 | 
1772 | wordwrapjs@^3.0.0:
1773 |   version "3.0.0"
1774 |   resolved "https://registry.yarnpkg.com/wordwrapjs/-/wordwrapjs-3.0.0.tgz#c94c372894cadc6feb1a66bff64e1d9af92c5d1e"
1775 |   integrity sha512-mO8XtqyPvykVCsrwj5MlOVWvSnCdT+C+QVbm6blradR7JExAhbkZ7hZ9A+9NUtwzSqrlUo9a67ws0EiILrvRpw==
1776 |   dependencies:
1777 |     reduce-flatten "^1.0.1"
1778 |     typical "^2.6.1"
1779 | 
1780 | wrap-ansi@^5.1.0:
1781 |   version "5.1.0"
1782 |   resolved "https://registry.yarnpkg.com/wrap-ansi/-/wrap-ansi-5.1.0.tgz#1fd1f67235d5b6d0fee781056001bfb694c03b09"
1783 |   integrity sha512-QC1/iN/2/RPVJ5jYK8BGttj5z83LmSKmvbvrXPNCLZSEb32KKVDJDl/MOt2N01qU2H/FkzEa9PKto1BqDjtd7Q==
1784 |   dependencies:
1785 |     ansi-styles "^3.2.0"
1786 |     string-width "^3.0.0"
1787 |     strip-ansi "^5.0.0"
1788 | 
1789 | wrappy@1:
1790 |   version "1.0.2"
1791 |   resolved "https://registry.yarnpkg.com/wrappy/-/wrappy-1.0.2.tgz#b5243d8f3ec1aa35f1364605bc0d1036e30ab69f"
1792 |   integrity sha1-tSQ9jz7BqjXxNkYFvA0QNuMKtp8=
1793 | 
1794 | y18n@^4.0.0:
1795 |   version "4.0.0"
1796 |   resolved "https://registry.yarnpkg.com/y18n/-/y18n-4.0.0.tgz#95ef94f85ecc81d007c264e190a120f0a3c8566b"
1797 |   integrity sha512-r9S/ZyXu/Xu9q1tYlpsLIsa3EeLXXk0VwlxqTcFRfg9EhMW+17kbt9G0NrgCmhGb5vT2hyhJZLfDGx+7+5Uj/w==
1798 | 
1799 | yargs-parser@13.1.1, yargs-parser@^13.1.1:
1800 |   version "13.1.1"
1801 |   resolved "https://registry.yarnpkg.com/yargs-parser/-/yargs-parser-13.1.1.tgz#d26058532aa06d365fe091f6a1fc06b2f7e5eca0"
1802 |   integrity sha512-oVAVsHz6uFrg3XQheFII8ESO2ssAf9luWuAd6Wexsu4F3OtIW0o8IribPXYrD4WC24LWtPrJlGy87y5udK+dxQ==
1803 |   dependencies:
1804 |     camelcase "^5.0.0"
1805 |     decamelize "^1.2.0"
1806 | 
1807 | yargs-unparser@1.6.0:
1808 |   version "1.6.0"
1809 |   resolved "https://registry.yarnpkg.com/yargs-unparser/-/yargs-unparser-1.6.0.tgz#ef25c2c769ff6bd09e4b0f9d7c605fb27846ea9f"
1810 |   integrity sha512-W9tKgmSn0DpSatfri0nx52Joq5hVXgeLiqR/5G0sZNDoLZFOr/xjBUDcShCOGNsBnEMNo1KAMBkTej1Hm62HTw==
1811 |   dependencies:
1812 |     flat "^4.1.0"
1813 |     lodash "^4.17.15"
1814 |     yargs "^13.3.0"
1815 | 
1816 | yargs@13.3.0, yargs@^13.3.0:
1817 |   version "13.3.0"
1818 |   resolved "https://registry.yarnpkg.com/yargs/-/yargs-13.3.0.tgz#4c657a55e07e5f2cf947f8a366567c04a0dedc83"
1819 |   integrity sha512-2eehun/8ALW8TLoIl7MVaRUrg+yCnenu8B4kBlRxj3GJGDKU1Og7sMXPNm1BYyM1DOJmTZ4YeN/Nwxv+8XJsUA==
1820 |   dependencies:
1821 |     cliui "^5.0.0"
1822 |     find-up "^3.0.0"
1823 |     get-caller-file "^2.0.1"
1824 |     require-directory "^2.1.1"
1825 |     require-main-filename "^2.0.0"
1826 |     set-blocking "^2.0.0"
1827 |     string-width "^3.0.0"
1828 |     which-module "^2.0.0"
1829 |     y18n "^4.0.0"
1830 |     yargs-parser "^13.1.1"
1831 | 


--------------------------------------------------------------------------------
/test_macro/.gitignore:
--------------------------------------------------------------------------------
1 | native/target
2 | native/index.node
3 | native/artifacts.json
4 | **/*~
5 | **/node_modules
6 | **/.DS_Store
7 | 


--------------------------------------------------------------------------------
/test_macro/__tests__/macros.js:
--------------------------------------------------------------------------------
 1 | const native = require('../native');
 2 | const expect = require('expect');
 3 | 
 4 | describe('macro functions', () => {
 5 |     it('Hello, World!', () => {
 6 |         expect(native.say_hello('World')).toBe('Hello, World!');
 7 |         expect(native.say_hello('Alice')).toBe('Hello, Alice!');
 8 |         expect(native.say_hello('Bob')).toBe('Hello, Bob!');
 9 |     })
10 | 
11 |     it("Greet users", () => {
12 |         expect(native.greet({ name: 'Bob', age: 32 })).toBe('Bob is 32 years old');
13 |         expect(native.greet({ name: 'Alice', age: 27 })).toBe('Alice is 27 years old');
14 |     })
15 | 
16 |     it("fibonacci", () => {
17 |         expect(native.fibonacci(5)).toBe(5);
18 |         expect(native.fibonacci(10)).toBe(55);
19 |     })
20 | 
21 |     it("buffers", () => {
22 |         expect(native.sort_utf8_bytes("hello world"))
23 |           .toEqual(new Buffer(" dehllloorw", 'ascii'))
24 | 
25 |         native.expect_buffer_only(new Buffer('000011110000', 'hex'))
26 |         expect(() => {
27 |           native.expect_buffer_only([1, 2, 3, 4])
28 |         }).toThrow(/failed downcast to Buffer/)
29 | 
30 |         native.expect_array([0,0,0,0])
31 |     })
32 | 
33 |     describe("maybe_say_hello", () => {
34 |         it("existing user", () => {
35 |             expect(native.maybe_say_hello({ name: 'Bob', age: 32 })).toBe('Bob is 32 years old');
36 |         })
37 | 
38 |         it("null user", () => {
39 |             expect(native.maybe_say_hello()).toBe(null);
40 |             expect(native.maybe_say_hello(undefined)).toBe(null);
41 |             expect(native.maybe_say_hello(null)).toBe(null);
42 |         })
43 |     })
44 | });
45 | 


--------------------------------------------------------------------------------
/test_macro/lib/index.js:
--------------------------------------------------------------------------------
1 | var addon = require('../native');
2 | 


--------------------------------------------------------------------------------
/test_macro/native/Cargo.toml:
--------------------------------------------------------------------------------
 1 | [package]
 2 | name = "test"
 3 | version = "0.1.0"
 4 | authors = ["Gabriel Castro <dev@GabrielCastro.ca>"]
 5 | license = "MIT"
 6 | build = "build.rs"
 7 | publish = false
 8 | 
 9 | [lib]
10 | name = "test"
11 | crate-type = ["dylib"]
12 | 
13 | [build-dependencies]
14 | neon-build = "0.4.0"
15 | 
16 | [dependencies]
17 | neon = "0.4.0"
18 | neon-serde = { path = "../../" }
19 | serde_derive = "1.0.106"
20 | serde = "1.0.106"
21 | serde_bytes = "0.11.3"
22 | 
23 | [profile.dev]
24 | codegen-units = 4
25 | lto = false
26 | 
27 | [profile.release]
28 | codegen-units = 4
29 | lto = false
30 | 


--------------------------------------------------------------------------------
/test_macro/native/build.rs:
--------------------------------------------------------------------------------
1 | extern crate neon_build;
2 | 
3 | fn main() {
4 |     neon_build::setup(); // must be called in build.rs
5 | 
6 |     // add project-specific build logic here...
7 | }
8 | 


--------------------------------------------------------------------------------
/test_macro/native/src/lib.rs:
--------------------------------------------------------------------------------
 1 | #[macro_use]
 2 | extern crate neon;
 3 | #[macro_use]
 4 | extern crate neon_serde;
 5 | #[macro_use]
 6 | extern crate serde_derive;
 7 | extern crate serde_bytes;
 8 | 
 9 | #[derive(Deserialize)]
10 | struct User {
11 |     name: String,
12 |     age: u16,
13 | }
14 | 
15 | export! {
16 | 
17 |     /// Say hello based on a persons name
18 |     fn say_hello(name: String) -> String {
19 |         format!("Hello, {}!", name)
20 |     }
21 | 
22 |     /// Say how old someone is
23 |     fn greet(user: User) -> String {
24 |         format!("{} is {} years old", user.name, user.age)
25 |     }
26 | 
27 |     /// Say how old someone is, if they exist
28 |     fn maybe_say_hello(user: Option<User>) -> Option<String> {
29 |         user.map(greet)
30 |     }
31 | 
32 |     /// Sorts the bytes in a string
33 |     /// use `serde_bytes::ByteBuf` to return a `Buffer` in node
34 |     /// a `Vec<u8>` will be an array
35 |     fn sort_utf8_bytes(str: String) -> serde_bytes::ByteBuf {
36 |         let mut bytes = str.into_bytes();
37 |         bytes.sort();
38 |         serde_bytes::ByteBuf::from(bytes)
39 |     }
40 | 
41 |     /// using `serde_bytes::ByteBuf` will make passing an array
42 |     /// of numbers an error
43 |     ///
44 |     /// note: `-> ()` is NOT optional
45 |     fn expect_buffer_only(_buff: serde_bytes::ByteBuf) -> () {
46 |         // code
47 |     }
48 | 
49 |     /// using `Vec<u8>` not accept a buffer
50 |     fn expect_array(_buff: Vec<u8>) -> () {
51 |         // code
52 |     }
53 | 
54 |     /// calculate fibonacci recursively
55 |     fn fibonacci(n: i32) -> i32 {
56 |         match n {
57 |             1 | 2 => 1,
58 |             n => fibonacci(n - 1) + fibonacci(n - 2)
59 |         }
60 |     }
61 | }
62 | 


--------------------------------------------------------------------------------
/test_macro/package.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "name": "test",
 3 |   "version": "0.1.0",
 4 |   "description": "",
 5 |   "main": "lib/index.js",
 6 |   "author": "Gabriel Castro <dev@GabrielCastro.ca>",
 7 |   "license": "MIT",
 8 |   "devDependencies": {
 9 |     "expect": "^24.9.0",
10 |     "mocha": "^6.2.3",
11 |     "neon-cli": "^0.4.0"
12 |   },
13 |   "scripts": {
14 |     "build": "neon build --release",
15 |     "build:debug": "neon build",
16 |     "test": "neon build && mocha __tests__"
17 |   }
18 | }


--------------------------------------------------------------------------------