pshenmic-dpp 1.0.0

package/packages/public_key/src/lib.rs

@@ -0,0 +1,125 @@
+use dpp::identity::identity_public_key::accessors::v0::{
+    IdentityPublicKeyGettersV0, IdentityPublicKeySettersV0,
+};
+use dpp::identity::identity_public_key::v0::IdentityPublicKeyV0;
+use dpp::identity::{IdentityPublicKey, KeyType, Purpose, SecurityLevel, TimestampMillis};
+use dpp::platform_value::BinaryData;
+use dpp::platform_value::string_encoding::Encoding::Hex;
+use js_sys::Boolean;
+use pshenmic_dpp_enums::keys::key_type::KeyTypeWASM;
+use pshenmic_dpp_enums::keys::purpose::PurposeWASM;
+use pshenmic_dpp_enums::keys::security_level::SecurityLevelWASM;
+use wasm_bindgen::prelude::wasm_bindgen;
+
+#[wasm_bindgen(js_name = IdentityPublicKeyWASM)]
+pub struct IdentityPublicKeyWASM {
+    public_key: IdentityPublicKey,
+}
+
+#[wasm_bindgen]
+impl IdentityPublicKeyWASM {
+    #[wasm_bindgen]
+    pub fn new(
+        id: u32,
+        purpose: PurposeWASM,
+        security_level: SecurityLevelWASM,
+        key_type: KeyTypeWASM,
+        read_only: Boolean,
+        binary_data: &str,
+        disabled_at: Option<TimestampMillis>,
+    ) -> Self {
+        IdentityPublicKeyWASM {
+            public_key: IdentityPublicKey::from(IdentityPublicKeyV0 {
+                id,
+                purpose: Purpose::from(purpose),
+                security_level: SecurityLevel::from(security_level),
+                contract_bounds: None,
+                key_type: KeyType::from(key_type),
+                read_only: read_only.as_bool().unwrap(),
+                data: BinaryData::from_string(binary_data, Hex).unwrap(),
+                disabled_at,
+            }),
+        }
+    }
+}
+
+impl IdentityPublicKeyWASM {
+    pub fn get_key(&self) -> IdentityPublicKey {
+        self.public_key.clone()
+    }
+}
+
+#[wasm_bindgen]
+impl IdentityPublicKeyWASM {
+    #[wasm_bindgen(js_name = getKeyId)]
+    pub fn get_key_id(&self) -> u32 {
+        self.public_key.id()
+    }
+
+    #[wasm_bindgen(js_name = getPurpose)]
+    pub fn get_purpose(&self) -> PurposeWASM {
+        PurposeWASM::from(self.public_key.purpose())
+    }
+
+    #[wasm_bindgen(js_name = getSecurityLevel)]
+    pub fn get_security_level(&self) -> SecurityLevelWASM {
+        SecurityLevelWASM::from(self.public_key.security_level())
+    }
+
+    #[wasm_bindgen(js_name = getKeyType)]
+    pub fn get_key_type(&self) -> KeyTypeWASM {
+        KeyTypeWASM::from(self.public_key.key_type())
+    }
+
+    #[wasm_bindgen(js_name = getReadOnly)]
+    pub fn get_read_only(&self) -> bool {
+        self.public_key.read_only()
+    }
+
+    #[wasm_bindgen(js_name = getData)]
+    pub fn get_data(&self) -> String {
+        self.public_key.data().to_string(Hex)
+    }
+
+    #[wasm_bindgen(js_name = getDisabledAt)]
+    pub fn get_disabled_at(&self) -> Option<u64> {
+        self.public_key.disabled_at()
+    }
+
+    #[wasm_bindgen(js_name = setKeyId)]
+    pub fn set_key_id(&mut self, key_id: u32) {
+        self.public_key.set_id(key_id)
+    }
+
+    #[wasm_bindgen(js_name = setPurpose)]
+    pub fn set_purpose(&mut self, purpose: PurposeWASM) {
+        self.public_key.set_purpose(Purpose::from(purpose))
+    }
+
+    #[wasm_bindgen(js_name = setSecurityLevel)]
+    pub fn set_security_level(&mut self, security_level: SecurityLevelWASM) {
+        self.public_key
+            .set_security_level(SecurityLevel::from(security_level))
+    }
+
+    #[wasm_bindgen(js_name = setKeyType)]
+    pub fn set_key_type(&mut self, key_type: KeyTypeWASM) {
+        self.public_key.set_key_type(KeyType::from(key_type))
+    }
+
+    #[wasm_bindgen(js_name = setReadOnly)]
+    pub fn set_read_only(&mut self, read_only: Boolean) {
+        self.public_key.set_read_only(read_only.as_bool().unwrap())
+    }
+
+    #[wasm_bindgen(js_name = setData)]
+    pub fn set_data(&mut self, binary_data: &str) {
+        let data = BinaryData::from_string(binary_data, Hex).unwrap();
+        self.public_key.set_data(data)
+    }
+
+    #[wasm_bindgen(js_name = setDisabledAt)]
+    pub fn set_disabled_at(&mut self, disabled_at: u64) {
+        self.public_key.set_disabled_at(disabled_at)
+    }
+}

