wip

.editorconfig

+# http://editorconfig.org
+
+root = true
+
+[**]
+indent_style = space
+indent_size = 2
+end_of_line = lf
+charset = utf-8
+trim_trailing_whitespace = true
+insert_final_newline = true

.eslintrc.js

+module.exports = {
+  // Airbnb is the base, prettier is here so that eslint doesn't conflict with prettier
+  extends: ['airbnb', 'prettier'],
+  parser: 'babel-eslint',
+  plugins: ['react', 'import'],
+  rules: {
+    // Parens will be needed for arrow functions
+    'arrow-parens': ['error', 'as-needed', { requireForBlockBody: true }],
+    // Lines will be broken before binary operators
+    'operator-linebreak': ['error', 'before'],
+    // Allow imports from dev and peer dependencies
+    'import/no-extraneous-dependencies': [
+      'error',
+      { devDependencies: true, peerDependencies: true },
+    ],
+    // Allows writing JSX in JS & TS files
+    // 'react/jsx-filename-extension': ['error', { extensions: ['.js', '.ts'] }],
+    // This rule doesn't play nice with Prettier
+    'react/jsx-one-expression-per-line': 'off',
+    // This rule doesn't play nice with Prettier
+    'react/jsx-wrap-multilines': 'off',
+    // Remove this rule because we only destructure props, but never state
+    'react/destructuring-assignment': 'off',
+    // Restrict imports that should be used carefully. Usually we have created a wrapper around them
+  },
+  overrides: [
+    {
+      files: ['*.ts', '*.tsx'],
+      parser: 'typescript-eslint-parser',
+      plugins: ['react', 'import', 'typescript'],
+      rules: {
+        'typescript/adjacent-overload-signatures': 'error',
+        'typescript/explicit-function-return-type': 'error',
+        'typescript/no-angle-bracket-type-assertion': 'error',
+        'typescript/no-empty-interface': 'error',
+        'typescript/no-explicit-any': 'error',
+        'typescript/no-inferrable-types': 'error',
+        'typescript/no-namespace': 'error',
+        'typescript/no-non-null-assertion': 'error',
+        'typescript/no-triple-slash-reference': 'error',
+        'typescript/no-type-alias': 'error',
+        'typescript/prefer-namespace-keyword': 'error',
+        'typescript/type-annotation-spacing': 'error',
+      },
+    },
+  ],
+  settings: {
+    'import/resolver': {
+      node: { extensions: ['.tsx', '.ts'] },
+    },
+    'import/cache:': {
+      lifetime: 2,
+    },
+  },
+};

.prettierrc.js

+// https://prettier.io/docs/en/options.html
+
+module.exports = {
+  // Allow to parse .ts files and TS annotations
+  parser: 'typescript',
+  // Enables semicolons at the end of statements
+  semi: true,
+  // Formats strings with single quotes ('') instead of quotes ("")
+  singleQuote: true,
+  // Adds a trailing comma at the end of all lists (including function arguments)
+  trailingComma: 'all',
+};

.vscode/settings.json

+{
+  "prettier.disableLanguages": [
+    "json"
+  ],
+  "prettier.eslintIntegration": true,
+  "prettier.stylelintIntegration": true,
+  "prettier.singleQuote": true,
+  "prettier.trailingComma": "all",
+}

package.json

   "version": "2.13.0",
   "homepage": "https://github.com/react-native-community/react-native-webview#readme",
   "scripts": {
-    "prebuild": "rimraf lib",
-    "prepare": "npm run build",
-    "build": "tsc -p tsconfig.base.json && cp ./index.js ./lib/index.js",
     "ci:publish": "yarn semantic-release",
-    "ci:test": "yarn ci:test:build",
-    "ci:test:build": "yarn build",
+    "ci:test": "yarn ci:test:tsc",
+    "ci:test:tsc": "yarn tsc --noEmit -p tsconfig.json",
     "semantic-release": "semantic-release"
   },
   "peerDependencies": {
     "@semantic-release/git": "7.0.5",
     "@types/invariant": "^2.2.29",
     "@types/react-native": "^0.57.6",
-    "rimraf": "^2.6.2",
+    "eslint": "5.9.0",
+    "eslint-config-airbnb": "17.1.0",
+    "eslint-config-prettier": "3.3.0",
+    "eslint-plugin-import": "2.14.0",
+    "eslint-plugin-jsx-a11y": "6.1.2",
+    "eslint-plugin-react": "7.11.1",
+    "eslint-plugin-react-native": "3.5.0",
+    "eslint-plugin-typescript": "0.13.0",
+    "prettier-eslint-cli": "4.7.1",
     "semantic-release": "15.10.3",
-    "typescript": "^3.1.6"
+    "typescript": "3.1.6",
+    "typescript-eslint-parser": "21.0.1"
   },
   "repository": {
     "type": "git",
     "url": "https://github.com/react-native-community/react-native-webview.git"
   }
