@zorilla/puppeteer-extra-plugin-stealth 1.0.0

package/dist/evasions/_utils/README.md

@@ -0,0 +1,287 @@
+## API
+
+
+#### Table of Contents
+
+- [utils()](#utils)
+  - [.stripProxyFromErrors(handler)](#stripproxyfromerrorshandler)
+  - [.stripErrorWithAnchor(err, anchor)](#striperrorwithanchorerr-anchor)
+  - [.replaceProperty(obj, propName, descriptorOverrides)](#replacepropertyobj-propname-descriptoroverrides)
+  - [.preloadCache()](#preloadcache)
+  - [.makeNativeString(name?)](#makenativestringname)
+  - [.patchToString(obj, str)](#patchtostringobj-str)
+  - [.patchToStringNested(obj)](#patchtostringnestedobj)
+  - [.redirectToString(proxyObj, originalObj)](#redirecttostringproxyobj-originalobj)
+  - [.replaceWithProxy(obj, propName, handler)](#replacewithproxyobj-propname-handler)
+  - [.mockWithProxy(obj, propName, pseudoTarget, handler)](#mockwithproxyobj-propname-pseudotarget-handler)
+  - [.createProxy(pseudoTarget, handler)](#createproxypseudotarget-handler)
+  - [.splitObjPath(objPath)](#splitobjpathobjpath)
+  - [.replaceObjPathWithProxy(objPath, handler)](#replaceobjpathwithproxyobjpath-handler)
+  - [.execRecursively(obj, typeFilter, fn)](#execrecursivelyobj-typefilter-fn)
+  - [.stringifyFns(fnObj)](#stringifyfnsfnobj)
+  - [.materializeFns(fnStrObj)](#materializefnsfnstrobj)
+
+### [utils()](https://github.com/zorillajs/zorilla/blob/e6133619b051febed630ada35241664eba59b9fa/packages/puppeteer-extra-plugin-stealth/evasions/_utils/index.js#L12-L12)
+
+A set of shared utility functions specifically for the purpose of modifying native browser APIs without leaving traces.
+
+Meant to be passed down in puppeteer and used in the context of the page (everything in here runs in NodeJS as well as a browser).
+
+Note: If for whatever reason you need to use this outside of `puppeteer-extra`:
+Just remove the `module.exports` statement at the very bottom, the rest can be copy pasted into any browser context.
+
+Alternatively take a look at the `extract-stealth-evasions` package to create a finished bundle which includes these utilities.
+
+---
+
+#### .[stripProxyFromErrors(handler)](https://github.com/zorillajs/zorilla/blob/e6133619b051febed630ada35241664eba59b9fa/packages/puppeteer-extra-plugin-stealth/evasions/_utils/index.js#L21-L82)
+
+- `handler` **[object](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Object)** The JS Proxy handler to wrap (optional, default `{}`)
+
+Wraps a JS Proxy Handler and strips it's presence from error stacks, in case the traps throw.
+
+The presence of a JS Proxy can be revealed as it shows up in error stack traces.
+
+---
+
+#### .[stripErrorWithAnchor(err, anchor)](https://github.com/zorillajs/zorilla/blob/e6133619b051febed630ada35241664eba59b9fa/packages/puppeteer-extra-plugin-stealth/evasions/_utils/index.js#L90-L101)
+
+- `err` **[object](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Object)** The error to sanitize
+- `anchor` **[string](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/String)** The string the anchor line starts with
+
+Strip error lines from stack traces until (and including) a known line the stack.
+
+---
+
+#### .[replaceProperty(obj, propName, descriptorOverrides)](https://github.com/zorillajs/zorilla/blob/e6133619b051febed630ada35241664eba59b9fa/packages/puppeteer-extra-plugin-stealth/evasions/_utils/index.js#L120-L127)
+
+- `obj` **[object](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Object)** The object which has the property to replace
+- `propName` **[string](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/String)** The property name to replace
+- `descriptorOverrides` **[object](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Object)** e.g. { value: "alice" } (optional, default `{}`)
+
+Replace the property of an object in a stealthy way.
+
+Note: You also want to work on the prototype of an object most often,
+as you'd otherwise leave traces (e.g. showing up in Object.getOwnPropertyNames(obj)).
+
+Example:
+
+```javascript
+replaceProperty(WebGLRenderingContext.prototype, 'getParameter', {
+  value: 'alice'
+})
+// or
+replaceProperty(Object.getPrototypeOf(navigator), 'languages', {
+  get: () => ['en-US', 'en']
+})
+```
+
+- **See: <https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/defineProperty>**
+
+---
+
+#### .[preloadCache()](https://github.com/zorillajs/zorilla/blob/e6133619b051febed630ada35241664eba59b9fa/packages/puppeteer-extra-plugin-stealth/evasions/_utils/index.js#L137-L150)
+
+Preload a cache of function copies and data.
+
+For a determined enough observer it would be possible to overwrite and sniff usage of functions
+we use in our internal Proxies, to combat that we use a cached copy of those functions.
+
+This is evaluated once per execution context (e.g. window)
+
+---
+
+#### .[makeNativeString(name?)](https://github.com/zorillajs/zorilla/blob/e6133619b051febed630ada35241664eba59b9fa/packages/puppeteer-extra-plugin-stealth/evasions/_utils/index.js#L169-L173)
+
+- `name` **[string](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/String)?** Optional function name (optional, default `''`)
+
+Utility function to generate a cross-browser `toString` result representing native code.
+
+There's small differences: Chromium uses a single line, whereas FF & Webkit uses multiline strings.
+To future-proof this we use an existing native toString result as the basis.
+
+The only advantage we have over the other team is that our JS runs first, hence we cache the result
+of the native toString result once, so they cannot spoof it afterwards and reveal that we're using it.
+
+Note: Whenever we add a `Function.prototype.toString` proxy we should preload the cache before,
+by executing `utils.preloadCache()` before the proxy is applied (so we don't cause recursive lookups).
+
+Example:
+
+```javascript
+makeNativeString('foobar') // => `function foobar() { [native code] }`
+```
+
+---
+
+#### .[patchToString(obj, str)](https://github.com/zorillajs/zorilla/blob/e6133619b051febed630ada35241664eba59b9fa/packages/puppeteer-extra-plugin-stealth/evasions/_utils/index.js#L189-L218)
+
+- `obj` **[object](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Object)** The object for which to modify the `toString()` representation
+- `str` **[string](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/String)** Optional string used as a return value (optional, default `''`)
+
+Helper function to modify the `toString()` result of the provided object.
+
+Note: Use `utils.redirectToString` instead when possible.
+
+There's a quirk in JS Proxies that will cause the `toString()` result to differ from the vanilla Object.
+If no string is provided we will generate a `[native code]` thing based on the name of the property object.
+
+Example:
+
+```javascript
+patchToString(
+  WebGLRenderingContext.prototype.getParameter,
+  'function getParameter() { [native code] }'
+)
+```
+
+---
+
+#### .[patchToStringNested(obj)](https://github.com/zorillajs/zorilla/blob/e6133619b051febed630ada35241664eba59b9fa/packages/puppeteer-extra-plugin-stealth/evasions/_utils/index.js#L225-L227)
+
+- `obj` **[object](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Object)** (optional, default `{}`)
+
+Make all nested functions of an object native.
+
+---
+
+#### .[redirectToString(proxyObj, originalObj)](https://github.com/zorillajs/zorilla/blob/e6133619b051febed630ada35241664eba59b9fa/packages/puppeteer-extra-plugin-stealth/evasions/_utils/index.js#L235-L272)
+
+- `proxyObj` **[object](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Object)** The object that toString will be called on
+- `originalObj` **[object](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Object)** The object which toString result we wan to return
+
+Redirect toString requests from one object to another.
+
+---
+
+#### .[replaceWithProxy(obj, propName, handler)](https://github.com/zorillajs/zorilla/blob/e6133619b051febed630ada35241664eba59b9fa/packages/puppeteer-extra-plugin-stealth/evasions/_utils/index.js#L287-L296)
+
+- `obj` **[object](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Object)** The object which has the property to replace
+- `propName` **[string](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/String)** The name of the property to replace
+- `handler` **[object](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Object)** The JS Proxy handler to use
+
+All-in-one method to replace a property with a JS Proxy using the provided Proxy handler with traps.
+
+Will stealthify these aspects (strip error stack traces, redirect toString, etc).
+Note: This is meant to modify native Browser APIs and works best with prototype objects.
+
+Example:
+
+```javascript
+replaceWithProxy(WebGLRenderingContext.prototype, 'getParameter', proxyHandler)
+```
+
+---
+
+#### .[mockWithProxy(obj, propName, pseudoTarget, handler)](https://github.com/zorillajs/zorilla/blob/e6133619b051febed630ada35241664eba59b9fa/packages/puppeteer-extra-plugin-stealth/evasions/_utils/index.js#L311-L319)
+
+- `obj` **[object](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Object)** The object which has the property to replace
+- `propName` **[string](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/String)** The name of the property to replace or create
+- `pseudoTarget` **[object](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Object)** The JS Proxy target to use as a basis
+- `handler` **[object](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Object)** The JS Proxy handler to use
+
+All-in-one method to mock a non-existing property with a JS Proxy using the provided Proxy handler with traps.
+
+Will stealthify these aspects (strip error stack traces, redirect toString, etc).
+
+Example:
+
+```javascript
+mockWithProxy(
+  chrome.runtime,
+  'sendMessage',
+  function sendMessage() {},
+  proxyHandler
+)
+```
+
+---
+
+#### .[createProxy(pseudoTarget, handler)](https://github.com/zorillajs/zorilla/blob/e6133619b051febed630ada35241664eba59b9fa/packages/puppeteer-extra-plugin-stealth/evasions/_utils/index.js#L334-L340)
+
+- `pseudoTarget` **[object](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Object)** The JS Proxy target to use as a basis
+- `handler` **[object](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Object)** The JS Proxy handler to use
+
+All-in-one method to create a new JS Proxy with stealth tweaks.
+
+This is meant to be used whenever we need a JS Proxy but don't want to replace or mock an existing known property.
+
+Will stealthify certain aspects of the Proxy (strip error stack traces, redirect toString, etc).
+
+Example:
+
+```javascript
+createProxy(navigator.mimeTypes.__proto__.namedItem, proxyHandler) // => Proxy
+```
+
+---
+
+#### .[splitObjPath(objPath)](https://github.com/zorillajs/zorilla/blob/e6133619b051febed630ada35241664eba59b9fa/packages/puppeteer-extra-plugin-stealth/evasions/_utils/index.js#L351-L359)
+
+- `objPath` **[string](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/String)** The full path to an object as dot notation string
+
+Helper function to split a full path to an Object into the first part and property.
+
+Example:
+
+```javascript
+splitObjPath(`HTMLMediaElement.prototype.canPlayType`)
+// => {objName: "HTMLMediaElement.prototype", propName: "canPlayType"}
+```
+
+---
+
+#### .[replaceObjPathWithProxy(objPath, handler)](https://github.com/zorillajs/zorilla/blob/e6133619b051febed630ada35241664eba59b9fa/packages/puppeteer-extra-plugin-stealth/evasions/_utils/index.js#L372-L376)
+
+- `objPath` **[string](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/String)** The full path to an object (dot notation string) to replace
+- `handler` **[object](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Object)** The JS Proxy handler to use
+
+Convenience method to replace a property with a JS Proxy using the provided objPath.
+
+Supports a full path (dot notation) to the object as string here, in case that makes it easier.
+
+Example:
+
+```javascript
+replaceObjPathWithProxy(
+  'WebGLRenderingContext.prototype.getParameter',
+  proxyHandler
+)
+```
+
+---
+
+#### .[execRecursively(obj, typeFilter, fn)](https://github.com/zorillajs/zorilla/blob/e6133619b051febed630ada35241664eba59b9fa/packages/puppeteer-extra-plugin-stealth/evasions/_utils/index.js#L385-L402)
+
+- `obj` **[object](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Object)** (optional, default `{}`)
+- `typeFilter` **[array](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Array)** e.g. `['function']` (optional, default `[]`)
+- `fn` **[Function](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Statements/function)** e.g. `utils.patchToString`
+
+Traverse nested properties of an object recursively and apply the given function on a whitelist of value types.
+
+---
+
+#### .[stringifyFns(fnObj)](https://github.com/zorillajs/zorilla/blob/e6133619b051febed630ada35241664eba59b9fa/packages/puppeteer-extra-plugin-stealth/evasions/_utils/index.js#L417-L431)
+
+- `fnObj` **[object](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Object)** An object containing functions as properties (optional, default `{hello:()=>'world'}`)
+
+Everything we run through e.g. `page.evaluate` runs in the browser context, not the NodeJS one.
+That means we cannot just use reference variables and functions from outside code, we need to pass everything as a parameter.
+
+Unfortunately the data we can pass is only allowed to be of primitive types, regular functions don't survive the built-in serialization process.
+This utility function will take an object with functions and stringify them, so we can pass them down unharmed as strings.
+
+We use this to pass down our utility functions as well as any other functions (to be able to split up code better).
+
+- **See: utils.materializeFns**
+
+---
+
+#### .[materializeFns(fnStrObj)](https://github.com/zorillajs/zorilla/blob/e6133619b051febed630ada35241664eba59b9fa/packages/puppeteer-extra-plugin-stealth/evasions/_utils/index.js#L439-L451)
+
+- `fnStrObj` **[object](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Object)** An object containing stringified functions as properties (optional, default `{hello:"() => 'world'"}`)
+
+Utility function to reverse the process of `utils.stringifyFns`.
+Will materialize an object with stringified functions (supports classic and fat arrow functions).
+
+---

package/dist/evasions/_utils/index.d.ts

@@ -0,0 +1,238 @@
+export default utils;
+declare namespace utils {
+    function init(): void;
+    /**
+     * Wraps a JS Proxy Handler and strips it's presence from error stacks, in case the traps throw.
+     *
+     * The presence of a JS Proxy can be revealed as it shows up in error stack traces.
+     *
+     * @param {object} handler - The JS Proxy handler to wrap
+     */
+    function stripProxyFromErrors(handler?: object): {
+        setPrototypeOf: (target: any, proto: any) => boolean;
+    };
+    /**
+     * Strip error lines from stack traces until (and including) a known line the stack.
+     *
+     * @param {object} err - The error to sanitize
+     * @param {string} anchor - The string the anchor line starts with
+     */
+    function stripErrorWithAnchor(err: object, anchor: string): object;
+    /**
+     * Replace the property of an object in a stealthy way.
+     *
+     * Note: You also want to work on the prototype of an object most often,
+     * as you'd otherwise leave traces (e.g. showing up in Object.getOwnPropertyNames(obj)).
+     *
+     * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/defineProperty
+     *
+     * @example
+     * replaceProperty(WebGLRenderingContext.prototype, 'getParameter', { value: "alice" })
+     * // or
+     * replaceProperty(Object.getPrototypeOf(navigator), 'languages', { get: () => ['en-US', 'en'] })
+     *
+     * @param {object} obj - The object which has the property to replace
+     * @param {string} propName - The property name to replace
+     * @param {object} descriptorOverrides - e.g. { value: "alice" }
+     */
+    function replaceProperty(obj: object, propName: string, descriptorOverrides?: object): object;
+    /**
+     * Preload a cache of function copies and data.
+     *
+     * For a determined enough observer it would be possible to overwrite and sniff usage of functions
+     * we use in our internal Proxies, to combat that we use a cached copy of those functions.
+     *
+     * Note: Whenever we add a `Function.prototype.toString` proxy we should preload the cache before,
+     * by executing `utils.preloadCache()` before the proxy is applied (so we don't cause recursive lookups).
+     *
+     * This is evaluated once per execution context (e.g. window)
+     */
+    function preloadCache(): void;
+    /**
+     * Utility function to generate a cross-browser `toString` result representing native code.
+     *
+     * There's small differences: Chromium uses a single line, whereas FF & Webkit uses multiline strings.
+     * To future-proof this we use an existing native toString result as the basis.
+     *
+     * The only advantage we have over the other team is that our JS runs first, hence we cache the result
+     * of the native toString result once, so they cannot spoof it afterwards and reveal that we're using it.
+     *
+     * @example
+     * makeNativeString('foobar') // => `function foobar() { [native code] }`
+     *
+     * @param {string} [name] - Optional function name
+     */
+    function makeNativeString(name?: string): any;
+    /**
+     * Helper function to modify the `toString()` result of the provided object.
+     *
+     * Note: Use `utils.redirectToString` instead when possible.
+     *
+     * There's a quirk in JS Proxies that will cause the `toString()` result to differ from the vanilla Object.
+     * If no string is provided we will generate a `[native code]` thing based on the name of the property object.
+     *
+     * @example
+     * patchToString(WebGLRenderingContext.prototype.getParameter, 'function getParameter() { [native code] }')
+     *
+     * @param {object} obj - The object for which to modify the `toString()` representation
+     * @param {string} str - Optional string used as a return value
+     */
+    function patchToString(obj: object, str?: string): void;
+    /**
+     * Make all nested functions of an object native.
+     *
+     * @param {object} obj
+     */
+    function patchToStringNested(obj?: object): object;
+    /**
+     * Redirect toString requests from one object to another.
+     *
+     * @param {object} proxyObj - The object that toString will be called on
+     * @param {object} originalObj - The object which toString result we wan to return
+     */
+    function redirectToString(proxyObj: object, originalObj: object): void;
+    /**
+     * All-in-one method to replace a property with a JS Proxy using the provided Proxy handler with traps.
+     *
+     * Will stealthify these aspects (strip error stack traces, redirect toString, etc).
+     * Note: This is meant to modify native Browser APIs and works best with prototype objects.
+     *
+     * @example
+     * replaceWithProxy(WebGLRenderingContext.prototype, 'getParameter', proxyHandler)
+     *
+     * @param {object} obj - The object which has the property to replace
+     * @param {string} propName - The name of the property to replace
+     * @param {object} handler - The JS Proxy handler to use
+     */
+    function replaceWithProxy(obj: object, propName: string, handler: object): boolean;
+    /**
+     * All-in-one method to replace a getter with a JS Proxy using the provided Proxy handler with traps.
+     *
+     * @example
+     * replaceGetterWithProxy(Object.getPrototypeOf(navigator), 'vendor', proxyHandler)
+     *
+     * @param {object} obj - The object which has the property to replace
+     * @param {string} propName - The name of the property to replace
+     * @param {object} handler - The JS Proxy handler to use
+     */
+    function replaceGetterWithProxy(obj: object, propName: string, handler: object): boolean;
+    /**
+     * All-in-one method to replace a getter and/or setter. Functions get and set
+     * of handler have one more argument that contains the native function.
+     *
+     * @example
+     * replaceGetterSetter(HTMLIFrameElement.prototype, 'contentWindow', handler)
+     *
+     * @param {object} obj - The object which has the property to replace
+     * @param {string} propName - The name of the property to replace
+     * @param {object} handlerGetterSetter - The handler with get and/or set
+     *                                     functions
+     * @see https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Object/defineProperty#description
+     */
+    function replaceGetterSetter(obj: object, propName: string, handlerGetterSetter: object): void;
+    /**
+     * All-in-one method to mock a non-existing property with a JS Proxy using the provided Proxy handler with traps.
+     *
+     * Will stealthify these aspects (strip error stack traces, redirect toString, etc).
+     *
+     * @example
+     * mockWithProxy(chrome.runtime, 'sendMessage', function sendMessage() {}, proxyHandler)
+     *
+     * @param {object} obj - The object which has the property to replace
+     * @param {string} propName - The name of the property to replace or create
+     * @param {object} pseudoTarget - The JS Proxy target to use as a basis
+     * @param {object} handler - The JS Proxy handler to use
+     */
+    function mockWithProxy(obj: object, propName: string, pseudoTarget: object, handler: object): boolean;
+    /**
+     * All-in-one method to create a new JS Proxy with stealth tweaks.
+     *
+     * This is meant to be used whenever we need a JS Proxy but don't want to replace or mock an existing known property.
+     *
+     * Will stealthify certain aspects of the Proxy (strip error stack traces, redirect toString, etc).
+     *
+     * @example
+     * createProxy(navigator.mimeTypes.__proto__.namedItem, proxyHandler) // => Proxy
+     *
+     * @param {object} pseudoTarget - The JS Proxy target to use as a basis
+     * @param {object} handler - The JS Proxy handler to use
+     */
+    function createProxy(pseudoTarget: object, handler: object): any;
+    /**
+     * Helper function to split a full path to an Object into the first part and property.
+     *
+     * @example
+     * splitObjPath(`HTMLMediaElement.prototype.canPlayType`)
+     * // => {objName: "HTMLMediaElement.prototype", propName: "canPlayType"}
+     *
+     * @param {string} objPath - The full path to an object as dot notation string
+     */
+    function splitObjPath(objPath: string): {
+        objName: string;
+        propName: string | undefined;
+    };
+    /**
+     * Convenience method to replace a property with a JS Proxy using the provided objPath.
+     *
+     * Supports a full path (dot notation) to the object as string here, in case that makes it easier.
+     *
+     * @example
+     * replaceObjPathWithProxy('WebGLRenderingContext.prototype.getParameter', proxyHandler)
+     *
+     * @param {string} objPath - The full path to an object (dot notation string) to replace
+     * @param {object} handler - The JS Proxy handler to use
+     */
+    function replaceObjPathWithProxy(objPath: string, handler: object): boolean;
+    /**
+     * Traverse nested properties of an object recursively and apply the given function on a whitelist of value types.
+     *
+     * @param {object} obj
+     * @param {array} typeFilter - e.g. `['function']`
+     * @param {Function} fn - e.g. `utils.patchToString`
+     */
+    function execRecursively(obj: object | undefined, typeFilter: array, fn: Function): object;
+    /**
+     * Everything we run through e.g. `page.evaluate` runs in the browser context, not the NodeJS one.
+     * That means we cannot just use reference variables and functions from outside code, we need to pass everything as a parameter.
+     *
+     * Unfortunately the data we can pass is only allowed to be of primitive types, regular functions don't survive the built-in serialization process.
+     * This utility function will take an object with functions and stringify them, so we can pass them down unharmed as strings.
+     *
+     * We use this to pass down our utility functions as well as any other functions (to be able to split up code better).
+     *
+     * @see utils.materializeFns
+     *
+     * @param {object} fnObj - An object containing functions as properties
+     */
+    function stringifyFns(fnObj?: object): {
+        [k: string]: any;
+    };
+    /**
+     * Utility function to reverse the process of `utils.stringifyFns`.
+     * Will materialize an object with stringified functions (supports classic and fat arrow functions).
+     *
+     * @param {object} fnStrObj - An object containing stringified functions as properties
+     */
+    function materializeFns(fnStrObj?: object): {
+        [k: string]: any;
+    };
+    function makeHandler(): {
+        getterValue: (value: any) => {
+            apply(_target: any, _ctx: any, _args: any, ...args: any[]): any;
+        };
+    };
+    /**
+     * Compare two arrays.
+     *
+     * @param {array} array1 - First array
+     * @param {array} array2 - Second array
+     */
+    function arrayEquals(array1: array, array2: array): boolean;
+    /**
+     * Cache the method return according to its arguments.
+     *
+     * @param {Function} fn - A function that will be cached
+     */
+    function memoize(fn: Function): (...args: any[]) => any;
+}
+//# sourceMappingURL=index.d.ts.map

package/dist/evasions/_utils/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/evasions/_utils/index.js"],"names":[],"mappings":";;IAaA,sBAEC;IAED;;;;;;OAMG;IACH,wCAFW,MAAM;;MAkFhB;IAED;;;;;OAKG;IACH,mCAHW,MAAM,UACN,MAAM,UAehB;IAED;;;;;;;;;;;;;;;;OAgBG;IACH,8BAJW,MAAM,YACN,MAAM,wBACN,MAAM,UAShB;IAED;;;;;;;;;;OAUG;IACH,8BAaC;IAED;;;;;;;;;;;;;OAaG;IACH,iCAFW,MAAM,OAIhB;IAED;;;;;;;;;;;;;OAaG;IACH,4BAHW,MAAM,QACN,MAAM,QAkChB;IAED;;;;OAIG;IACH,mCAFW,MAAM,UAIhB;IAED;;;;;OAKG;IACH,oCAHW,MAAM,eACN,MAAM,QA8ChB;IAED;;;;;;;;;;;;OAYG;IACH,+BAJW,MAAM,YACN,MAAM,WACN,MAAM,WAahB;IACD;;;;;;;;;OASG;IACH,qCAJW,MAAM,YACN,MAAM,WACN,MAAM,WAWhB;IAED;;;;;;;;;;;;OAYG;IACH,kCANW,MAAM,YACN,MAAM,uBACN,MAAM,QAyBhB;IAED;;;;;;;;;;;;OAYG;IACH,4BALW,MAAM,YACN,MAAM,gBACN,MAAM,WACN,MAAM,WAShB;IAED;;;;;;;;;;;;OAYG;IACH,mCAHW,MAAM,WACN,MAAM,OAOhB;IAED;;;;;;;;OAQG;IACH,+BAFW,MAAM;;;MAOf;IAEF;;;;;;;;;;OAUG;IACH,0CAHW,MAAM,WACN,MAAM,WAMhB;IAED;;;;;;OAMG;IACH,8BAJW,MAAM,0BACN,KAAK,wBAoBf;IAED;;;;;;;;;;;;OAYG;IACH,8BAFW,MAAM;;MAgBhB;IAED;;;;;OAKG;IACH,mCAFW,MAAM;;MAchB;IAGD;;;;MAUE;IAEF;;;;;OAKG;IACH,6BAHW,KAAK,UACL,KAAK,WAYf;IAED;;;;OAIG;IACH,iCAEmB,GAAG,WAAI,SAMzB"}