package/packages/utils/Cargo.toml

@@ -0,0 +1,20 @@
+[package]
+name = "pshenmic_dpp_utils"
+version = "0.1.0"
+edition = "2024"
+
+[lib]
+crate-type = ["cdylib", "lib"]
+
+[dependencies]
+wasm-bindgen = { version = "=0.2.100", features = ["serde-serialize"] }
+anyhow = { version = "1.0.75" }
+dpp = { git = "https://github.com/dashpay/platform", branch = "master", features = [
+    "platform-value",
+    "document-json-conversion"
+]}
+js-sys = "0.3.53"
+serde_json = { version = "1.0", features = ["preserve_order"] }
+serde-wasm-bindgen = { git = "https://github.com/QuantumExplorer/serde-wasm-bindgen", branch = "feat/not_human_readable" }
+serde = { version = "1.0.197", features = ["derive"] }
+itertools = { version = "0.13" }

package/packages/utils/src/buffer.rs

@@ -0,0 +1,29 @@
+use js_sys::ArrayBuffer;
+use wasm_bindgen::prelude::*;
+
+#[wasm_bindgen]
+extern "C" {
+    #[derive(PartialEq, Debug)]
+    pub type Buffer;
+
+    #[wasm_bindgen(constructor)]
+    pub fn new() -> Buffer;
+
+    #[wasm_bindgen(static_method_of = Buffer, js_name = from)]
+    pub fn from_bytes(js_sys: &[u8]) -> Buffer;
+
+    #[wasm_bindgen(static_method_of = Buffer, js_name = from)]
+    pub fn from_bytes_owned(js_sys: Vec<u8>) -> Buffer;
+
+    #[wasm_bindgen(static_method_of = Buffer, js_name = from)]
+    pub fn from_string(js_sys: String) -> Buffer;
+
+    #[wasm_bindgen(method, getter)]
+    pub fn buffer(this: &Buffer) -> ArrayBuffer;
+
+    #[wasm_bindgen(method, getter, js_name = byteOffset)]
+    pub fn byte_offset(this: &Buffer) -> u32;
+
+    #[wasm_bindgen(method, getter)]
+    pub fn length(this: &Buffer) -> u32;
+}

package/packages/utils/src/lib.rs