-}
+}

src/WebView.android.tsx

-import React from "react";
+import React from 'react';
 
-import ReactNative from "react-native";
+import ReactNative from 'react-native';
 import {
   ActivityIndicator,
   StyleSheet,
   requireNativeComponent,
   NativeModules,
   Image,
-  NativeSyntheticEvent
-} from "react-native";
+  NativeSyntheticEvent,
+} from 'react-native';
 
-import invariant from "invariant";
+import invariant from 'invariant';
 
-import WebViewShared from "./WebViewShared";
+import WebViewShared from './WebViewShared';
 import {
   WebViewSourceUri,
   WebViewError,
   WebViewNavigationEvent,
   WebViewSharedProps,
   WebViewSource,
-  WebViewProgressEvent
-} from "./types/WebViewTypes";
-import { isWebViewUriSource } from "./utils";
+  WebViewProgressEvent,
+} from './types/WebViewTypes';
+import { isWebViewUriSource } from './utils';
 
 enum WebViewState {
-  IDLE = "IDLE",
-  LOADING = "LOADING",
-  ERROR = "ERROR"
+  IDLE = 'IDLE',
+  LOADING = 'LOADING',
+  ERROR = 'ERROR',
 }
 
 const defaultRenderLoading = () => (
 
 type State = {
   viewState: WebViewState;
-  lastErrorEvent: WebViewError;
+  lastErrorEvent: WebViewError | null;
 };
 
 /**
  * Renders a native WebView.
  */
-export default class WebView extends React.Component<WebViewSharedProps, State> {
+export default class WebView extends React.Component<
+  WebViewSharedProps,
+  State
+> {
   static defaultProps = {
-    overScrollMode: "always",
+    overScrollMode: 'always',
     javaScriptEnabled: true,
     thirdPartyCookiesEnabled: true,
     scalesPageToFit: true,
     allowFileAccess: false,
     saveFormDataDisabled: false,
-    originWhitelist: WebViewShared.defaultOriginWhitelist
+    originWhitelist: WebViewShared.defaultOriginWhitelist,
   };
 
   static isFileUploadSupported = async () => {
     viewState: this.props.startInLoadingState
       ? WebViewState.LOADING
       : WebViewState.IDLE,
-    lastErrorEvent: null
+    lastErrorEvent: null,
   };
 
   webViewRef = React.createRef<React.ComponentClass>();
       otherView = (this.props.renderLoading || defaultRenderLoading)();
     } else if (this.state.viewState === WebViewState.ERROR) {
       const errorEvent = this.state.lastErrorEvent;
-      invariant(errorEvent != null, "lastErrorEvent expected to be non-null");
+      invariant(errorEvent != null, 'lastErrorEvent expected to be non-null');
       otherView =
         this.props.renderError &&
         this.props.renderError(
-          errorEvent.domain,
-          errorEvent.code,
-          errorEvent.description
+          errorEvent!.domain,
+          errorEvent!.code,
+          errorEvent!.description,
         );
     } else if (this.state.viewState !== WebViewState.IDLE) {
       console.error(
-        "RNCWebView invalid state encountered: " + this.state.viewState
+        'RNCWebView invalid state encountered: ' + this.state.viewState,
       );
     }
 
     }
 
     if (isWebViewUriSource(source)) {
-      if (source.method === "POST" && source.headers) {
+      if (source.method === 'POST' && source.headers) {
         console.warn(
-          "WebView: `source.headers` is not supported when using POST."
+          'WebView: `source.headers` is not supported when using POST.',
         );
-      } else if (source.method === "GET" && source.body) {
-        console.warn("WebView: `source.body` is not supported when using GET.");
+      } else if (source.method === 'GET' && source.body) {
+        console.warn('WebView: `source.body` is not supported when using GET.');
       }
     }
 
     const nativeConfig = this.props.nativeConfig || {};
 
     const originWhitelist = (this.props.originWhitelist || []).map(
-      WebViewShared.originWhitelistToRegex
+      WebViewShared.originWhitelistToRegex,
     );
 
     let NativeWebView = nativeConfig.component || RNCWebView;
         javaScriptEnabled={this.props.javaScriptEnabled}
         thirdPartyCookiesEnabled={this.props.thirdPartyCookiesEnabled}
         domStorageEnabled={this.props.domStorageEnabled}
-        messagingEnabled={typeof this.props.onMessage === "function"}
+        messagingEnabled={typeof this.props.onMessage === 'function'}
         onMessage={this.onMessage}
         overScrollMode={this.props.overScrollMode}
         contentInset={this.props.contentInset}
     UIManager.dispatchViewManagerCommand(
       this.getWebViewHandle(),
       UIManager.RNCWebView.Commands.goForward,
-      null
+      null,
     );
   };
 
     UIManager.dispatchViewManagerCommand(
       this.getWebViewHandle(),
       UIManager.RNCWebView.Commands.goBack,
-      null
+      null,
     );
   };
 
   reload = () => {
     this.setState({
-      viewState: WebViewState.LOADING
+      viewState: WebViewState.LOADING,
     });
     UIManager.dispatchViewManagerCommand(
       this.getWebViewHandle(),
       UIManager.RNCWebView.Commands.reload,
-      null
+      null,
     );
   };
 
     UIManager.dispatchViewManagerCommand(
       this.getWebViewHandle(),
       UIManager.RNCWebView.Commands.stopLoading,
-      null
+      null,
     );
   };
 
     UIManager.dispatchViewManagerCommand(
       this.getWebViewHandle(),
       UIManager.RNCWebView.Commands.postMessage,
-      [String(data)]
+      [String(data)],
     );
   };
 
     UIManager.dispatchViewManagerCommand(
       this.getWebViewHandle(),
       UIManager.RNCWebView.Commands.injectJavaScript,
-      [data]
+      [data],
     );
   };
 
     const { onError, onLoadEnd } = this.props;
     onError && onError(event);
     onLoadEnd && onLoadEnd(event);