@@ -0,0 +1,351 @@
+mod buffer;
+
+use anyhow::{Context, anyhow, bail};
+use dpp::ProtocolError;
+use dpp::identifier::Identifier;
+use dpp::platform_value::Value;
+use dpp::platform_value::string_encoding::Encoding;
+use dpp::util::hash::hash_double_to_vec;
+use itertools::Itertools;
+use js_sys::Function;
+use serde::de::DeserializeOwned;
+use serde_json::Value as JsonValue;
+use std::collections::BTreeMap;
+use std::convert::TryInto;
+use wasm_bindgen::JsValue;
+use wasm_bindgen::{convert::RefFromWasmAbi, prelude::*};
+
+pub trait ToSerdeJSONExt {
+    fn with_serde_to_json_value(&self) -> Result<JsonValue, JsValue>;
+    fn with_serde_to_platform_value(&self) -> Result<Value, JsValue>;
+    /// Converts the `JsValue` into `platform::Value`. It's an expensive conversion,
+    /// as `JsValue` must be stringified first
+    fn with_serde_to_platform_value_map(&self) -> Result<BTreeMap<String, Value>, JsValue>;
+    fn with_serde_into<D: DeserializeOwned>(&self) -> Result<D, JsValue>
+    where
+        D: for<'de> serde::de::Deserialize<'de> + 'static;
+}
+
+impl ToSerdeJSONExt for JsValue {
+    /// Converts the `JsValue` into `serde_json::Value`. It's an expensive conversion,
+    /// as `JsValue` must be stringified first
+    fn with_serde_to_json_value(&self) -> Result<JsonValue, JsValue> {
+        with_serde_to_json_value(self.clone())
+    }
+
+    /// Converts the `JsValue` into `platform::Value`. It's an expensive conversion,
+    /// as `JsValue` must be stringified first
+    fn with_serde_to_platform_value(&self) -> Result<Value, JsValue> {
+        with_serde_to_platform_value(self)
+    }
+
+    /// Converts the `JsValue` into `platform::Value`. It's an expensive conversion,
+    /// as `JsValue` must be stringified first
+    fn with_serde_to_platform_value_map(&self) -> Result<BTreeMap<String, Value>, JsValue> {
+        self.with_serde_to_platform_value()?
+            .into_btree_string_map()
+            .map_err(ProtocolError::ValueError)
+            .with_js_error()
+    }
+
+    /// converts the `JsValue` into any type that is supported by serde. It's an expensive conversion
+    /// as the `jsValue` must be stringified first
+    fn with_serde_into<D>(&self) -> Result<D, JsValue>
+    where
+        D: for<'de> serde::de::Deserialize<'de> + 'static,
+    {
+        with_serde_into(self)
+    }
+}
+
+pub fn to_vec_js<T>(iter: impl IntoIterator<Item = T>) -> Vec<JsValue>
+where
+    T: Into<JsValue>,
+{
+    iter.into_iter().map(|v| v.into()).collect()
+}
+
+#[allow(dead_code)]
+#[deprecated(note = "This function is marked as unused.")]
+#[allow(deprecated)]
+pub fn to_vec_of_serde_values(
+    values: impl IntoIterator<Item = impl AsRef<JsValue>>,
+) -> Result<Vec<JsonValue>, JsValue> {
+    values
+        .into_iter()
+        .map(|v| v.as_ref().with_serde_to_json_value())
+        .collect()
+}
+
+pub fn to_vec_of_platform_values(
+    values: impl IntoIterator<Item = impl AsRef<JsValue>>,
+) -> Result<Vec<Value>, JsValue> {
+    values
+        .into_iter()
+        .map(|v| v.as_ref().with_serde_to_platform_value())
+        .collect()
+}
+
+pub fn into_vec_of<T>(iter: &[JsValue]) -> Vec<T>
+where
+    T: for<'de> serde::de::Deserialize<'de>,
+{
+    iter.iter()
+        .map(|v| serde_wasm_bindgen::from_value(v.clone()).expect("data malformed"))
+        .collect()
+}
+
+pub fn with_serde_to_json_value(data: JsValue) -> Result<JsonValue, JsValue> {
+    let data = stringify(&data)?;
+    let value: JsonValue = serde_json::from_str(&data)
+        .with_context(|| format!("cant convert {data:#?} to serde json value"))
+        .map_err(|e| format!("{e:#}"))?;
+    Ok(value)
+}
+
+pub fn with_serde_to_platform_value(data: &JsValue) -> Result<Value, JsValue> {
+    Ok(with_serde_to_json_value(data.clone())?.into())
+}
+
+pub fn with_serde_into<D>(data: &JsValue) -> Result<D, JsValue>
+where
+    D: for<'de> serde::de::Deserialize<'de> + 'static,
+{
+    let data = stringify(data)?;
+    let value: D = serde_json::from_str(&data)
+        .with_context(|| format!("cant convert {:#?} to serde json value", data))
+        .map_err(|e| format!("{:#}", e))?;
+    Ok(value)
+}
+
+pub fn stringify(data: &JsValue) -> Result<String, JsValue> {
+    let replacer_func = Function::new_with_args(
+        "key, value",
+        "return (value != undefined && value.type=='Buffer')  ? value.data : value ",
+    );
+
+    let data_string: String =
+        js_sys::JSON::stringify_with_replacer(data, &JsValue::from(replacer_func))?.into();
+
+    Ok(data_string)
+}
+
+pub trait WithJsError<T> {
+    /// Converts the error into JsValue
+    fn with_js_error(self) -> Result<T, JsValue>;
+}
+
+impl<T> WithJsError<T> for Result<T, anyhow::Error> {
+    fn with_js_error(self) -> Result<T, JsValue> {
+        match self {
+            Ok(ok) => Ok(ok),
+            Err(error) => Err(format!("{error:#}").into()),
+        }
+    }
+}
+
+impl<T> WithJsError<T> for Result<T, ProtocolError> {
+    fn with_js_error(self) -> Result<T, JsValue> {
+        match self {
+            Ok(ok) => Ok(ok),
+            Err(error) => Err(JsValue::from_str(&error.to_string())),
+        }
+    }
+}
+
+pub trait IntoWasm {
+    fn to_wasm<T: RefFromWasmAbi<Abi = u32>>(&self, class_name: &str)
+    -> Result<T::Anchor, JsValue>;
+}
+
+impl IntoWasm for JsValue {
+    fn to_wasm<T: RefFromWasmAbi<Abi = u32>>(
+        &self,
+        class_name: &str,
+    ) -> Result<T::Anchor, JsValue> {
+        generic_of_js_val::<T>(self, class_name)
+    }
+}
+
+pub fn generic_of_js_val<T: RefFromWasmAbi<Abi = u32>>(
+    js_value: &JsValue,
+    class_name: &str,
+) -> Result<T::Anchor, JsValue> {
+    if !js_value.is_object() {
+        return Err(JsError::new(
+            format!("Value supplied as {} is not an object", class_name).as_str(),
+        )
+        .into());
+    }
+
+    let ctor_name = js_sys::Object::get_prototype_of(js_value)
+        .constructor()
+        .name();
+
+    if ctor_name == class_name {
+        let ptr = js_sys::Reflect::get(js_value, &JsValue::from_str("__wbg_ptr"))?;
+        let ptr_u32: u32 = ptr
+            .as_f64()
+            .ok_or_else(|| JsValue::from(JsError::new("Invalid JS object pointer")))?
+            as u32;
+        let reference = unsafe { T::ref_from_abi(ptr_u32) };
+        Ok(reference)
+    } else {
+        let error_string = format!(
+            "JS object constructor name mismatch. Expected {}, provided {}.",
+            class_name, ctor_name
+        );
+        Err(JsError::new(&error_string).into())
+    }
+}
+
+pub const SKIP_VALIDATION_PROPERTY_NAME: &str = "skipValidation";
+
+pub fn get_bool_from_options(
+    options: JsValue,
+    property: &str,
+    default: bool,
+) -> Result<bool, JsValue> {
+    if options.is_object() {
+        let val2 = options.with_serde_to_json_value()?;
+        let kek = val2
+            .as_object()
+            .ok_or_else(|| JsError::new("Can't parse options"))?;
+        let kek2 = kek
+            .get(property)
+            .ok_or_else(|| JsError::new(&format!("Can't get property {} of options", property)))?;
+        Ok(kek2
+            .as_bool()
+            .ok_or_else(|| JsError::new(&format!("Option {} is not a boolean", property)))?)
+    } else {
+        Ok(default)
+    }
+}
+
+#[allow(dead_code)]
+#[deprecated(note = "This function is marked as unused.")]
+#[allow(deprecated)]
+pub fn get_class_name(value: &JsValue) -> String {
+    js_sys::Object::get_prototype_of(value)
+        .constructor()
+        .name()
+        .into()
+}
+
+#[allow(dead_code)]
+#[deprecated(note = "This function is marked as unused.")]
+#[allow(deprecated)]
+pub fn try_to_u64(value: JsValue) -> Result<u64, anyhow::Error> {
+    if value.is_bigint() {
+        js_sys::BigInt::new(&value)
+            .map_err(|e| anyhow!("unable to create bigInt: {}", e.to_string()))?
+            .try_into()
+            .map_err(|e| anyhow!("conversion of BigInt to u64 failed: {:#}", e))
+    } else if value.as_f64().is_some() {
+        let number = js_sys::Number::from(value);
+        convert_number_to_u64(number)
+    } else {
+        bail!("supported types are Number or BigInt")
+    }
+}
+
+pub fn convert_number_to_u64(js_number: js_sys::Number) -> Result<u64, anyhow::Error> {
+    if let Some(float_number) = js_number.as_f64() {
+        if float_number.is_nan() || float_number.is_infinite() {
+            bail!("received an invalid timestamp: the number is either NaN or Inf")
+        }
+        if float_number < 0. {
+            bail!("received an invalid timestamp: the number is negative");
+        }
+        if float_number.fract() != 0. {
+            bail!("received an invalid timestamp: the number is fractional")
+        }
+        if float_number > u64::MAX as f64 {
+            bail!("received an invalid timestamp: the number is > u64::max")
+        }
+
+        return Ok(float_number as u64);
+    }
+    bail!("the value is not a number")
+}
+
+pub fn generate_document_id_v0(
+    contract_id: &Identifier,
+    owner_id: &Identifier,
+    document_type_name: &str,
+    entropy: &[u8],
+) -> Identifier {
+    let mut buf: Vec<u8> = vec![];
+
+    buf.extend_from_slice(&contract_id.to_buffer());
+    buf.extend_from_slice(&owner_id.to_buffer());
+    buf.extend_from_slice(document_type_name.as_bytes());
+    buf.extend_from_slice(entropy);
+
+    Identifier::from_bytes(&hash_double_to_vec(&buf)).unwrap()
+}
+
+#[wasm_bindgen(raw_module = "../identifier_utils/Identifier.js")]
+extern "C" {
+    #[derive(Debug, Clone)]
+    #[wasm_bindgen(js_name = default)]
+    pub type IdentifierWrapper; // Rename to IdentifierJS?
+
+    #[wasm_bindgen(constructor, js_class=default)]
+    pub fn new(buffer: JsValue) -> IdentifierWrapper;
+
+    #[wasm_bindgen(method, js_name=toBuffer)]
+    pub fn to_buffer(this: &IdentifierWrapper) -> Vec<u8>;
+}
+
+impl From<Identifier> for IdentifierWrapper {
+    fn from(s: Identifier) -> Self {
+        IdentifierWrapper::new(buffer::Buffer::from_bytes(s.as_slice()).into())
+    }
+}
+
+impl From<IdentifierWrapper> for Identifier {
+    fn from(s: IdentifierWrapper) -> Self {
+        Identifier::from_bytes(&s.to_buffer()).unwrap()
+    }
+}
+
+impl From<&IdentifierWrapper> for Identifier {
+    fn from(s: &IdentifierWrapper) -> Self {
+        Identifier::from_bytes(&s.to_buffer()).unwrap()
+    }
+}
+
+// Try to extract Identifier from **stringified** identifier_utils.
+// The `js_value` can be a stringified instance of: `Identifier`, `Buffer` or `Array`
+pub fn identifier_from_js_value(js_value: &JsValue) -> Result<Identifier, JsValue> {
+    if js_value.is_undefined() || js_value.is_null() {
+        wasm_bindgen::throw_val(JsValue::from_str(
+            "the identifier cannot be null or undefined",
+        ));
+    }
+
+    let value: serde_json::Value = js_value.with_serde_to_json_value()?;
+    match value {
+        serde_json::Value::Array(arr) => {
+            let bytes: Vec<u8> = arr.into_iter().map(value_to_u8).try_collect()?;
+            Identifier::from_bytes(&bytes)
+                .map_err(ProtocolError::ValueError)
+                .with_js_error()
+        }
+        serde_json::Value::String(string) => Identifier::from_string(&string, Encoding::Base58)
+            .map_err(ProtocolError::ValueError)
+            .with_js_error(),
+        _ => Err(JsValue::from_str("Invalid ID. Expected array or string")),
+    }
+}
+
+pub fn value_to_u8(v: serde_json::Value) -> Result<u8, JsValue> {
+    let number = v
+        .as_u64()
+        .ok_or_else(|| format!("failed converting {} into u64", v))?;
+    if number > u8::MAX as u64 {
+        JsValue::from_str("the integer in the array isn't a byte");
+    }
+    Ok(number as u8)
+}