-    console.warn("Encountered an error loading page", event.nativeEvent);
+    console.warn('Encountered an error loading page', event.nativeEvent);
 
     this.setState({
       lastErrorEvent: event.nativeEvent,
-      viewState: WebViewState.ERROR
+      viewState: WebViewState.ERROR,
     });
   };
 
     onLoad && onLoad(event);
     onLoadEnd && onLoadEnd(event);
     this.setState({
-      viewState: WebViewState.IDLE
+      viewState: WebViewState.IDLE,
     });
     this.updateNavigationState(event);
   };
   };
 }
 
-const RNCWebView = requireNativeComponent("RNCWebView");
+const RNCWebView = requireNativeComponent('RNCWebView');
 
 const styles = StyleSheet.create({
   container: {
-    flex: 1
+    flex: 1,
   },
   hidden: {
     height: 0,
-    flex: 0 // disable 'flex:1' when hiding a View
+    flex: 0, // disable 'flex:1' when hiding a View
   },
   loadingView: {
     flex: 1,
-    justifyContent: "center",
-    alignItems: "center"
+    justifyContent: 'center',
+    alignItems: 'center',
   },
   loadingProgressBar: {
-    height: 20
-  }
-});
+    height: 20,
+  },
+});

src/WebView.ios.tsx

-import React from "react";
+import React from 'react';
 import {
   ActivityIndicator,
   Linking,
   NativeModules,
   Image,
   findNodeHandle,
-  NativeSyntheticEvent
-} from "react-native";
+  NativeSyntheticEvent,
+} from 'react-native';
 
-import invariant from "invariant";
+import invariant from 'invariant';
 
-import WebViewShared from "./WebViewShared";
+import WebViewShared from './WebViewShared';
 import {
   WebViewSourceUri,
   WebViewError,
   WebViewNavigationEvent,
   WebViewSharedProps,
   WebViewSource,
-  WebViewProgressEvent
-} from "./types/WebViewTypes";
+  WebViewProgressEvent,
+} from './types/WebViewTypes';
 
-type DecelerationRate = number | "normal" | "fast";
+type DecelerationRate = number | 'normal' | 'fast';
 
 // Imported from https://github.com/facebook/react-native/blob/master/Libraries/Components/ScrollView/processDecelerationRate.js
-function processDecelerationRate(decelerationRate: DecelerationRate) {
-  if (decelerationRate === "normal") {
+function processDecelerationRate(decelerationRate?: DecelerationRate) {
+  if (decelerationRate === 'normal') {
     decelerationRate = 0.998;
-  } else if (decelerationRate === "fast") {
+  } else if (decelerationRate === 'fast') {
     decelerationRate = 0.99;
   }
   return decelerationRate;
 const RNCUIWebViewManager = NativeModules.RNCUIWebViewManager;
 const RNCWKWebViewManager = NativeModules.RNCWKWebViewManager;
 
-const BGWASH = "rgba(255,255,255,0.8)";
+const BGWASH = 'rgba(255,255,255,0.8)';
 
 enum WebViewState {
-  IDLE = "IDLE",
-  LOADING = "LOADING",
-  ERROR = "ERROR"
+  IDLE = 'IDLE',
+  LOADING = 'LOADING',
+  ERROR = 'ERROR',
 }
 
 enum NavigationType {
-  click = "click",
-  formsubmit = "formsubmit",
-  backforward = "backforward",
-  reload = "reload",
-  formresubmit = "formresubmit",
-  other = "other"
+  click = 'click',
+  formsubmit = 'formsubmit',
+  backforward = 'backforward',
+  reload = 'reload',
+  formresubmit = 'formresubmit',
+  other = 'other',
 }
 
-const JSNavigationScheme = "react-js-navigation";
+const JSNavigationScheme = 'react-js-navigation';
 
 type State = {
   viewState: WebViewState;
-  lastErrorEvent: WebViewError;
+  lastErrorEvent: WebViewError | null;
 };
 
 const defaultRenderLoading = () => (
   </View>
 );
 const defaultRenderError = (
-  errorDomain: string,
+  errorDomain: string | undefined,
   errorCode: number,
-  errorDesc: string
+  errorDesc: string,
 ) => (
   <View style={styles.errorContainer}>
     <Text style={styles.errorTextTitle}>Error loading page</Text>
-    <Text style={styles.errorText}>{"Domain: " + errorDomain}</Text>
-    <Text style={styles.errorText}>{"Error Code: " + errorCode}</Text>
-    <Text style={styles.errorText}>{"Description: " + errorDesc}</Text>
+    <Text style={styles.errorText}>{'Domain: ' + errorDomain}</Text>
+    <Text style={styles.errorText}>{'Error Code: ' + errorCode}</Text>
+    <Text style={styles.errorText}>{'Description: ' + errorDesc}</Text>
   </View>
 );
 
 
   static defaultProps = {
     useWebKit: true,
-    originWhitelist: WebViewShared.defaultOriginWhitelist
+    originWhitelist: WebViewShared.defaultOriginWhitelist,
   };
 
   static isFileUploadSupported = async () => {
     viewState: this.props.startInLoadingState
       ? WebViewState.LOADING
       : WebViewState.IDLE,
-    lastErrorEvent: null
+    lastErrorEvent: null,
   };
 
   webViewRef = React.createRef<React.ComponentClass>();
       this.props.scalesPageToFit !== undefined
     ) {
       console.warn(
-        "The scalesPageToFit property is not supported when useWebKit = true"
+        'The scalesPageToFit property is not supported when useWebKit = true',
       );
     }
     if (
       this.props.allowsBackForwardNavigationGestures
     ) {
       console.warn(
-        "The allowsBackForwardNavigationGestures property is not supported when useWebKit = false"
+        'The allowsBackForwardNavigationGestures property is not supported when useWebKit = false',
       );
     }
   }
       otherView = (this.props.renderLoading || defaultRenderLoading)();
     } else if (this.state.viewState === WebViewState.ERROR) {
       const errorEvent = this.state.lastErrorEvent;
-      invariant(errorEvent != null, "lastErrorEvent expected to be non-null");
+      invariant(errorEvent != null, 'lastErrorEvent expected to be non-null');
       otherView = (this.props.renderError || defaultRenderError)(
-        errorEvent.domain,
-        errorEvent.code,
-        errorEvent.description
+        errorEvent!.domain,
+        errorEvent!.code,
+        errorEvent!.description,
       );
     } else if (this.state.viewState !== WebViewState.IDLE) {
       console.error(
-        "RNCWebView invalid state encountered: " + this.state.viewState
+        'RNCWebView invalid state encountered: ' + this.state.viewState,
       );
     }
 
     }
 
     const compiledWhitelist = [
-      "about:blank",
-      ...(this.props.originWhitelist || [])
+      'about:blank',
+      ...(this.props.originWhitelist || []),
     ].map(WebViewShared.originWhitelistToRegex);
     const onShouldStartLoadWithRequest = (
-      event: NativeSyntheticEvent<WebViewIOSLoadRequestEvent>
+      event: NativeSyntheticEvent<WebViewIOSLoadRequestEvent>,
     ) => {
       let shouldStart = true;
       const { url } = event.nativeEvent;
       const origin = WebViewShared.extractOrigin(url);
       const passesWhitelist = compiledWhitelist.some(x =>
-        new RegExp(x).test(origin)
+        new RegExp(x).test(origin),
       );
       shouldStart = shouldStart && passesWhitelist;
       if (!passesWhitelist) {
           shouldStart &&
           this.props.onShouldStartLoadWithRequest(event.nativeEvent);
       }
-      invariant(viewManager != null, "viewManager expected to be non-null");
+      invariant(viewManager != null, 'viewManager expected to be non-null');
       viewManager.startLoadWithResult(
         !!shouldStart,
-        event.nativeEvent.lockIdentifier
+        event.nativeEvent.lockIdentifier,
       );
     };
 
     const decelerationRate = processDecelerationRate(
-      this.props.decelerationRate
+      this.props.decelerationRate,
     );
 
     let source: WebViewSource = this.props.source || {};
       source = { uri: this.props.url };
     }
 