package/scripts/build-js.sh

@@ -0,0 +1,38 @@
+#!/usr/bin/env bash
+
+## Paths to distributive that exposed to library consumers
+DIST_DIR="$PWD/dist"
+DIST_WASM_DIR="$DIST_DIR/wasm"
+DIST_WASM_BINARY_BASE_64="$DIST_WASM_DIR/pshenmic_dpp_bg.js"
+DIST_WASM_BINARY_RAW="$DIST_WASM_DIR/pshenmic_dpp_bg.wasm"
+DIST_WASM_JS="$DIST_WASM_DIR/pshenmic_dpp.js"
+
+## Paths to wasm files produced by wasm-bindgen
+WASM_DIR="$PWD/wasm"
+WASM_JS_CODE_PATH="$WASM_DIR/pshenmic_dpp.js"
+WASM_BINARY_PATH="$WASM_DIR/pshenmic_dpp_bg.wasm"
+
+# Create directory in dist to save transpiled wasm code and TS typings
+mkdir -p $DIST_WASM_DIR
+
+## Converting wasm into base64 and saving it to dist folder
+
+rm -rf $DIST_WASM_BINARY_BASE_64
+rm -rf $DIST_WASM_BINARY_RAW
+rm -rf $DIST_WASM_JS
+
+if [[ "${RAW}" == "true" ]]; then
+  cp $WASM_BINARY_PATH $DIST_WASM_BINARY_RAW
+else
+  echo "Converting wasm binary into base64 module"
+  WASM_BUILD_BASE_64=$(base64 -i "$WASM_BINARY_PATH")
+  echo 'module.exports = "'${WASM_BUILD_BASE_64}'"' > "$DIST_WASM_BINARY_BASE_64"
+fi
+
+## Transpile ES Modules code to Common JS
+## and save directly to dist folder to avoid re-generating TS declarations
+echo "Transpiling wasm ES Modules to CommonJS"
+cp $WASM_JS_CODE_PATH $DIST_WASM_JS
+
+echo "Cleaning wasm build"
+rm -rf $WASM_DIR