-    const messagingEnabled = typeof this.props.onMessage === "function";
+    const messagingEnabled = typeof this.props.onMessage === 'function';
 
     let NativeWebView = nativeConfig.component;
 
     UIManager.dispatchViewManagerCommand(
       this.getWebViewHandle(),
       this._getCommands().goForward,
-      null
+      null,
     );
   };
 
     UIManager.dispatchViewManagerCommand(
       this.getWebViewHandle(),
       this._getCommands().goBack,
-      null
+      null,
     );
   };
 
     UIManager.dispatchViewManagerCommand(
       this.getWebViewHandle(),
       this._getCommands().reload,
-      null
+      null,
     );
   };
 
     UIManager.dispatchViewManagerCommand(
       this.getWebViewHandle(),
       this._getCommands().stopLoading,
-      null
+      null,
     );
   };
 
     UIManager.dispatchViewManagerCommand(
       this.getWebViewHandle(),
       this._getCommands().postMessage,
-      [String(data)]
+      [String(data)],
     );
   };
 
     UIManager.dispatchViewManagerCommand(
       this.getWebViewHandle(),
       this._getCommands().injectJavaScript,
-      [data]
+      [data],
     );
   };
 
     const { onError, onLoadEnd } = this.props;
     onError && onError(event);
     onLoadEnd && onLoadEnd(event);
-    console.warn("Encountered an error loading page", event.nativeEvent);
+    console.warn('Encountered an error loading page', event.nativeEvent);
 
     this.setState({
       lastErrorEvent: event.nativeEvent,
-      viewState: WebViewState.ERROR
+      viewState: WebViewState.ERROR,
     });
   };
 
     onLoad && onLoad(event);
     onLoadEnd && onLoadEnd(event);
     this.setState({
-      viewState: WebViewState.IDLE
+      viewState: WebViewState.IDLE,
     });
     this._updateNavigationState(event);
   };
       return;
     }
 