package/scripts/build.sh

@@ -0,0 +1,35 @@
+#!/usr/bin/env bash
+# shellcheck disable=SC2312
+
+TARGET=wasm32-unknown-unknown
+
+OUTPUT_DIR="${PWD}/wasm"
+CARGO_BUILD_PROFILE="${CARGO_BUILD_PROFILE:-dev}"
+PROFILE_ARG="--profile ${CARGO_BUILD_PROFILE}"
+PROFILE=debug
+
+OUTPUT_FILE="${PWD}/wasm/pshenmic_dpp_bg.wasm"
+
+BUILD_COMMAND="cargo build --config net.git-fetch-with-cli=true --target=${TARGET} ${PROFILE_ARG}"
+BINDGEN_COMMAND="wasm-bindgen --out-dir=${OUTPUT_DIR} --target=web --omit-default-module-path ${PWD}/target/${TARGET}/${PROFILE}/pshenmic_dpp.wasm"
+
+if ! [[ -d ${OUTPUT_DIR} ]]; then
+  mkdir -p "${OUTPUT_DIR}"
+fi
+
+if [[ "${OSTYPE}" == "darwin"* ]]; then
+  AR_PATH=$(command -v llvm-ar)
+  CLANG_PATH=$(command -v clang)
+  AR=${AR_PATH} CC=${CLANG_PATH} ${BUILD_COMMAND}
+  AR=${AR_PATH} CC=${CLANG_PATH} ${BINDGEN_COMMAND}
+else
+  ${BUILD_COMMAND}
+  ${BINDGEN_COMMAND}
+fi
+
+if command -v wasm-opt &> /dev/null; then
+  echo "Optimizing wasm using Binaryen"
+  wasm-opt -tnh --flatten --rereloop -Oz --gufa -Oz --gufa -Oz  "$OUTPUT_FILE" -o "${OUTPUT_FILE}"
+else
+  echo "wasm-opt command not found. Skipping wasm optimization."
+fi

package/src/lib.rs

@@ -0,0 +1,2 @@
+pub use pshenmic_dpp_document_batch::DocumentBatchWASM;
+pub use pshenmic_dpp_document_search;

package/tsconfig.json

@@ -0,0 +1,18 @@
+{
+  "compilerOptions": {
+    "outDir": "./dist",
+    "noImplicitAny": true,
+    "module": "commonjs",
+    "target": "es2015",
+    "rootDir": "./lib",
+    "allowJs": false,
+    "moduleResolution": "node",
+    "esModuleInterop": true,
+    "declaration": true,
+    "lib": [
+      "es2015",
+      "dom"
+    ]
+  },
+  "include": ["lib/**/*.ts"],
+}