-    this._showRedboxOnPropChanges(prevProps, "allowsInlineMediaPlayback");
-    this._showRedboxOnPropChanges(prevProps, "mediaPlaybackRequiresUserAction");
-    this._showRedboxOnPropChanges(prevProps, "dataDetectorTypes");
+    this._showRedboxOnPropChanges(prevProps, 'allowsInlineMediaPlayback');
+    this._showRedboxOnPropChanges(prevProps, 'mediaPlaybackRequiresUserAction');
+    this._showRedboxOnPropChanges(prevProps, 'dataDetectorTypes');
 
     if (this.props.scalesPageToFit !== undefined) {
       console.warn(
-        "The scalesPageToFit property is not supported when useWebKit = true"
+        'The scalesPageToFit property is not supported when useWebKit = true',
       );
     }
   }
   _showRedboxOnPropChanges(
     prevProps: WebViewSharedProps,
     propName:
-      | "allowsInlineMediaPlayback"
-      | "mediaPlaybackRequiresUserAction"
-      | "dataDetectorTypes"
+      | 'allowsInlineMediaPlayback'
+      | 'mediaPlaybackRequiresUserAction'
+      | 'dataDetectorTypes',
   ) {
     if (this.props[propName] !== prevProps[propName]) {
       console.error(
-        `Changes to property ${propName} do nothing after the initial render.`
+        `Changes to property ${propName} do nothing after the initial render.`,
       );
     }
   }
 }
 
-const RNCUIWebView = requireNativeComponent("RNCUIWebView");
-const RNCWKWebView = requireNativeComponent("RNCWKWebView");
+const RNCUIWebView = requireNativeComponent('RNCUIWebView');
+const RNCWKWebView = requireNativeComponent('RNCWKWebView');
 
 const styles = StyleSheet.create({
   container: {
-    flex: 1
+    flex: 1,
   },
   errorContainer: {
     flex: 1,
-    justifyContent: "center",
-    alignItems: "center",
-    backgroundColor: BGWASH
+    justifyContent: 'center',
+    alignItems: 'center',
+    backgroundColor: BGWASH,
   },
   errorText: {
     fontSize: 14,
-    textAlign: "center",
-    marginBottom: 2
+    textAlign: 'center',
+    marginBottom: 2,
   },
   errorTextTitle: {
     fontSize: 15,
-    fontWeight: "500",
-    marginBottom: 10
+    fontWeight: '500',
+    marginBottom: 10,
   },
   hidden: {
     height: 0,
-    flex: 0 // disable 'flex:1' when hiding a View
+    flex: 0, // disable 'flex:1' when hiding a View
   },
   loadingView: {
     backgroundColor: BGWASH,
     flex: 1,
-    justifyContent: "center",
-    alignItems: "center",
-    height: 100
+    justifyContent: 'center',
+    alignItems: 'center',
+    height: 100,
   },
   webView: {
-    backgroundColor: "#ffffff"
-  }
+    backgroundColor: '#ffffff',
+  },
 });

tsconfig.base.json

-{
-  "compilerOptions": {
-    "strictNullChecks": false,
-    "alwaysStrict": true,
-    "allowSyntheticDefaultImports": true,
-    "declaration": true,
-    "declarationDir": "lib",
-    "emitDecoratorMetadata": false,
-    "esModuleInterop": true,
-    "outDir": "lib",
-    "jsx": "react-native",
-    "lib": ["es6"],
-    "module": "esnext",
-    "moduleResolution": "node",
-    "noFallthroughCasesInSwitch": true,
-    "noImplicitAny": true,
-    "noImplicitReturns": true,
-    "noImplicitThis": true,
-    "noUnusedLocals": true,
-    "noUnusedParameters": true,
-    "pretty": true,
-    "removeComments": true,
-    "sourceMap": true,
-    "strict": true,
-    "stripInternal": true,
-    "target": "es5"
-  }
-}

tsconfig.json

 {
-  "extends": "./tsconfig.base.json",
-  "include": ["src", "./typings.d.ts", "types", "test"],
-  "exclude": ["node_modules", "dist"]  
-}
+  "compilerOptions": {
+    "allowSyntheticDefaultImports": true,
+    "esModuleInterop": true,
+    "jsx": "react-native",
+    "module": "esnext",
+    "moduleResolution": "node",
+    "noEmit": true,
+    "noFallthroughCasesInSwitch": true,
+    "noImplicitAny": true,
+    "noImplicitReturns": true,
+    "noImplicitThis": true,
+    "noUnusedLocals": true,
+    "noUnusedParameters": true,
+    "pretty": true,
+    "skipLibCheck": true,
+    "strict": true,
+  },
+  "include": [
+    "src",
+    "./typings.d.ts",
+    "types",
+    "test"
+  ],
+  "exclude": [
+    "node_modules",
+    "dist"
+  ]
+}