diff --git a/.github/workflows/ci-module.yml b/.github/workflows/ci-module.yml
index 54426ca2..49bcabb9 100644
--- a/.github/workflows/ci-module.yml
+++ b/.github/workflows/ci-module.yml
@@ -1,14 +1,13 @@
 name: ci
 
 on:
-  push:
-    branches:
-      - master
-  pull_request:
-  workflow_dispatch:
+    push:
+        branches:
+            - master
+            - next
+    pull_request:
+    workflow_dispatch:
 
 jobs:
-  test:
-    uses: hapijs/.github/.github/workflows/ci-module.yml@master
-    with:
-      min-node-version: 14
+    test:
+        uses: hapijs/.github/.github/workflows/ci-module.yml@min-node-22-hapi-21
diff --git a/.gitignore b/.gitignore
index 8f679c9d..e0b41f66 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1,7 +1,7 @@
 **/node_modules
 **/package-lock.json
 
-coverage.*
+coverage
 
 **/.DS_Store
 **/._*
@@ -11,3 +11,4 @@ coverage.*
 **/.vs
 **/.vscode
 **/.idea
+dist
diff --git a/API.md b/API.md
index ae0a7c68..4f9b16ea 100755
--- a/API.md
+++ b/API.md
@@ -1,12 +1,12 @@
-
 ### Object
 
 **hoek** provides several helpful methods for objects and arrays.
 
 #### clone(obj, [options])
 
-Clones an object or an array. A *deep copy* is made (duplicates everything, including values that are
+Clones an object or an array. A _deep copy_ is made (duplicates everything, including values that are
 objects, as well as non-enumerable properties) where:
+
 - `obj` - the object to be cloned.
 - `options` - optional settings:
     - `symbols` - clone symbol properties. Defaults to `true`.
@@ -15,54 +15,53 @@ objects, as well as non-enumerable properties) where:
         - `true` to shallow copy all object properties. Used to shallow copy an object with non-enumerable properties and prototype;
 
 ```javascript
-
 const nestedObj = {
-        w: /^something$/ig,
-        x: {
-            a: [1, 2, 3],
-            b: 123456,
-            c: new Date()
-        },
-        y: 'y',
-        z: new Date()
-    };
+    w: /^something$/gi,
+    x: {
+        a: [1, 2, 3],
+        b: 123456,
+        c: new Date(),
+    },
+    y: 'y',
+    z: new Date(),
+};
 
 const copy = Hoek.clone(nestedObj);
 
 copy.x.b = 100;
 
-console.log(copy.y);        // results in 'y'
+console.log(copy.y); // results in 'y'
 console.log(nestedObj.x.b); // results in 123456
-console.log(copy.x.b);      // results in 100
+console.log(copy.x.b); // results in 100
 ```
 
 Clones an object or array excluding some keys which are shallow copied:
 
 ```javascript
-
 const nestedObj = {
-        w: /^something$/ig,
-        x: {
-            a: [1, 2, 3],
-            b: 123456,
-            c: new Date()
-        },
-        y: 'y',
-        z: new Date()
-    };
+    w: /^something$/gi,
+    x: {
+        a: [1, 2, 3],
+        b: 123456,
+        c: new Date(),
+    },
+    y: 'y',
+    z: new Date(),
+};
 
 const copy = Hoek.clone(nestedObj, { shallow: ['x'] });
 
 copy.x.b = 100;
 
-console.log(copy.y);        // results in 'y'
+console.log(copy.y); // results in 'y'
 console.log(nestedObj.x.b); // results in 100
-console.log(copy.x.b);      // results in 100
+console.log(copy.x.b); // results in 100
 ```
 
 #### merge(target, source, [options])
 
 Merge all the properties of source into target where:
+
 - `target` - the object onto which the properties of `source` are copied to.
 - `source` - the object copied onto `target`.
 - `options` - optional settings:
@@ -75,27 +74,26 @@ Merge all the properties of source into target where:
 Note that source wins in conflict, and by default null and undefined from source are applied.
 Merge is destructive where the target is modified. For non destructive merge, use `applyToDefaults`.
 
-
 ```javascript
+const target = { a: 1, b: 2 };
+const source = { a: 0, c: 5 };
+const source2 = { a: null, c: 5 };
 
-const target = {a: 1, b : 2};
-const source = {a: 0, c: 5};
-const source2 = {a: null, c: 5};
-
-Hoek.merge(target, source);         // results in {a: 0, b: 2, c: 5}
-Hoek.merge(target, source2);        // results in {a: null, b: 2, c: 5}
-Hoek.merge(target, source2, { nullOverride: false} ); // results in {a: 1, b: 2, c: 5}
+Hoek.merge(target, source); // results in {a: 0, b: 2, c: 5}
+Hoek.merge(target, source2); // results in {a: null, b: 2, c: 5}
+Hoek.merge(target, source2, { nullOverride: false }); // results in {a: 1, b: 2, c: 5}
 
 const targetArray = [1, 2, 3];
 const sourceArray = [4, 5];
 
-Hoek.merge(targetArray, sourceArray);              // results in [1, 2, 3, 4, 5]
+Hoek.merge(targetArray, sourceArray); // results in [1, 2, 3, 4, 5]
 Hoek.merge(targetArray, sourceArray, { mergeArrays: false }); // results in [4, 5]
 ```
 
 #### applyToDefaults(defaults, source, [options])
 
 Apply source to a copy of the defaults where:
+
 - `defaults` - the default object to clone and then apply `source` onto.
 - `source` - the object applied to the `defaults`.
 - `options` - optional settings:
@@ -104,8 +102,7 @@ Apply source to a copy of the defaults where:
     - `shallow` - an array of dot-separated or array-based key paths to shallow copy values in `source`.
 
 ```javascript
-
-const defaults = { host: "localhost", port: 8000 };
+const defaults = { host: 'localhost', port: 8000 };
 const source = { port: 8080 };
 
 const config = Hoek.applyToDefaults(defaults, source); // results in { host: "localhost", port: 8080 }
@@ -114,8 +111,7 @@ const config = Hoek.applyToDefaults(defaults, source); // results in { host: "lo
 Apply source with a null value to a copy of the defaults
 
 ```javascript
-
-const defaults = { host: "localhost", port: 8000 };
+const defaults = { host: 'localhost', port: 8000 };
 const source = { host: null, port: 8080 };
 
 const config = Hoek.applyToDefaults(defaults, source, { nullOverride: true }); // results in { host: null, port: 8080 }
@@ -124,27 +120,27 @@ const config = Hoek.applyToDefaults(defaults, source, { nullOverride: true }); /
 Apply source to a copy of the defaults where the shallow keys specified in the last parameter are shallow copied from source instead of merged
 
 ```javascript
-
 const defaults = {
     db: {
         server: {
-            host: "localhost",
-            port: 8000
+            host: 'localhost',
+            port: 8000,
         },
-        name: 'example'
-    }
+        name: 'example',
+    },
 };
 
 const source = { db: { server: { port: 8080 } } };
 
-const config = Hoek.applyToDefaults(defaults, source, { shallow: ['db.server'] });        // results in { db: { server: { port: 8080 }, name: 'example' } }
-const config = Hoek.applyToDefaults(defaults, source, { shallow: [['db', 'server']] });   // results in { db: { server: { port: 8080 }, name: 'example' } }
+const config = Hoek.applyToDefaults(defaults, source, { shallow: ['db.server'] }); // results in { db: { server: { port: 8080 }, name: 'example' } }
+const config = Hoek.applyToDefaults(defaults, source, { shallow: [['db', 'server']] }); // results in { db: { server: { port: 8080 }, name: 'example' } }
 ```
 
 #### deepEqual(a, b, [options])
 
 Performs a deep comparison of the two values including support for circular dependencies,
 prototype, and enumerable properties, where:
+
 - `a` - the first value.
 - `b` - the second value.
 - `options` - optional settings:
@@ -168,13 +164,13 @@ Hoek.deepEqual(Object.create(null), {}); //results in false
 #### intersect(array1, array2, [options])
 
 Find the common unique items betwee two arrays where:
+
 - `array1` - the first array.
 - `array2` - the second array.
 - `options` - optional settings:
     - `first` - if `true`, return only the first intersecting item. Defaults to `false`.
 
 ```javascript
-
 const array1 = [1, 2, 3];
 const array2 = [1, 4, 5];
 
@@ -184,6 +180,7 @@ const newArray = Hoek.intersect(array1, array2); // results in [1]
 #### contain(ref, values, [options])
 
 Tests if the reference value contains the provided values where:
+
 - `ref` - the reference string, array, or object.
 - `values` - a single or array of values to find within the `ref` value. If `ref` is an object, `values` can be a key name,
   an array of key names, or an object with key-value pairs to compare.
@@ -198,9 +195,9 @@ Note: comparing a string to overlapping values will result in failed comparison
 Also, if an object key's value does not match the provided value, `false` is returned even when `part` is specified.
 
 ```javascript
-Hoek.contain('aaa', 'a', { only: true });							// true
-Hoek.contain([{ a: 1 }], [{ a: 1 }], { deep: true });				// true
-Hoek.contain([1, 2, 2], [1, 2], { once: true });					// false
+Hoek.contain('aaa', 'a', { only: true }); // true
+Hoek.contain([{ a: 1 }], [{ a: 1 }], { deep: true }); // true
+Hoek.contain([1, 2, 2], [1, 2], { once: true }); // false
 Hoek.contain({ a: 1, b: 2, c: 3 }, { a: 1, d: 4 }, { part: true }); // true
 ```
 
@@ -209,7 +206,6 @@ Hoek.contain({ a: 1, b: 2, c: 3 }, { a: 1, d: 4 }, { part: true }); // true
 Flatten an array
 
 ```javascript
-
 const array = [1, [2, 3]];
 
 const flattenedArray = Hoek.flatten(array); // results in [1, 2, 3]
@@ -243,14 +239,13 @@ A chain including negative numbers will work like negative indices on an array.
 If chain is `null`, `undefined` or `false`, the object itself will be returned.
 
 ```javascript
-
 const chain = 'a.b.c';
-const obj = {a : {b : { c : 1}}};
+const obj = { a: { b: { c: 1 } } };
 
 Hoek.reach(obj, chain); // returns 1
 
 const chain = ['a', 'b', -1];
-const obj = {a : {b : [2,3,6]}};
+const obj = { a: { b: [2, 3, 6] } };
 
 Hoek.reach(obj, chain); // returns 6
 ```
@@ -280,7 +275,7 @@ error message) without the need to worry about invalid conversion.
 ```javascript
 const a = {};
 a.b = a;
-Hoek.stringify(a);		// Returns '[Cannot display object: Converting circular structure to JSON]'
+Hoek.stringify(a); // Returns '[Cannot display object: Converting circular structure to JSON]'
 ```
 
 ### Bench
@@ -293,21 +288,19 @@ human-readable timestamps. More accurate for benchmarking or internal timers.
 **hoek** provides convenient methods for escaping html characters. The escaped characters are as followed:
 
 ```javascript
-
 internals.htmlEscaped = {
     '&': '&',
     '<': '&lt;',
     '>': '&gt;',
     '"': '&quot;',
     "'": '&#x27;',
-    '`': '&#x60;'
+    '`': '&#x60;',
 };
 ```
 
 #### escapeHtml(string)
 
 ```javascript
-
 const string = '<html> hey </html>';
 const escapedString = Hoek.escapeHtml(string); // returns &lt;html&gt; hey &lt;/html&gt;
 ```
@@ -317,8 +310,7 @@ const escapedString = Hoek.escapeHtml(string); // returns &lt;html&gt; hey &lt;/
 Escape attribute value for use in HTTP header
 
 ```javascript
-
-const a = Hoek.escapeHeaderAttribute('I said "go w\\o me"');  //returns I said \"go w\\o me\"
+const a = Hoek.escapeHeaderAttribute('I said "go w\\o me"'); //returns I said \"go w\\o me\"
 ```
 
 #### escapeJson(string)
@@ -326,9 +318,8 @@ const a = Hoek.escapeHeaderAttribute('I said "go w\\o me"');  //returns I said \
 Unicode escapes the characters `<`, `>`, and `&` to prevent mime-sniffing older browsers mistaking JSON as HTML, and escapes line and paragraph separators for JSONP and script contexts.
 
 ```javascript
-
 const lineSeparator = String.fromCharCode(0x2028);
-const a = Hoek.escapeJson('I said <script>confirm(&).' + lineSeparator);  //returns I said \\u003cscript\\u003econfirm(\\u0026).\\u2028
+const a = Hoek.escapeJson('I said <script>confirm(&).' + lineSeparator); //returns I said \\u003cscript\\u003econfirm(\\u0026).\\u2028
 ```
 
 #### escapeRegex(string)
@@ -336,8 +327,7 @@ const a = Hoek.escapeJson('I said <script>confirm(&).' + lineSeparator);  //retu
 Escape string for Regex construction
 
 ```javascript
-
-const a = Hoek.escapeRegex('4^f$s.4*5+-_?%=#!:@|~\\/`"(>)[<]d{}s,');  // returns 4\^f\$s\.4\*5\+\-_\?%\=#\!\:@\|~\\\/`"\(>\)\[<\]d\{\}s\,
+const a = Hoek.escapeRegex('4^f$s.4*5+-_?%=#!:@|~\\/`"(>)[<]d{}s,'); // returns 4\^f\$s\.4\*5\+\-_\?%\=#\!\:@\|~\\\/`"\(>\)\[<\]d\{\}s\,
 ```
 
 ### Errors
@@ -345,17 +335,17 @@ const a = Hoek.escapeRegex('4^f$s.4*5+-_?%=#!:@|~\\/`"(>)[<]d{}s,');  // returns
 #### assert(condition, message)
 
 ```javascript
+const a = 1,
+    b = 2;
 
-const a = 1, b = 2;
-
-Hoek.assert(a === b, 'a should equal b');  // Throws 'a should equal b'
+Hoek.assert(a === b, 'a should equal b'); // Throws 'a should equal b'
 ```
 
 Note that you may also pass an already created Error object as the second parameter, and `assert` will throw that object.
 
 ```javascript
-
-const a = 1, b = 2;
+const a = 1,
+    b = 2;
 
 Hoek.assert(a === b, new Error('a should equal b')); // Throws the given error object
 ```
@@ -367,7 +357,6 @@ Hoek.assert(a === b, new Error('a should equal b')); // Throws the given error o
 Returns a new function that can be run multiple times, but makes sure `fn` is only run once.
 
 ```javascript
-
 const myFn = function () {
     console.log('Ran myFn');
 };
@@ -384,6 +373,7 @@ A simple no-op function. It does nothing at all.
 ### Promises
 
 #### wait(timeout, [returnValue])
+
 Resolve the promise after `timeout` milliseconds with the provided `returnValue`.
 
 ```javascript
@@ -392,12 +382,13 @@ const timeout = Hoek.wait(1000, 'timeout'); // resolves after 1s with 'timeout'
 ```
 
 #### block()
-A no-op Promise. Does nothing.
 
+A no-op Promise. Does nothing.
 
 #### isPromise(promise)
 
 Determines if an item is a promise where:
+
 - `promise` - the item being tested.
 
 Returns `true` is the item is a promise, otherwise `false`.
diff --git a/lib/applyToDefaults.d.ts b/lib/applyToDefaults.d.ts
deleted file mode 100644
index 8236d9af..00000000
--- a/lib/applyToDefaults.d.ts
+++ /dev/null
@@ -1,3 +0,0 @@
-import { applyToDefaults } from "./index";
-
-export = applyToDefaults;
diff --git a/lib/applyToDefaults.js b/lib/applyToDefaults.js
deleted file mode 100755
index 9881247b..00000000
--- a/lib/applyToDefaults.js
+++ /dev/null
@@ -1,102 +0,0 @@
-'use strict';
-
-const Assert = require('./assert');
-const Clone = require('./clone');
-const Merge = require('./merge');
-const Reach = require('./reach');
-
-
-const internals = {};
-
-
-module.exports = function (defaults, source, options = {}) {
-
-    Assert(defaults && typeof defaults === 'object', 'Invalid defaults value: must be an object');
-    Assert(!source || source === true || typeof source === 'object', 'Invalid source value: must be true, falsy or an object');
-    Assert(typeof options === 'object', 'Invalid options: must be an object');
-
-    if (!source) {                                                  // If no source, return null
-        return null;
-    }
-
-    if (options.shallow) {
-        return internals.applyToDefaultsWithShallow(defaults, source, options);
-    }
-
-    const copy = Clone(defaults);
-
-    if (source === true) {                                          // If source is set to true, use defaults
-        return copy;
-    }
-
-    const nullOverride = options.nullOverride !== undefined ? options.nullOverride : false;
-    return Merge(copy, source, { nullOverride, mergeArrays: false });
-};
-
-
-internals.applyToDefaultsWithShallow = function (defaults, source, options) {
-
-    const keys = options.shallow;
-    Assert(Array.isArray(keys), 'Invalid keys');
-
-    const seen = new Map();
-    const merge = source === true ? null : new Set();
-
-    for (let key of keys) {
-        key = Array.isArray(key) ? key : key.split('.');            // Pre-split optimization
-
-        const ref = Reach(defaults, key);
-        if (ref &&
-            typeof ref === 'object') {
-
-            seen.set(ref, merge && Reach(source, key) || ref);
-        }
-        else if (merge) {
-            merge.add(key);
-        }
-    }
-
-    const copy = Clone(defaults, {}, seen);
-
-    if (!merge) {
-        return copy;
-    }
-
-    for (const key of merge) {
-        internals.reachCopy(copy, source, key);
-    }
-
-    const nullOverride = options.nullOverride !== undefined ? options.nullOverride : false;
-    return Merge(copy, source, { nullOverride, mergeArrays: false });
-};
-
-
-internals.reachCopy = function (dst, src, path) {
-
-    for (const segment of path) {
-        if (!(segment in src)) {
-            return;
-        }
-
-        const val = src[segment];
-
-        if (typeof val !== 'object' || val === null) {
-            return;
-        }
-
-        src = val;
-    }
-
-    const value = src;
-    let ref = dst;
-    for (let i = 0; i < path.length - 1; ++i) {
-        const segment = path[i];
-        if (typeof ref[segment] !== 'object') {
-            ref[segment] = {};
-        }
-
-        ref = ref[segment];
-    }
-
-    ref[path[path.length - 1]] = value;
-};
diff --git a/lib/assert.d.ts b/lib/assert.d.ts
deleted file mode 100644
index 732b5206..00000000
--- a/lib/assert.d.ts
+++ /dev/null
@@ -1,3 +0,0 @@
-import { assert } from "./index";
-
-export = assert;
diff --git a/lib/assert.js b/lib/assert.js
deleted file mode 100755
index acfe6180..00000000
--- a/lib/assert.js
+++ /dev/null
@@ -1,30 +0,0 @@
-'use strict';
-
-const AssertError = require('./assertError');
-const Stringify = require('./stringify');
-
-
-const internals = {};
-
-
-const assert = module.exports = function (condition, ...args) {
-
-    if (condition) {
-        return;
-    }
-
-    if (args.length === 1 &&
-        args[0] instanceof Error) {
-
-        throw args[0];
-    }
-
-    const msgs = args
-        .filter((arg) => arg !== '')
-        .map((arg) => {
-
-            return typeof arg === 'string' ? arg : arg instanceof Error ? arg.message : Stringify(arg);
-        });
-
-    throw new AssertError(msgs.join(' '), assert);
-};
diff --git a/lib/assertError.d.ts b/lib/assertError.d.ts
deleted file mode 100644
index 82f3f5be..00000000
--- a/lib/assertError.d.ts
+++ /dev/null
@@ -1,3 +0,0 @@
-import { AssertError } from "./index";
-
-export = AssertError;
diff --git a/lib/assertError.js b/lib/assertError.js
deleted file mode 100755
index 699c8b0b..00000000
--- a/lib/assertError.js
+++ /dev/null
@@ -1,18 +0,0 @@
-'use strict';
-
-const internals = {};
-
-
-module.exports = class AssertError extends Error {
-
-    name = 'AssertError';
-
-    constructor(message, ctor) {
-
-        super(message || 'Unknown error');
-
-        if (typeof Error.captureStackTrace === 'function') {            // $lab:coverage:ignore$
-            Error.captureStackTrace(this, ctor);
-        }
-    }
-};
diff --git a/lib/bench.d.ts b/lib/bench.d.ts
deleted file mode 100644
index 1fa3f4d5..00000000
--- a/lib/bench.d.ts
+++ /dev/null
@@ -1,3 +0,0 @@
-import { Bench } from "./index";
-
-export = Bench;
diff --git a/lib/bench.js b/lib/bench.js
deleted file mode 100755
index 26ee1962..00000000
--- a/lib/bench.js
+++ /dev/null
@@ -1,29 +0,0 @@
-'use strict';
-
-const internals = {};
-
-
-module.exports = internals.Bench = class {
-
-    constructor() {
-
-        this.ts = 0;
-        this.reset();
-    }
-
-    reset() {
-
-        this.ts = internals.Bench.now();
-    }
-
-    elapsed() {
-
-        return internals.Bench.now() - this.ts;
-    }
-
-    static now() {
-
-        const ts = process.hrtime();
-        return (ts[0] * 1e3) + (ts[1] / 1e6);
-    }
-};
diff --git a/lib/block.d.ts b/lib/block.d.ts
deleted file mode 100644
index 0385864f..00000000
--- a/lib/block.d.ts
+++ /dev/null
@@ -1,3 +0,0 @@
-import { block } from "./index";
-
-export = block;
diff --git a/lib/block.js b/lib/block.js
deleted file mode 100755
index 73fb9a53..00000000
--- a/lib/block.js
+++ /dev/null
@@ -1,12 +0,0 @@
-'use strict';
-
-const Ignore = require('./ignore');
-
-
-const internals = {};
-
-
-module.exports = function () {
-
-    return new Promise(Ignore);
-};
diff --git a/lib/clone.d.ts b/lib/clone.d.ts
deleted file mode 100644
index 66211172..00000000
--- a/lib/clone.d.ts
+++ /dev/null
@@ -1,3 +0,0 @@
-import { clone } from "./index";
-
-export = clone;
diff --git a/lib/clone.js b/lib/clone.js
deleted file mode 100755
index fec88d75..00000000
--- a/lib/clone.js
+++ /dev/null
@@ -1,198 +0,0 @@
-'use strict';
-
-const Reach = require('./reach');
-const Types = require('./types');
-const Utils = require('./utils');
-
-
-const internals = {
-    needsProtoHack: new Set([Types.set, Types.map, Types.weakSet, Types.weakMap]),
-    structuredCloneExists: typeof structuredClone === 'function'
-};
-
-
-module.exports = internals.clone = function (obj, options = {}, _seen = null) {
-
-    if (typeof obj !== 'object' ||
-        obj === null) {
-
-        return obj;
-    }
-
-    let clone = internals.clone;
-    let seen = _seen;
-
-    if (options.shallow) {
-        if (options.shallow !== true) {
-            return internals.cloneWithShallow(obj, options);
-        }
-
-        clone = (value) => value;
-    }
-    else if (seen) {
-        const lookup = seen.get(obj);
-        if (lookup) {
-            return lookup;
-        }
-    }
-    else {
-        seen = new Map();
-    }
-
-    // Built-in object types
-
-    const baseProto = Types.getInternalProto(obj);
-    switch (baseProto) {
-        case Types.buffer:
-            return Buffer?.from(obj);
-        case Types.date:
-            return new Date(obj.getTime());
-        case Types.regex:
-        case Types.url:
-            return new baseProto.constructor(obj);
-    }
-
-    // Generic objects
-
-    const newObj = internals.base(obj, baseProto, options);
-    if (newObj === obj) {
-        return obj;
-    }
-
-    if (seen) {
-        seen.set(obj, newObj);                              // Set seen, since obj could recurse
-    }
-
-    if (baseProto === Types.set) {
-        for (const value of obj) {
-            newObj.add(clone(value, options, seen));
-        }
-    }
-    else if (baseProto === Types.map) {
-        for (const [key, value] of obj) {
-            newObj.set(key, clone(value, options, seen));
-        }
-    }
-
-    const keys = Utils.keys(obj, options);
-    for (const key of keys) {
-        if (key === '__proto__') {
-            continue;
-        }
-
-        if (baseProto === Types.array &&
-            key === 'length') {
-
-            newObj.length = obj.length;
-            continue;
-        }
-
-        // Can only be covered in node 21+
-        /* $lab:coverage:off$ */
-        if (internals.structuredCloneExists &&
-            baseProto === Types.error &&
-            key === 'stack') {
-
-            continue;       // Already a part of the base object
-        }
-        /* $lab:coverage:on$ */
-
-        const descriptor = Object.getOwnPropertyDescriptor(obj, key);
-        if (descriptor) {
-            if (descriptor.get ||
-                descriptor.set) {
-
-                Object.defineProperty(newObj, key, descriptor);
-            }
-            else if (descriptor.enumerable) {
-                newObj[key] = clone(obj[key], options, seen);
-            }
-            else {
-                Object.defineProperty(newObj, key, { enumerable: false, writable: true, configurable: true, value: clone(obj[key], options, seen) });
-            }
-        }
-        else {
-            Object.defineProperty(newObj, key, {
-                enumerable: true,
-                writable: true,
-                configurable: true,
-                value: clone(obj[key], options, seen)
-            });
-        }
-    }
-
-    return newObj;
-};
-
-
-internals.cloneWithShallow = function (source, options) {
-
-    const keys = options.shallow;
-    options = Object.assign({}, options);
-    options.shallow = false;
-
-    const seen = new Map();
-
-    for (const key of keys) {
-        const ref = Reach(source, key);
-        if (typeof ref === 'object' ||
-            typeof ref === 'function') {
-
-            seen.set(ref, ref);
-        }
-    }
-
-    return internals.clone(source, options, seen);
-};
-
-
-internals.base = function (obj, baseProto, options) {
-
-    if (options.prototype === false) {                  // Defaults to true
-        if (internals.needsProtoHack.has(baseProto)) {
-            return new baseProto.constructor();
-        }
-
-        return baseProto === Types.array ? [] : {};
-    }
-
-    const proto = Object.getPrototypeOf(obj);
-    if (proto &&
-        proto.isImmutable) {
-
-        return obj;
-    }
-
-    if (baseProto === Types.array) {
-        const newObj = [];
-        if (proto !== baseProto) {
-            Object.setPrototypeOf(newObj, proto);
-        }
-
-        return newObj;
-    }
-    // Can only be covered in node 21+
-    /* $lab:coverage:off$ */
-    else if (baseProto === Types.error && internals.structuredCloneExists &&
-        (proto === baseProto || Error.isPrototypeOf(proto.constructor))) {      // Don't match Util.inherit() subclassed errors
-
-        const err = structuredClone(obj);                                       // Needed to copy internal stack state
-        if (Object.getPrototypeOf(err) !== proto) {
-            Object.setPrototypeOf(err, proto);                                  // Fix prototype
-        }
-
-        return err;
-    }
-    /* $lab:coverage:on$ */
-
-    if (internals.needsProtoHack.has(baseProto)) {
-        const newObj = new proto.constructor();
-        if (proto !== baseProto) {
-            Object.setPrototypeOf(newObj, proto);
-        }
-
-        return newObj;
-    }
-
-    return Object.create(proto);
-};
diff --git a/lib/contain.d.ts b/lib/contain.d.ts
deleted file mode 100644
index 03b40c8a..00000000
--- a/lib/contain.d.ts
+++ /dev/null
@@ -1,3 +0,0 @@
-import { contain } from "./index";
-
-export = contain;
diff --git a/lib/deepEqual.d.ts b/lib/deepEqual.d.ts
deleted file mode 100644
index 8be0ea62..00000000
--- a/lib/deepEqual.d.ts
+++ /dev/null
@@ -1,3 +0,0 @@
-import { deepEqual } from "./index";
-
-export = deepEqual;
diff --git a/lib/deepEqual.js b/lib/deepEqual.js
deleted file mode 100755
index a41df5a9..00000000
--- a/lib/deepEqual.js
+++ /dev/null
@@ -1,317 +0,0 @@
-'use strict';
-
-const Types = require('./types');
-
-
-const internals = {
-    mismatched: null
-};
-
-
-module.exports = function (obj, ref, options) {
-
-    options = Object.assign({ prototype: true }, options);
-
-    return !!internals.isDeepEqual(obj, ref, options, []);
-};
-
-
-internals.isDeepEqual = function (obj, ref, options, seen) {
-
-    if (obj === ref) {                                                      // Copied from Deep-eql, copyright(c) 2013 Jake Luer, jake@alogicalparadox.com, MIT Licensed, https://github.com/chaijs/deep-eql
-        return obj !== 0 || 1 / obj === 1 / ref;
-    }
-
-    const type = typeof obj;
-
-    if (type !== typeof ref) {
-        return false;
-    }
-
-    if (obj === null ||
-        ref === null) {
-
-        return false;
-    }
-
-    if (type === 'function') {
-        if (!options.deepFunction ||
-            obj.toString() !== ref.toString()) {
-
-            return false;
-        }
-
-        // Continue as object
-    }
-    else if (type !== 'object') {
-        return obj !== obj && ref !== ref;                                  // NaN
-    }
-
-    const instanceType = internals.getSharedType(obj, ref, !!options.prototype);
-    switch (instanceType) {
-        case Types.buffer:
-            return Buffer && Buffer.prototype.equals.call(obj, ref);        // $lab:coverage:ignore$
-        case Types.promise:
-            return obj === ref;
-        case Types.regex:
-        case Types.url:
-            return obj.toString() === ref.toString();
-        case internals.mismatched:
-            return false;
-    }
-
-    for (let i = seen.length - 1; i >= 0; --i) {
-        if (seen[i].isSame(obj, ref)) {
-            return true;                                                    // If previous comparison failed, it would have stopped execution
-        }
-    }
-
-    seen.push(new internals.SeenEntry(obj, ref));
-
-    try {
-        return !!internals.isDeepEqualObj(instanceType, obj, ref, options, seen);
-    }
-    finally {
-        seen.pop();
-    }
-};
-
-
-internals.getSharedType = function (obj, ref, checkPrototype) {
-
-    if (checkPrototype) {
-        if (Object.getPrototypeOf(obj) !== Object.getPrototypeOf(ref)) {
-            return internals.mismatched;
-        }
-
-        return Types.getInternalProto(obj);
-    }
-
-    const type = Types.getInternalProto(obj);
-    if (type !== Types.getInternalProto(ref)) {
-        return internals.mismatched;
-    }
-
-    return type;
-};
-
-
-internals.valueOf = function (obj) {
-
-    const objValueOf = obj.valueOf;
-    if (objValueOf === undefined) {
-        return obj;
-    }
-
-    try {
-        return objValueOf.call(obj);
-    }
-    catch (err) {
-        return err;
-    }
-};
-
-
-internals.hasOwnEnumerableProperty = function (obj, key) {
-
-    return Object.prototype.propertyIsEnumerable.call(obj, key);
-};
-
-
-internals.isSetSimpleEqual = function (obj, ref) {
-
-    for (const entry of Set.prototype.values.call(obj)) {
-        if (!Set.prototype.has.call(ref, entry)) {
-            return false;
-        }
-    }
-
-    return true;
-};
-
-
-internals.isDeepEqualObj = function (instanceType, obj, ref, options, seen) {
-
-    const { isDeepEqual, valueOf, hasOwnEnumerableProperty } = internals;
-    const { keys, getOwnPropertySymbols } = Object;
-
-    if (instanceType === Types.array) {
-        if (options.part) {
-
-            // Check if any index match any other index
-
-            for (const objValue of obj) {
-                for (const refValue of ref) {
-                    if (isDeepEqual(objValue, refValue, options, seen)) {
-                        return true;
-                    }
-                }
-            }
-        }
-        else {
-            if (obj.length !== ref.length) {
-                return false;
-            }
-
-            for (let i = 0; i < obj.length; ++i) {
-                if (!isDeepEqual(obj[i], ref[i], options, seen)) {
-                    return false;
-                }
-            }
-
-            return true;
-        }
-    }
-    else if (instanceType === Types.set) {
-        if (obj.size !== ref.size) {
-            return false;
-        }
-
-        if (!internals.isSetSimpleEqual(obj, ref)) {
-
-            // Check for deep equality
-
-            const ref2 = new Set(Set.prototype.values.call(ref));
-            for (const objEntry of Set.prototype.values.call(obj)) {
-                if (ref2.delete(objEntry)) {
-                    continue;
-                }
-
-                let found = false;
-                for (const refEntry of ref2) {
-                    if (isDeepEqual(objEntry, refEntry, options, seen)) {
-                        ref2.delete(refEntry);
-                        found = true;
-                        break;
-                    }
-                }
-
-                if (!found) {
-                    return false;
-                }
-            }
-        }
-    }
-    else if (instanceType === Types.map) {
-        if (obj.size !== ref.size) {
-            return false;
-        }
-
-        for (const [key, value] of Map.prototype.entries.call(obj)) {
-            if (value === undefined && !Map.prototype.has.call(ref, key)) {
-                return false;
-            }
-
-            if (!isDeepEqual(value, Map.prototype.get.call(ref, key), options, seen)) {
-                return false;
-            }
-        }
-    }
-    else if (instanceType === Types.error) {
-
-        // Always check name and message
-
-        if (obj.name !== ref.name ||
-            obj.message !== ref.message) {
-
-            return false;
-        }
-    }
-
-    // Check .valueOf()
-
-    const valueOfObj = valueOf(obj);
-    const valueOfRef = valueOf(ref);
-    if ((obj !== valueOfObj || ref !== valueOfRef) &&
-        !isDeepEqual(valueOfObj, valueOfRef, options, seen)) {
-
-        return false;
-    }
-
-    // Check properties
-
-    const objKeys = keys(obj);
-    if (!options.part &&
-        objKeys.length !== keys(ref).length &&
-        !options.skip) {
-
-        return false;
-    }
-
-    let skipped = 0;
-    for (const key of objKeys) {
-        if (options.skip &&
-            options.skip.includes(key)) {
-
-            if (ref[key] === undefined) {
-                ++skipped;
-            }
-
-            continue;
-        }
-
-        if (!hasOwnEnumerableProperty(ref, key)) {
-            return false;
-        }
-
-        if (!isDeepEqual(obj[key], ref[key], options, seen)) {
-            return false;
-        }
-    }
-
-    if (!options.part &&
-        objKeys.length - skipped !== keys(ref).length) {
-
-        return false;
-    }
-
-    // Check symbols
-
-    if (options.symbols !== false) {                                // Defaults to true
-        const objSymbols = getOwnPropertySymbols(obj);
-        const refSymbols = new Set(getOwnPropertySymbols(ref));
-
-        for (const key of objSymbols) {
-            if (!options.skip?.includes(key)) {
-
-                if (hasOwnEnumerableProperty(obj, key)) {
-                    if (!hasOwnEnumerableProperty(ref, key)) {
-                        return false;
-                    }
-
-                    if (!isDeepEqual(obj[key], ref[key], options, seen)) {
-                        return false;
-                    }
-                }
-                else if (hasOwnEnumerableProperty(ref, key)) {
-                    return false;
-                }
-            }
-
-            refSymbols.delete(key);
-        }
-
-        for (const key of refSymbols) {
-            if (hasOwnEnumerableProperty(ref, key)) {
-                return false;
-            }
-        }
-    }
-
-    return true;
-};
-
-
-internals.SeenEntry = class {
-
-    constructor(obj, ref) {
-
-        this.obj = obj;
-        this.ref = ref;
-    }
-
-    isSame(obj, ref) {
-
-        return this.obj === obj && this.ref === ref;
-    }
-};
diff --git a/lib/escapeHeaderAttribute.d.ts b/lib/escapeHeaderAttribute.d.ts
deleted file mode 100644
index 78117c8f..00000000
--- a/lib/escapeHeaderAttribute.d.ts
+++ /dev/null
@@ -1,3 +0,0 @@
-import { escapeHeaderAttribute } from "./index";
-
-export = escapeHeaderAttribute;
diff --git a/lib/escapeHeaderAttribute.js b/lib/escapeHeaderAttribute.js
deleted file mode 100755
index a0a4deea..00000000
--- a/lib/escapeHeaderAttribute.js
+++ /dev/null
@@ -1,16 +0,0 @@
-'use strict';
-
-const Assert = require('./assert');
-
-
-const internals = {};
-
-
-module.exports = function (attribute) {
-
-    // Allowed value characters: !#$%&'()*+,-./:;<=>?@[]^_`{|}~ and space, a-z, A-Z, 0-9, \, "
-
-    Assert(/^[ \w\!#\$%&'\(\)\*\+,\-\.\/\:;<\=>\?@\[\]\^`\{\|\}~\"\\]*$/.test(attribute), 'Bad attribute value (' + attribute + ')');
-
-    return attribute.replace(/\\/g, '\\\\').replace(/\"/g, '\\"');                             // Escape quotes and slash
-};
diff --git a/lib/escapeHtml.d.ts b/lib/escapeHtml.d.ts
deleted file mode 100644
index 5113b984..00000000
--- a/lib/escapeHtml.d.ts
+++ /dev/null
@@ -1,3 +0,0 @@
-import { escapeHtml } from "./index";
-
-export = escapeHtml;
diff --git a/lib/escapeHtml.js b/lib/escapeHtml.js
deleted file mode 100755
index c2dd4436..00000000
--- a/lib/escapeHtml.js
+++ /dev/null
@@ -1,87 +0,0 @@
-'use strict';
-
-const internals = {};
-
-
-module.exports = function (input) {
-
-    if (!input) {
-        return '';
-    }
-
-    let escaped = '';
-
-    for (let i = 0; i < input.length; ++i) {
-
-        const charCode = input.charCodeAt(i);
-
-        if (internals.isSafe(charCode)) {
-            escaped += input[i];
-        }
-        else {
-            escaped += internals.escapeHtmlChar(charCode);
-        }
-    }
-
-    return escaped;
-};
-
-
-internals.escapeHtmlChar = function (charCode) {
-
-    const namedEscape = internals.namedHtml.get(charCode);
-    if (namedEscape) {
-        return namedEscape;
-    }
-
-    if (charCode >= 256) {
-        return '&#' + charCode + ';';
-    }
-
-    const hexValue = charCode.toString(16).padStart(2, '0');
-    return `&#x${hexValue};`;
-};
-
-
-internals.isSafe = function (charCode) {
-
-    return internals.safeCharCodes.has(charCode);
-};
-
-
-internals.namedHtml = new Map([
-    [38, '&amp;'],
-    [60, '&lt;'],
-    [62, '&gt;'],
-    [34, '&quot;'],
-    [160, '&nbsp;'],
-    [162, '&cent;'],
-    [163, '&pound;'],
-    [164, '&curren;'],
-    [169, '&copy;'],
-    [174, '&reg;']
-]);
-
-
-internals.safeCharCodes = (function () {
-
-    const safe = new Set();
-
-    for (let i = 32; i < 123; ++i) {
-
-        if ((i >= 97) ||                    // a-z
-            (i >= 65 && i <= 90) ||         // A-Z
-            (i >= 48 && i <= 57) ||         // 0-9
-            i === 32 ||                     // space
-            i === 46 ||                     // .
-            i === 44 ||                     // ,
-            i === 45 ||                     // -
-            i === 58 ||                     // :
-            i === 95) {                     // _
-
-            safe.add(i);
-        }
-    }
-
-    return safe;
-}());
diff --git a/lib/escapeJson.d.ts b/lib/escapeJson.d.ts
deleted file mode 100644
index bbbd1e75..00000000
--- a/lib/escapeJson.d.ts
+++ /dev/null
@@ -1,3 +0,0 @@
-import { escapeJson } from "./index";
-
-export = escapeJson;
diff --git a/lib/escapeJson.js b/lib/escapeJson.js
deleted file mode 100755
index 243edfb9..00000000
--- a/lib/escapeJson.js
+++ /dev/null
@@ -1,28 +0,0 @@
-'use strict';
-
-const internals = {};
-
-
-module.exports = function (input) {
-
-    if (!input) {
-        return '';
-    }
-
-    return input.replace(/[<>&\u2028\u2029]/g, internals.escape);
-};
-
-
-internals.escape = function (char) {
-
-    return internals.replacements.get(char);
-};
-
-
-internals.replacements = new Map([
-    ['<', '\\u003c'],
-    ['>', '\\u003e'],
-    ['&', '\\u0026'],
-    ['\u2028', '\\u2028'],
-    ['\u2029', '\\u2029']
-]);
diff --git a/lib/escapeRegex.d.ts b/lib/escapeRegex.d.ts
deleted file mode 100644
index 2685ccf8..00000000
--- a/lib/escapeRegex.d.ts
+++ /dev/null
@@ -1,3 +0,0 @@
-import { escapeRegex } from "./index";
-
-export = escapeRegex;
diff --git a/lib/escapeRegex.js b/lib/escapeRegex.js
deleted file mode 100755
index 3272497e..00000000
--- a/lib/escapeRegex.js
+++ /dev/null
@@ -1,11 +0,0 @@
-'use strict';
-
-const internals = {};
-
-
-module.exports = function (string) {
-
-    // Escape ^$.*+-?=!:|\/()[]{},
-
-    return string.replace(/[\^\$\.\*\+\-\?\=\!\:\|\\\/\(\)\[\]\{\}\,]/g, '\\$&');
-};
diff --git a/lib/flatten.d.ts b/lib/flatten.d.ts
deleted file mode 100644
index 53dc4b6e..00000000
--- a/lib/flatten.d.ts
+++ /dev/null
@@ -1,3 +0,0 @@
-import { flatten } from "./index";
-
-export = flatten;
diff --git a/lib/flatten.js b/lib/flatten.js
deleted file mode 100755
index a5ea622a..00000000
--- a/lib/flatten.js
+++ /dev/null
@@ -1,20 +0,0 @@
-'use strict';
-
-const internals = {};
-
-
-module.exports = internals.flatten = function (array, target) {
-
-    const result = target || [];
-
-    for (const entry of array) {
-        if (Array.isArray(entry)) {
-            internals.flatten(entry, result);
-        }
-        else {
-            result.push(entry);
-        }
-    }
-
-    return result;
-};
diff --git a/lib/ignore.d.ts b/lib/ignore.d.ts
deleted file mode 100644
index 6112ab64..00000000
--- a/lib/ignore.d.ts
+++ /dev/null
@@ -1,3 +0,0 @@
-import { ignore } from "./index";
-
-export = ignore;
diff --git a/lib/ignore.js b/lib/ignore.js
deleted file mode 100755
index 21ad1443..00000000
--- a/lib/ignore.js
+++ /dev/null
@@ -1,6 +0,0 @@
-'use strict';
-
-const internals = {};
-
-
-module.exports = function () { };
diff --git a/lib/index.d.ts b/lib/index.d.ts
deleted file mode 100644
index 00897c3c..00000000
--- a/lib/index.d.ts
+++ /dev/null
@@ -1,480 +0,0 @@
-/// <reference types="node" />
-
-
-/**
- * Performs a deep comparison of the two values including support for circular dependencies, prototype, and enumerable properties.
- *
- * @param obj - The value being compared.
- * @param ref - The reference value used for comparison.
- * 
- * @return true when the two values are equal, otherwise false.
- */
-export function deepEqual(obj: any, ref: any, options?: deepEqual.Options): boolean;
-
-export namespace deepEqual {
-
-    interface Options {
-
-        /**
-         * Compare functions with difference references by comparing their internal code and properties.
-         *
-         * @default false
-         */
-        readonly deepFunction?: boolean;
-
-        /**
-         * Allow partial match.
-         *
-         * @default false
-         */
-        readonly part?: boolean;
-
-        /**
-         * Compare the objects' prototypes.
-         *
-         * @default true
-         */
-        readonly prototype?: boolean;
-
-        /**
-         * List of object keys to ignore different values of.
-         *
-         * @default null
-         */
-        readonly skip?: (string | symbol)[];
-
-        /**
-         * Compare symbol properties.
-         *
-         * @default true
-         */
-        readonly symbols?: boolean;
-    }
-}
-
-
-/**
- * Clone any value, object, or array.
- *
- * @param obj - The value being cloned.
- * @param options - Optional settings.
- *
- * @returns A deep clone of `obj`.
- */
-export function clone<T>(obj: T, options?: clone.Options): T;
-
-export namespace clone {
-
-    interface Options {
-
-        /**
-         * Clone the object's prototype.
-         *
-         * @default true
-         */
-        readonly prototype?: boolean;
-
-        /**
-         * Include symbol properties.
-         *
-         * @default true
-         */
-        readonly symbols?: boolean;
-
-        /**
-         * Shallow clone the specified keys.
-         *
-         * @default undefined
-         */
-        readonly shallow?: string[] | string[][] | boolean;
-    }
-}
-
-
-/**
- * Merge all the properties of source into target.
- *
- * @param target - The object being modified.
- * @param source - The object used to copy properties from.
- * @param options - Optional settings.
- *
- * @returns The `target` object.
- */
-export function merge<T1 extends object, T2 extends object>(target: T1, source: T2, options?: merge.Options): T1 & T2;
-
-export namespace merge {
-
-    interface Options {
-
-        /**
-         * When true, null value from `source` overrides existing value in `target`.
-         *
-         * @default true
-         */
-        readonly nullOverride?: boolean;
-
-        /**
-         * When true, array value from `source` is merged with the existing value in `target`.
-         *
-         * @default true
-         */
-        readonly mergeArrays?: boolean;
-
-        /**
-         * Compare symbol properties.
-         *
-         * @default undefined
-         */
-        readonly symbols?: boolean;
-    }
-}
-
-
-/**
- * Apply source to a copy of the defaults.
- *
- * @param defaults - An object with the default values to use of `options` does not contain the same keys.
- * @param source - The source used to override the `defaults`.
- * @param options - Optional settings.
- *
- * @returns A copy of `defaults` with `source` keys overriding any conflicts.
- */
-export function applyToDefaults<T extends object>(defaults: Partial<T>, source: Partial<T> | boolean | null, options?: applyToDefaults.Options): Partial<T>;
-
-export namespace applyToDefaults {
-
-    interface Options {
-
-        /**
-         * When true, null value from `source` overrides existing value in `target`.
-         *
-         * @default true
-         */
-        readonly nullOverride?: boolean;
-
-        /**
-         * Shallow clone the specified keys.
-         *
-         * @default undefined
-         */
-        readonly shallow?: string[] | string[][];
-    }
-}
-
-
-/**
- * Find the common unique items in two arrays.
- *
- * @param array1 - The first array to compare.
- * @param array2 - The second array to compare.
- * @param options - Optional settings.
- *
- * @return - An array of the common items. If `justFirst` is true, returns the first common item.
- */
-export function intersect<T1, T2>(array1: intersect.Array<T1>, array2: intersect.Array<T2>, options?: intersect.Options): Array<T1 | T2>;
-export function intersect<T1, T2>(array1: intersect.Array<T1>, array2: intersect.Array<T2>, options?: intersect.Options): T1 | T2;
-
-export namespace intersect {
-
-    type Array<T> = ArrayLike<T> | Set<T> | null;
-
-    interface Options {
-
-        /**
-         * When true, return the first overlapping value.
-         *
-         * @default false
-         */
-        readonly first?: boolean;
-    }
-}
-
-
-/**
- * Checks if the reference value contains the provided values.
- *
- * @param ref - The reference string, array, or object.
- * @param values - A single or array of values to find within `ref`. If `ref` is an object, `values` can be a key name, an array of key names, or an object with key-value pairs to compare.
- *
- * @return true if the value contains the provided values, otherwise false.
- */
-export function contain(ref: string, values: string | string[], options?: contain.Options): boolean;
-export function contain(ref: any[], values: any, options?: contain.Options): boolean;
-export function contain(ref: object, values: string | string[] | object, options?: Omit<contain.Options, 'once'>): boolean;
-
-export namespace contain {
-
-    interface Options {
-
-        /**
-         * Perform a deep comparison.
-         *
-         * @default false
-         */
-        readonly deep?: boolean;
-
-        /**
-         * Allow only one occurrence of each value.
-         *
-         * @default false
-         */
-        readonly once?: boolean;
-
-        /**
-         * Allow only values explicitly listed.
-         *
-         * @default false
-         */
-        readonly only?: boolean;
-
-        /**
-         * Allow partial match.
-         *
-         * @default false
-         */
-        readonly part?: boolean;
-
-        /**
-         * Include symbol properties.
-         *
-         * @default true
-         */
-        readonly symbols?: boolean;
-    }
-}
-
-
-/**
- * Flatten an array with sub arrays
- *
- * @param array - an array of items or other arrays to flatten.
- * @param target - if provided, an array to shallow copy the flattened `array` items to
- *
- * @return a flat array of the provided values (appended to `target` is provided).
- */
-export function flatten<T>(array: ArrayLike<T | ReadonlyArray<T>>, target?: ArrayLike<T | ReadonlyArray<T>>): T[];
-
-
-/**
- * Convert an object key chain string to reference.
- *
- * @param obj - the object from which to look up the value.
- * @param chain - the string path of the requested value. The chain string is split into key names using `options.separator`, or an array containing each individual key name. A chain including negative numbers will work like a negative index on an array.
- *
- * @return The value referenced by the chain if found, otherwise undefined. If chain is null, undefined, or false, the object itself will be returned.
- */
-export function reach(obj: object | null, chain: string | (string | number)[] | false | null | undefined, options?: reach.Options): any;
-
-export namespace reach {
-
-    interface Options {
-
-        /**
-         * String to split chain path on. Defaults to '.'.
-         *
-         * @default false
-         */
-        readonly separator?: string;
-
-        /**
-         * Value to return if the path or value is not present. No default value.
-         *
-         * @default false
-         */
-        readonly default?: any;
-
-        /**
-         * If true, will throw an error on missing member in the chain. Default to false.
-         *
-         * @default false
-         */
-        readonly strict?: boolean;
-
-        /**
-         * If true, allows traversing functions for properties. false will throw an error if a function is part of the chain.
-         *
-         * @default true
-         */
-        readonly functions?: boolean;
-
-        /**
-         * If true, allows traversing Set and Map objects for properties. false will return undefined regardless of the Set or Map passed.
-         *
-         * @default false
-         */
-        readonly iterables?: boolean;
-    }
-}
-
-
-/**
- * Replace string parameters (using format "{path.to.key}") with their corresponding object key values using `Hoek.reach()`.
- *
- * @param obj - the object from which to look up the value.
- * @param template - the string containing {} enclosed key paths to be replaced.
- *
- * @return The template string with the {} enclosed keys replaced with looked-up values.
- */
-export function reachTemplate(obj: object | null, template: string, options?: reach.Options): string;
-
-
-/**
- * Throw an error if condition is falsy.
- *
- * @param condition - If `condition` is not truthy, an exception is thrown.
- * @param error - The error thrown if the condition fails.
- *
- * @return Does not return a value but throws if the `condition` is falsy.
- */
-export function assert(condition: any, error: Error): asserts condition;
-
-
-/**
- * Throw an error if condition is falsy.
- *
- * @param condition - If `condition` is not truthy, an exception is thrown.
- * @param args - Any number of values, concatenated together (space separated) to create the error message.
- *
- * @return Does not return a value but throws if the `condition` is falsy.
- */
-export function assert(condition: any, ...args: any): asserts condition;
-
-
-/**
- * Assertion Error as thrown from Hoek.assert().
- */
-export class AssertError extends Error {
-
-    name: 'AssertError';
-}
-
-
-/**
- * A benchmarking timer, using the internal node clock for maximum accuracy.
- */
-export class Bench {
-
-    constructor();
-
-    /** The starting timestamp expressed in the number of milliseconds since the epoch. */
-    ts: number;
-
-    /** The time in milliseconds since the object was created. */
-    elapsed(): number;
-
-    /** Reset the `ts` value to now. */
-    reset(): void;
-
-    /** The current time in milliseconds since the epoch. */
-    static now(): number;
-}
-
-
-/**
- * Escape string for Regex construction by prefixing all reserved characters with a backslash.
- *
- * @param string - The string to be escaped.
- *
- * @return The escaped string.
- */
-export function escapeRegex(string: string): string;
-
-
-/**
- * Escape string for usage as an attribute value in HTTP headers.
- *
- * @param attribute - The string to be escaped.
- *
- * @return The escaped string. Will throw on invalid characters that are not supported to be escaped.
- */
-export function escapeHeaderAttribute(attribute: string): string;
-
-
-/**
- * Escape string for usage in HTML.
- *
- * @param string - The string to be escaped.
- *
- * @return The escaped string.
- */
-export function escapeHtml(string: string): string;
-
-
-/**
- * Escape string for usage in JSON.
- *
- * @param string - The string to be escaped.
- *
- * @return The escaped string.
- */
-export function escapeJson(string: string): string;
-
-
-/**
- * Wraps a function to ensure it can only execute once.
- *
- * @param method - The function to be wrapped.
- *
- * @return The wrapped function.
- */
-export function once<T extends Function>(method: T): T;
-
-
-/**
- * A reusable no-op function.
- */
-export function ignore(...ignore: any): void;
-
-
-/**
- * Converts a JavaScript value to a JavaScript Object Notation (JSON) string with protection against thrown errors.
- *
- * @param value A JavaScript value, usually an object or array, to be converted.
- * @param replacer The JSON.stringify() `replacer` argument.
- * @param space Adds indentation, white space, and line break characters to the return-value JSON text to make it easier to read.
- *
- * @return The JSON string. If the operation fails, an error string value is returned (no exception thrown).
- */
-export function stringify(value: any, replacer?: any, space?: string | number): string;
-
-
-/**
- * Returns a Promise that resolves after the requested timeout.
- *
- * @param timeout - The number of milliseconds to wait before resolving the Promise.
- * @param returnValue - The value that the Promise will resolve to.
- *
- * @return A Promise that resolves with `returnValue`.
- */
-export function wait<T>(timeout?: number, returnValue?: T): Promise<T>;
-
-
-/**
- * Returns a Promise that never resolves.
- */
-export function block(): Promise<void>;
-
-
-/**
- * Determines if an object is a promise.
- * 
- * @param promise - the object tested.
- * 
- * @returns true if the object is a promise, otherwise false.
- */
-export function isPromise(promise: any): boolean;
-
-
-export namespace ts {
-
-    /**
-     * Defines a type that can must be one of T or U but not both.
-     */
-    type XOR<T, U> = (T | U) extends object ? (internals.Without<T, U> & U) | (internals.Without<U, T> & T) : T | U;
-}
-
-
-declare namespace internals {
-
-    type Without<T, U> = { [P in Exclude<keyof T, keyof U>]?: never };
-}
diff --git a/lib/index.js b/lib/index.js
deleted file mode 100755
index 7b4a122d..00000000
--- a/lib/index.js
+++ /dev/null
@@ -1,45 +0,0 @@
-'use strict';
-
-exports.applyToDefaults = require('./applyToDefaults');
-
-exports.assert = require('./assert');
-
-exports.AssertError = require('./assertError');
-
-exports.Bench = require('./bench');
-
-exports.block = require('./block');
-
-exports.clone = require('./clone');
-
-exports.contain = require('./contain');
-
-exports.deepEqual = require('./deepEqual');
-
-exports.escapeHeaderAttribute = require('./escapeHeaderAttribute');
-
-exports.escapeHtml = require('./escapeHtml');
-
-exports.escapeJson = require('./escapeJson');
-
-exports.escapeRegex = require('./escapeRegex');
-
-exports.flatten = require('./flatten');
-
-exports.ignore = require('./ignore');
-
-exports.intersect = require('./intersect');
-
-exports.isPromise = require('./isPromise');
-
-exports.merge = require('./merge');
-
-exports.once = require('./once');
-
-exports.reach = require('./reach');
-
-exports.reachTemplate = require('./reachTemplate');
-
-exports.stringify = require('./stringify');
-
-exports.wait = require('./wait');
diff --git a/lib/index.mjs b/lib/index.mjs
deleted file mode 100755
index 7205b2ac..00000000
--- a/lib/index.mjs
+++ /dev/null
@@ -1,43 +0,0 @@
-export { default as applyToDefaults } from './applyToDefaults.js';
-
-export { default as assert } from './assert.js';
-
-export { default as Bench } from './bench.js';
-
-export { default as block } from './block.js';
-
-export { default as clone } from './clone.js';
-
-export { default as contain } from './contain.js';
-
-export { default as deepEqual } from './deepEqual.js';
-
-export { default as AssertError } from './assertError.js';
-
-export { default as escapeHeaderAttribute } from './escapeHeaderAttribute.js';
-
-export { default as escapeHtml } from './escapeHtml.js';
-
-export { default as escapeJson } from './escapeJson.js';
-
-export { default as escapeRegex } from './escapeRegex.js';
-
-export { default as flatten } from './flatten.js';
-
-export { default as ignore } from './ignore.js';
-
-export { default as intersect } from './intersect.js';
-
-export { default as isPromise } from './isPromise.js';
-
-export { default as merge } from './merge.js';
-
-export { default as once } from './once.js';
-
-export { default as reach } from './reach.js';
-
-export { default as reachTemplate } from './reachTemplate.js';
-
-export { default as stringify } from './stringify.js';
-
-export { default as wait } from './wait.js';
diff --git a/lib/intersect.d.ts b/lib/intersect.d.ts
deleted file mode 100644
index eeb8fd1b..00000000
--- a/lib/intersect.d.ts
+++ /dev/null
@@ -1,3 +0,0 @@
-import { intersect } from "./index";
-
-export = intersect;
diff --git a/lib/intersect.js b/lib/intersect.js
deleted file mode 100755
index 59e6aaf1..00000000
--- a/lib/intersect.js
+++ /dev/null
@@ -1,41 +0,0 @@
-'use strict';
-
-const internals = {};
-
-
-module.exports = function (array1, array2, options = {}) {
-
-    if (!array1 ||
-        !array2) {
-
-        return (options.first ? null : []);
-    }
-
-    const common = [];
-    const hash = (Array.isArray(array1) ? new Set(array1) : array1);
-    const found = new Set();
-    for (const value of array2) {
-        if (internals.has(hash, value) &&
-            !found.has(value)) {
-
-            if (options.first) {
-                return value;
-            }
-
-            common.push(value);
-            found.add(value);
-        }
-    }
-
-    return (options.first ? null : common);
-};
-
-
-internals.has = function (ref, key) {
-
-    if (typeof ref.has === 'function') {
-        return ref.has(key);
-    }
-
-    return ref[key] !== undefined;
-};
diff --git a/lib/isPromise.d.ts b/lib/isPromise.d.ts
deleted file mode 100644
index e5108fc2..00000000
--- a/lib/isPromise.d.ts
+++ /dev/null
@@ -1,3 +0,0 @@
-import { isPromise } from "./index";
-
-export = isPromise;
diff --git a/lib/isPromise.js b/lib/isPromise.js
deleted file mode 100755
index bb7768d7..00000000
--- a/lib/isPromise.js
+++ /dev/null
@@ -1,9 +0,0 @@
-'use strict';
-
-const internals = {};
-
-
-module.exports = function (promise) {
-
-    return typeof promise?.then === 'function';
-};
diff --git a/lib/merge.d.ts b/lib/merge.d.ts
deleted file mode 100644
index eef7872c..00000000
--- a/lib/merge.d.ts
+++ /dev/null
@@ -1,3 +0,0 @@
-import { merge } from "./index";
-
-export = merge;
diff --git a/lib/merge.js b/lib/merge.js
deleted file mode 100755
index 47a1e1e9..00000000
--- a/lib/merge.js
+++ /dev/null
@@ -1,78 +0,0 @@
-'use strict';
-
-const Assert = require('./assert');
-const Clone = require('./clone');
-const Utils = require('./utils');
-
-
-const internals = {};
-
-
-module.exports = internals.merge = function (target, source, options) {
-
-    Assert(target && typeof target === 'object', 'Invalid target value: must be an object');
-    Assert(source === null || source === undefined || typeof source === 'object', 'Invalid source value: must be null, undefined, or an object');
-
-    if (!source) {
-        return target;
-    }
-
-    options = Object.assign({ nullOverride: true, mergeArrays: true }, options);
-
-    if (Array.isArray(source)) {
-        Assert(Array.isArray(target), 'Cannot merge array onto an object');
-        if (!options.mergeArrays) {
-            target.length = 0;                                                          // Must not change target assignment
-        }
-
-        for (let i = 0; i < source.length; ++i) {
-            target.push(Clone(source[i], { symbols: options.symbols }));
-        }
-
-        return target;
-    }
-
-    const keys = Utils.keys(source, options);
-    for (let i = 0; i < keys.length; ++i) {
-        const key = keys[i];
-        if (key === '__proto__' ||
-            !Object.prototype.propertyIsEnumerable.call(source, key)) {
-
-            continue;
-        }
-
-        const value = source[key];
-        if (value &&
-            typeof value === 'object') {
-
-            if (target[key] === value) {
-                continue;                                           // Can occur for shallow merges
-            }
-
-            if (!target[key] ||
-                typeof target[key] !== 'object' ||
-                (Array.isArray(target[key]) !== Array.isArray(value)) ||
-                value instanceof Date ||
-                (Buffer && Buffer.isBuffer(value)) ||               // $lab:coverage:ignore$
-                value instanceof RegExp) {
-
-                target[key] = Clone(value, { symbols: options.symbols });
-            }
-            else {
-                internals.merge(target[key], value, options);
-            }
-        }
-        else {
-            if (value !== null &&
-                value !== undefined) {                              // Explicit to preserve empty strings
-
-                target[key] = value;
-            }
-            else if (options.nullOverride) {
-                target[key] = value;
-            }
-        }
-    }
-
-    return target;
-};
diff --git a/lib/once.d.ts b/lib/once.d.ts
deleted file mode 100644
index 8c5be14b..00000000
--- a/lib/once.d.ts
+++ /dev/null
@@ -1,3 +0,0 @@
-import { once } from "./index";
-
-export = once;
diff --git a/lib/once.js b/lib/once.js
deleted file mode 100755
index c825767e..00000000
--- a/lib/once.js
+++ /dev/null
@@ -1,25 +0,0 @@
-'use strict';
-
-const internals = {
-    wrapped: Symbol('wrapped')
-};
-
-
-module.exports = function (method) {
-
-    if (method[internals.wrapped]) {
-        return method;
-    }
-
-    let once = false;
-    const wrappedFn = function (...args) {
-
-        if (!once) {
-            once = true;
-            method(...args);
-        }
-    };
-
-    wrappedFn[internals.wrapped] = true;
-    return wrappedFn;
-};
diff --git a/lib/reach.d.ts b/lib/reach.d.ts
deleted file mode 100644
index e656c936..00000000
--- a/lib/reach.d.ts
+++ /dev/null
@@ -1,3 +0,0 @@
-import { reach } from "./index";
-
-export = reach;
diff --git a/lib/reach.js b/lib/reach.js
deleted file mode 100755
index 53b7c24e..00000000
--- a/lib/reach.js
+++ /dev/null
@@ -1,76 +0,0 @@
-'use strict';
-
-const Assert = require('./assert');
-
-
-const internals = {};
-
-
-module.exports = function (obj, chain, options) {
-
-    if (chain === false ||
-        chain === null ||
-        chain === undefined) {
-
-        return obj;
-    }
-
-    options = options || {};
-    if (typeof options === 'string') {
-        options = { separator: options };
-    }
-
-    const isChainArray = Array.isArray(chain);
-
-    Assert(!isChainArray || !options.separator, 'Separator option is not valid for array-based chain');
-
-    const path = isChainArray ? chain : chain.split(options.separator || '.');
-    let ref = obj;
-    for (let i = 0; i < path.length; ++i) {
-        let key = path[i];
-        const type = options.iterables && internals.iterables(ref);
-
-        if (Array.isArray(ref) ||
-            type === 'set') {
-
-            const number = Number(key);
-            if (Number.isInteger(number)) {
-                key = number < 0 ? ref.length + number : number;
-            }
-        }
-
-        if (!ref ||
-            typeof ref === 'function' && options.functions === false ||         // Defaults to true
-            !type && ref[key] === undefined) {
-
-            Assert(!options.strict || i + 1 === path.length, 'Missing segment', key, 'in reach path ', chain);
-            Assert(typeof ref === 'object' || options.functions === true || typeof ref !== 'function', 'Invalid segment', key, 'in reach path ', chain);
-            ref = options.default;
-            break;
-        }
-
-        if (!type) {
-            ref = ref[key];
-        }
-        else if (type === 'set') {
-            ref = [...ref][key];
-        }
-        else {  // type === 'map'
-            ref = ref.get(key);
-        }
-    }
-
-    return ref;
-};
-
-
-internals.iterables = function (ref) {
-
-    if (ref instanceof Set) {
-        return 'set';
-    }
-
-    if (ref instanceof Map) {
-        return 'map';
-    }
-};
diff --git a/lib/reachTemplate.d.ts b/lib/reachTemplate.d.ts
deleted file mode 100644
index 84066c3a..00000000
--- a/lib/reachTemplate.d.ts
+++ /dev/null
@@ -1,3 +0,0 @@
-import { reachTemplate } from "./index";
-
-export = reachTemplate;
diff --git a/lib/reachTemplate.js b/lib/reachTemplate.js
deleted file mode 100755
index 4ba304cc..00000000
--- a/lib/reachTemplate.js
+++ /dev/null
@@ -1,16 +0,0 @@
-'use strict';
-
-const Reach = require('./reach');
-
-
-const internals = {};
-
-
-module.exports = function (obj, template, options) {
-
-    return template.replace(/{([^{}]+)}/g, ($0, chain) => {
-
-        const value = Reach(obj, chain, options);
-        return value ?? '';
-    });
-};
diff --git a/lib/stringify.d.ts b/lib/stringify.d.ts
deleted file mode 100644
index ecfaffa3..00000000
--- a/lib/stringify.d.ts
+++ /dev/null
@@ -1,3 +0,0 @@
-import { stringify } from "./index";
-
-export = stringify;
diff --git a/lib/stringify.js b/lib/stringify.js
deleted file mode 100755
index 82152cf2..00000000
--- a/lib/stringify.js
+++ /dev/null
@@ -1,14 +0,0 @@
-'use strict';
-
-const internals = {};
-
-
-module.exports = function (...args) {
-
-    try {
-        return JSON.stringify(...args);
-    }
-    catch (err) {
-        return '[Cannot display object: ' + err.message + ']';
-    }
-};
diff --git a/lib/types.js b/lib/types.js
deleted file mode 100755
index 056049ff..00000000
--- a/lib/types.js
+++ /dev/null
@@ -1,57 +0,0 @@
-'use strict';
-
-const internals = {};
-
-
-exports = module.exports = {
-    array: Array.prototype,
-    buffer: Buffer && Buffer.prototype,             // $lab:coverage:ignore$
-    date: Date.prototype,
-    error: Error.prototype,
-    generic: Object.prototype,
-    map: Map.prototype,
-    promise: Promise.prototype,
-    regex: RegExp.prototype,
-    set: Set.prototype,
-    url: URL.prototype,
-    weakMap: WeakMap.prototype,
-    weakSet: WeakSet.prototype
-};
-
-
-internals.typeMap = new Map([
-    ['[object Error]', exports.error],
-    ['[object Map]', exports.map],
-    ['[object Promise]', exports.promise],
-    ['[object Set]', exports.set],
-    ['[object URL]', exports.url],
-    ['[object WeakMap]', exports.weakMap],
-    ['[object WeakSet]', exports.weakSet]
-]);
-
-
-exports.getInternalProto = function (obj) {
-
-    if (Array.isArray(obj)) {
-        return exports.array;
-    }
-
-    if (Buffer && obj instanceof Buffer) {          // $lab:coverage:ignore$
-        return exports.buffer;
-    }
-
-    if (obj instanceof Date) {
-        return exports.date;
-    }
-
-    if (obj instanceof RegExp) {
-        return exports.regex;
-    }
-
-    if (obj instanceof Error) {
-        return exports.error;
-    }
-
-    const objName = Object.prototype.toString.call(obj);
-    return internals.typeMap.get(objName) || exports.generic;
-};
diff --git a/lib/utils.js b/lib/utils.js
deleted file mode 100755
index bab1e8c4..00000000
--- a/lib/utils.js
+++ /dev/null
@@ -1,9 +0,0 @@
-'use strict';
-
-const internals = {};
-
-
-exports.keys = function (obj, options = {}) {
-
-    return options.symbols !== false ? Reflect.ownKeys(obj) : Object.getOwnPropertyNames(obj);  // Defaults to true
-};
diff --git a/lib/wait.d.ts b/lib/wait.d.ts
deleted file mode 100644
index be8e73fd..00000000
--- a/lib/wait.d.ts
+++ /dev/null
@@ -1,3 +0,0 @@
-import { wait } from "./index";
-
-export = wait;
diff --git a/lib/wait.js b/lib/wait.js
deleted file mode 100755
index 28d344cf..00000000
--- a/lib/wait.js
+++ /dev/null
@@ -1,37 +0,0 @@
-'use strict';
-
-const internals = {
-    maxTimer: 2 ** 31 - 1              // ~25 days
-};
-
-
-module.exports = function (timeout, returnValue, options) {
-
-    if (typeof timeout === 'bigint') {
-        timeout = Number(timeout);
-    }
-
-    if (timeout >= Number.MAX_SAFE_INTEGER) {         // Thousands of years
-        timeout = Infinity;
-    }
-
-    if (typeof timeout !== 'number' && timeout !== undefined) {
-        throw new TypeError('Timeout must be a number or bigint');
-    }
-
-    return new Promise((resolve) => {
-
-        const _setTimeout = options ? options.setTimeout : setTimeout;
-
-        const activate = () => {
-
-            const time = Math.min(timeout, internals.maxTimer);
-            timeout -= time;
-            _setTimeout(() => (timeout > 0 ? activate() : resolve(returnValue)), time);
-        };
-
-        if (timeout !== Infinity) {
-            activate();
-        }
-    });
-};
diff --git a/oxfmt.config.ts b/oxfmt.config.ts
new file mode 100644
index 00000000..5f74e6e1
--- /dev/null
+++ b/oxfmt.config.ts
@@ -0,0 +1,6 @@
+import DefaultOxfmtConfig from '@hapi/oxc-plugin/oxfmt';
+import { defineConfig } from 'oxfmt';
+
+export default defineConfig({
+    ...DefaultOxfmtConfig,
+});
diff --git a/oxlint.config.ts b/oxlint.config.ts
new file mode 100644
index 00000000..1e87556f
--- /dev/null
+++ b/oxlint.config.ts
@@ -0,0 +1,9 @@
+import HapiRecommended from '@hapi/oxc-plugin/oxlint';
+import { defineConfig } from 'oxlint';
+
+export default defineConfig({
+    extends: [HapiRecommended],
+    env: {
+        ...HapiRecommended.env,
+    },
+});
diff --git a/package.json b/package.json
index 55ae228f..cd5c03c9 100755
--- a/package.json
+++ b/package.json
@@ -1,60 +1,44 @@
 {
-  "name": "@hapi/hoek",
-  "description": "General purpose node utilities",
-  "version": "11.0.7",
-  "repository": "git://github.com/hapijs/hoek",
-  "main": "lib/index.js",
-  "types": "lib/index.d.ts",
-  "exports": {
-    ".": {
-      "import": "./lib/index.mjs",
-      "require": "./lib/index.js",
-      "types": "./lib/index.d.ts"
+    "name": "@hapi/hoek",
+    "version": "11.0.7",
+    "description": "General purpose node utilities",
+    "keywords": [
+        "utilities"
+    ],
+    "license": "BSD-3-Clause",
+    "repository": "git://github.com/hapijs/hoek",
+    "files": [
+        "dist",
+        "API.md",
+        "README.md"
+    ],
+    "type": "module",
+    "types": "./dist/index.d.mts",
+    "exports": {
+        ".": "./dist/index.mjs",
+        "./package.json": "./package.json"
     },
-    "./applyToDefaults": "./lib/applyToDefaults.js",
-    "./assert": "./lib/assert.js",
-    "./assertError": "./lib/assertError.js",
-    "./bench": "./lib/bench.js",
-    "./block": "./lib/block.js",
-    "./clone": "./lib/clone.js",
-    "./contain": "./lib/contain.js",
-    "./deepEqual": "./lib/deepEqual.js",
-    "./escapeHeaderAttribute": "./lib/escapeHeaderAttribute.js",
-    "./escapeHtml": "./lib/escapeHtml.js",
-    "./escapeJson": "./lib/escapeJson.js",
-    "./escapeRegex": "./lib/escapeRegex.js",
-    "./flatten": "./lib/flatten.js",
-    "./ignore": "./lib/ignore.js",
-    "./intersect": "./lib/intersect.js",
-    "./isPromise": "./lib/isPromise.js",
-    "./merge": "./lib/merge.js",
-    "./once": "./lib/once.js",
-    "./reach": "./lib/reach.js",
-    "./reachTemplate": "./lib/reachTemplate.js",
-    "./stringify": "./lib/stringify.js",
-    "./wait": "./lib/wait.js"
-  },
-  "keywords": [
-    "utilities"
-  ],
-  "files": [
-    "lib"
-  ],
-  "eslintConfig": {
-    "extends": [
-      "plugin:@hapi/module"
-    ]
-  },
-  "devDependencies": {
-    "@hapi/code": "^9.0.0",
-    "@hapi/eslint-plugin": "^6.0.0",
-    "@hapi/lab": "^25.0.1",
-    "@types/node": "^17.0.30",
-    "typescript": "~4.6.4"
-  },
-  "scripts": {
-    "test": "lab -a @hapi/code -t 100 -L -Y",
-    "test-cov-html": "lab -a @hapi/code -t 100 -L -r html -o coverage.html"
-  },
-  "license": "BSD-3-Clause"
+    "scripts": {
+        "prepare": "node --run build",
+        "test": "vitest run --coverage",
+        "typecheck": "tsc --noEmit",
+        "lint": "oxlint",
+        "lint:fix": "oxlint --fix",
+        "fmt": "oxfmt --check",
+        "fmt:fix": "oxfmt",
+        "build": "tsdown"
+    },
+    "devDependencies": {
+        "@hapi/oxc-plugin": "^1.0.2",
+        "@types/node": "^22.20.1",
+        "@vitest/coverage-v8": "^4.1.10",
+        "oxfmt": "^0.61.0",
+        "oxlint": "^1.76.0",
+        "tsdown": "^0.22.14",
+        "typescript": "^6.0.3",
+        "vitest": "^4.1.10"
+    },
+    "engines": {
+        "node": ">=22"
+    }
 }
diff --git a/src/applyToDefaults.ts b/src/applyToDefaults.ts
new file mode 100755
index 00000000..6d7a5b56
--- /dev/null
+++ b/src/applyToDefaults.ts
@@ -0,0 +1,117 @@
+import { assert } from './assert.js';
+import { clone } from './clone.js';
+import { merge } from './merge.js';
+import { reach } from './reach.js';
+
+import type { ShallowKeys } from './clone.js';
+
+export type ApplyToDefaultsOptions = {
+    /** When true, null value from `source` overrides existing value in `target`. */
+    nullOverride?: boolean;
+    /** Shallow clone the specified keys. */
+    shallow?: boolean | ShallowKeys;
+};
+
+export type Falsy = null | false | 0 | '' | undefined;
+
+export const applyToDefaults = function <T extends object>(
+    defaults: Partial<T>,
+    source: Partial<T> | Falsy | true,
+    options: ApplyToDefaultsOptions = {},
+) {
+    assert(defaults && typeof defaults === 'object', 'Invalid defaults value: must be an object');
+    assert(
+        !source || source === true || typeof source === 'object',
+        'Invalid source value: must be true, falsy or an object',
+    );
+    assert(typeof options === 'object', 'Invalid options: must be an object');
+
+    if (!source) {
+        // If no source, return null
+        return null;
+    }
+
+    if (options.shallow) {
+        return applyToDefaultsWithShallow(defaults, source, options);
+    }
+
+    const copy = clone(defaults);
+
+    if (source === true) {
+        // If source is set to true, use defaults
+        return copy;
+    }
+
+    const nullOverride = options.nullOverride !== undefined ? options.nullOverride : false;
+    return merge(copy, source, { nullOverride, mergeArrays: false });
+};
+
+const applyToDefaultsWithShallow = function <T extends object, U extends object>(
+    defaults: T,
+    source: U | true,
+    options: ApplyToDefaultsOptions,
+) {
+    const keys = options.shallow;
+    assert(Array.isArray(keys), 'Invalid keys');
+
+    const seen = new Map();
+    const sourcePathsToShallowCopy = source === true ? null : new Set();
+
+    for (const k of keys) {
+        const key = Array.isArray(k) ? k : (k as string).split('.'); // Pre-split optimization
+
+        const ref = reach(defaults!, key as string[]);
+        if (ref && typeof ref === 'object') {
+            seen.set(ref, (sourcePathsToShallowCopy && reach(source as U, key as string[])) || ref);
+        } else if (sourcePathsToShallowCopy) {
+            sourcePathsToShallowCopy.add(key);
+        }
+    }
+
+    const copy = clone(defaults, {}, seen);
+
+    if (!sourcePathsToShallowCopy) {
+        return copy;
+    }
+
+    for (const key of sourcePathsToShallowCopy) {
+        reachCopy(copy, source as U, key as string[]);
+    }
+
+    const nullOverride = options.nullOverride !== undefined ? options.nullOverride : false;
+
+    return merge(copy, source as object, { nullOverride, mergeArrays: false });
+};
+
+const reachCopy = function <T extends object, U extends object>(dst: T, src: U, path: string[]) {
+    for (const segment of path) {
+        if (!(segment in src)) {
+            return;
+        }
+
+        const val = src[segment as keyof U];
+
+        if (typeof val !== 'object' || val === null) {
+            return;
+        }
+
+        src = val as U;
+    }
+
+    const value = src;
+    let ref = dst;
+
+    for (let i = 0; i < path.length - 1; ++i) {
+        const segment = path[i] as keyof T;
+
+        if (typeof ref[segment] !== 'object') {
+            // @ts-expect-error - we know that ref[segment] is an object
+            ref[segment] = {};
+        }
+
+        ref = ref[segment] as T;
+    }
+
+    // @ts-expect-error - we know that ref is an object
+    ref[path[path.length - 1]] = value;
+};
diff --git a/src/assert.ts b/src/assert.ts
new file mode 100755
index 00000000..92c7545a
--- /dev/null
+++ b/src/assert.ts
@@ -0,0 +1,23 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+
+import { AssertError } from './assertError.js';
+import { stringify } from './stringify.js';
+
+// eslint-disable-next-line func-style -- https://github.com/microsoft/TypeScript/issues/34523
+export function assert<T>(condition: T, ...args: ({ toString: () => string } | Error)[]): asserts condition {
+    if (condition) {
+        return;
+    }
+
+    if (args.length === 1 && args[0] instanceof Error) {
+        throw args[0];
+    }
+
+    const msgs = args
+        .filter((arg) => arg !== '')
+        .map((arg) => {
+            return typeof arg === 'string' ? arg : arg instanceof Error ? arg.message : stringify(arg);
+        });
+
+    throw new AssertError(msgs.join(' '), assert);
+}
diff --git a/src/assertError.ts b/src/assertError.ts
new file mode 100755
index 00000000..73f2a86d
--- /dev/null
+++ b/src/assertError.ts
@@ -0,0 +1,8 @@
+export class AssertError extends Error {
+    name = 'AssertError' as const;
+
+    constructor(message?: string | undefined | null, ctor?: Function) {
+        super(message || 'Unknown error');
+        Error.captureStackTrace(this, ctor);
+    }
+}
diff --git a/src/bench.ts b/src/bench.ts
new file mode 100755
index 00000000..bda1a3c4
--- /dev/null
+++ b/src/bench.ts
@@ -0,0 +1,21 @@
+export class Bench {
+    ts: number;
+
+    constructor() {
+        this.ts = 0;
+        this.reset();
+    }
+
+    reset(): void {
+        this.ts = Bench.now();
+    }
+
+    elapsed(): number {
+        return Bench.now() - this.ts;
+    }
+
+    static now(): number {
+        const ts = process.hrtime();
+        return ts[0] * 1e3 + ts[1] / 1e6;
+    }
+}
diff --git a/src/block.ts b/src/block.ts
new file mode 100755
index 00000000..33ba2f6c
--- /dev/null
+++ b/src/block.ts
@@ -0,0 +1,3 @@
+import { ignore } from './ignore.js';
+
+export const block = (): Promise<void> => new Promise<void>(ignore);
diff --git a/src/clone.ts b/src/clone.ts
new file mode 100755
index 00000000..fefec0d9
--- /dev/null
+++ b/src/clone.ts
@@ -0,0 +1,204 @@
+import { reach } from './reach.js';
+import { prototypes, getInternalProto } from './types.js';
+import * as Utils from './utils.js';
+
+const needsProtoHack = new Set([prototypes.set, prototypes.map, prototypes.weakSet, prototypes.weakMap]);
+
+type ObjKey = string | symbol | number;
+export type ShallowKeys = ObjKey[] | ObjKey[][];
+
+export interface CloneOptions {
+    /**
+     * Clone the object's prototype.
+     *
+     * @default true
+     */
+    prototype?: boolean | undefined;
+
+    /**
+     * Include symbol properties.
+     *
+     * @default true
+     */
+    symbols?: boolean | undefined;
+
+    /**
+     * Shallow clone the specified keys.
+     *
+     * @default undefined
+     */
+    shallow?: ShallowKeys | boolean | undefined;
+}
+
+export const clone = function <T>(obj: T, options: CloneOptions = {}, _seen: Map<unknown, unknown> | null = null): T {
+    if (typeof obj !== 'object' || obj === null) {
+        return obj;
+    }
+
+    let cloneFn = clone;
+    let seen = _seen;
+
+    if (options.shallow) {
+        if (options.shallow !== true) {
+            return cloneWithShallow(obj, options);
+        }
+
+        cloneFn = (value) => value;
+    } else if (seen) {
+        const lookup = seen.get(obj);
+
+        if (lookup) {
+            return lookup as T;
+        }
+    } else {
+        seen = new Map();
+    }
+
+    // Built-in object types
+
+    if (Buffer && Buffer.isBuffer(obj)) {
+        return Buffer.from(obj) as T;
+    }
+
+    if (obj instanceof Date) {
+        return new Date(obj.getTime()) as T;
+    }
+
+    if (obj instanceof RegExp) {
+        return new RegExp(obj) as T;
+    }
+
+    if (obj instanceof URL) {
+        return new URL(obj) as T;
+    }
+
+    const baseProto = getInternalProto(obj);
+
+    // Generic objects
+
+    const newObj = base(obj, baseProto, options);
+    if (newObj === obj) {
+        return obj;
+    }
+
+    if (seen) {
+        seen.set(obj, newObj); // Set seen, since obj could recurse
+    }
+
+    if ((baseProto as never) === prototypes.set) {
+        for (const value of obj as never[]) {
+            (newObj as unknown as Set<any>).add(cloneFn(value, options, seen));
+        }
+    } else if ((baseProto as never) === prototypes.map) {
+        for (const [key, value] of obj as unknown as Map<unknown, unknown>) {
+            (newObj as unknown as Map<any, any>).set(key, cloneFn(value, options, seen));
+        }
+    }
+
+    const keys = Utils.keys(obj, options);
+    for (const key of keys) {
+        if (key === '__proto__') {
+            continue;
+        }
+
+        if (baseProto === prototypes.array && key === 'length') {
+            (newObj as []).length = (obj as []).length;
+            continue;
+        }
+
+        if ((baseProto as unknown as Error) === prototypes.error && key === 'stack') {
+            continue; // Already a part of the base object
+        }
+
+        const descriptor = Object.getOwnPropertyDescriptor(obj, key);
+        if (descriptor) {
+            if (descriptor.get || descriptor.set) {
+                Object.defineProperty(newObj, key, descriptor);
+            } else if (descriptor.enumerable) {
+                newObj[key] = cloneFn(obj[key], options, seen);
+            } else {
+                Object.defineProperty(newObj, key, {
+                    enumerable: false,
+                    writable: true,
+                    configurable: true,
+                    value: cloneFn(obj[key], options, seen),
+                });
+            }
+        } else {
+            Object.defineProperty(newObj, key, {
+                enumerable: true,
+                writable: true,
+                configurable: true,
+                value: cloneFn(obj[key], options, seen),
+            });
+        }
+    }
+
+    return newObj;
+};
+
+const cloneWithShallow = function <T extends object>(source: T, options: CloneOptions) {
+    const keys = options.shallow as string[] | string[][];
+    options = Object.assign({}, options) as CloneOptions;
+    options.shallow = false;
+
+    const seen = new Map();
+
+    for (const key of keys) {
+        const ref = reach(source, key);
+        if (typeof ref === 'object' || typeof ref === 'function') {
+            seen.set(ref, ref);
+        }
+    }
+
+    return clone(source, options, seen);
+};
+
+const base = function <T>(obj: T, baseProto: any, options: CloneOptions): T {
+    if (options.prototype === false) {
+        // Defaults to true
+        if (needsProtoHack.has(baseProto)) {
+            return new baseProto.constructor();
+        }
+
+        return baseProto === prototypes.array ? ([] as T) : ({} as T);
+    }
+
+    const proto = Object.getPrototypeOf(obj);
+    if (proto && proto.isImmutable) {
+        return obj;
+    }
+
+    if (baseProto === prototypes.array) {
+        const newObj = [] as unknown as T;
+
+        if (proto !== baseProto) {
+            Object.setPrototypeOf(newObj, proto);
+        }
+
+        return newObj;
+    } else if (
+        baseProto === prototypes.error &&
+        (proto === baseProto || Error.isPrototypeOf(proto.constructor)) // Don't match Util.inherit() subclassed errors
+    ) {
+        const err = structuredClone(obj); // Needed to copy internal stack state
+
+        if (Object.getPrototypeOf(err) !== proto) {
+            Object.setPrototypeOf(err, proto); // Fix prototype
+        }
+
+        return err;
+    }
+
+    if (needsProtoHack.has(baseProto)) {
+        const newObj = new proto.constructor();
+
+        if (proto !== baseProto) {
+            Object.setPrototypeOf(newObj, proto);
+        }
+
+        return newObj;
+    }
+
+    return Object.create(proto);
+};
diff --git a/lib/contain.js b/src/contain.ts
similarity index 51%
rename from lib/contain.js
rename to src/contain.ts
index f4d4eee8..8533e161 100755
--- a/lib/contain.js
+++ b/src/contain.ts
@@ -1,15 +1,59 @@
-'use strict';
-
-const Assert = require('./assert');
-const DeepEqual = require('./deepEqual');
-const EscapeRegex = require('./escapeRegex');
-const Utils = require('./utils');
-
-
-const internals = {};
-
-
-module.exports = function (ref, values, options = {}) {        // options: { deep, once, only, part, symbols }
+/* eslint-disable func-style */
+import { assert as Assert } from './assert.js';
+import { deepEqual as DeepEqual } from './deepEqual.js';
+import { escapeRegex } from './escapeRegex.js';
+import * as Utils from './utils.js';
+
+// Partial one or many
+type PartOOM<T> = Partial<T> | Partial<T>[];
+type ContainValues<T = unknown> = PartOOM<string> | PartOOM<T> | PartOOM<keyof T>;
+
+export interface ContainOptions {
+    /**
+     * Perform a deep comparison.
+     *
+     * @default false
+     */
+    readonly deep?: boolean | undefined;
+
+    /**
+     * Allow only one occurrence of each value.
+     *
+     * @default false
+     */
+    readonly once?: boolean | undefined;
+
+    /**
+     * Allow only values explicitly listed.
+     *
+     * @default false
+     */
+    readonly only?: boolean | undefined;
+
+    /**
+     * Allow partial match.
+     *
+     * @default false
+     */
+    readonly part?: boolean | undefined;
+
+    /**
+     * Include symbol properties.
+     *
+     * @default true
+     */
+    readonly symbols?: boolean | undefined;
+}
+
+export function contain(ref: string, values: PartOOM<string>, options?: ContainOptions | undefined): boolean;
+export function contain<T>(ref: T[], values: PartOOM<T>, options?: ContainOptions | undefined): boolean;
+export function contain<T>(
+    ref: T,
+    values: PartOOM<keyof T> | PartOOM<T>,
+    options?: ContainOptions | undefined,
+): boolean;
+export function contain(ref: unknown, values: unknown, options: ContainOptions = {}): boolean {
+    // options: { deep, once, only, part, symbols }
 
     /*
         string -> string(s)
@@ -27,63 +71,54 @@ module.exports = function (ref, values, options = {}) {        // options: { dee
     // String
 
     if (typeof ref === 'string') {
-        return internals.string(ref, values, options);
+        return compareString(ref, values as string[], options);
     }
 
     // Array
 
     if (Array.isArray(ref)) {
-        return internals.array(ref, values, options);
+        return containArray(ref, values as [], options);
     }
 
     // Object
 
     Assert(typeof ref === 'object', 'Reference must be string or an object');
-    return internals.object(ref, values, options);
-};
-
 
-internals.array = function (ref, values, options) {
+    return containObject(ref!, values as object, options);
+}
 
+const containArray = function <T>(ref: T[], values: ContainValues<T>, options: ContainOptions) {
     if (!Array.isArray(values)) {
-        values = [values];
+        values = [values] as T[];
     }
 
     if (!ref.length) {
         return false;
     }
 
-    if (options.only &&
-        options.once &&
-        ref.length !== values.length) {
-
+    if (options.only && options.once && ref.length !== values.length) {
         return false;
     }
 
-    let compare;
+    let compareFn;
 
     // Map values
 
-    const map = new Map();
+    const map = new Map<unknown, { allowed: number; hits: number }>();
     for (const value of values) {
-        if (!options.deep ||
-            !value ||
-            typeof value !== 'object') {
-
+        if (!options.deep || !value || typeof value !== 'object') {
             const existing = map.get(value);
             if (existing) {
                 ++existing.allowed;
-            }
-            else {
+            } else {
                 map.set(value, { allowed: 1, hits: 0 });
             }
-        }
-        else {
-            compare = compare ?? internals.compare(options);
+        } else {
+            compareFn = compareFn ?? compare(options);
 
             let found = false;
             for (const [key, existing] of map.entries()) {
-                if (compare(key, value)) {
+                if (compareFn(key, value)) {
                     ++existing.allowed;
                     found = true;
                     break;
@@ -101,17 +136,13 @@ internals.array = function (ref, values, options) {
     let hits = 0;
     for (const item of ref) {
         let match;
-        if (!options.deep ||
-            !item ||
-            typeof item !== 'object') {
-
+        if (!options.deep || !item || typeof item !== 'object') {
             match = map.get(item);
-        }
-        else {
-            compare = compare ?? internals.compare(options);
+        } else {
+            compareFn = compareFn ?? compare(options);
 
             for (const [key, existing] of map.entries()) {
-                if (compare(key, item)) {
+                if (compareFn(key, item)) {
                     match = existing;
                     break;
                 }
@@ -122,9 +153,7 @@ internals.array = function (ref, values, options) {
             ++match.hits;
             ++hits;
 
-            if (options.once &&
-                match.hits > match.allowed) {
-
+            if (options.once && match.hits > match.allowed) {
                 return false;
             }
         }
@@ -132,9 +161,7 @@ internals.array = function (ref, values, options) {
 
     // Validate results
 
-    if (options.only &&
-        hits !== ref.length) {
-
+    if (options.only && hits !== ref.length) {
         return false;
     }
 
@@ -143,9 +170,7 @@ internals.array = function (ref, values, options) {
             continue;
         }
 
-        if (match.hits < match.allowed &&
-            !options.part) {
-
+        if (match.hits < match.allowed && !options.part) {
             return false;
         }
     }
@@ -153,9 +178,7 @@ internals.array = function (ref, values, options) {
     return !!hits;
 };
 
-
-internals.object = function (ref, values, options) {
-
+const containObject = function <T extends object>(ref: T, values: ContainValues, options: ContainOptions) {
     Assert(options.once === undefined, 'Cannot use option once with object');
 
     const keys = Utils.keys(ref, options);
@@ -164,9 +187,8 @@ internals.object = function (ref, values, options) {
     }
 
     // Keys list
-
     if (Array.isArray(values)) {
-        return internals.array(keys, values, options);
+        return containArray(keys, values, options);
     }
 
     // Key value pairs
@@ -174,11 +196,11 @@ internals.object = function (ref, values, options) {
     const symbols = Object.getOwnPropertySymbols(values).filter((sym) => values.propertyIsEnumerable(sym));
     const targets = [...Object.keys(values), ...symbols];
 
-    const compare = internals.compare(options);
+    const compareFn = compare(options);
     const set = new Set(targets);
 
     for (const key of keys) {
-        if (!set.has(key)) {
+        if (!set.has(key as string)) {
             if (options.only) {
                 return false;
             }
@@ -186,11 +208,11 @@ internals.object = function (ref, values, options) {
             continue;
         }
 
-        if (!compare(values[key], ref[key])) {
+        if (!compareFn(values[key as never], ref[key])) {
             return false;
         }
 
-        set.delete(key);
+        set.delete(key as string);
     }
 
     if (set.size) {
@@ -200,20 +222,20 @@ internals.object = function (ref, values, options) {
     return true;
 };
 
-
-internals.string = function (ref, values, options) {
-
+const compareString = function (ref: string, values: string[], options: ContainOptions) {
     // Empty string
 
     if (ref === '') {
-        return values.length === 1 && values[0] === '' ||               // '' contains ''
-            !options.once && !values.some((v) => v !== '');             // '' contains multiple '' if !once
+        return (
+            (values.length === 1 && values[0] === '') || // '' contains ''
+            (!options.once && !values.some((v) => v !== '')) // '' contains multiple '' if !once
+        );
     }
 
     // Map values
 
     const map = new Map();
-    const patterns = [];
+    const patterns = [] as string[];
 
     for (const value of values) {
         Assert(typeof value === 'string', 'Cannot compare string reference to non-string value');
@@ -222,37 +244,31 @@ internals.string = function (ref, values, options) {
             const existing = map.get(value);
             if (existing) {
                 ++existing.allowed;
-            }
-            else {
+            } else {
                 map.set(value, { allowed: 1, hits: 0 });
-                patterns.push(EscapeRegex(value));
+                patterns.push(escapeRegex(value));
             }
-        }
-        else if (options.once ||
-            options.only) {
-
+        } else if (options.once || options.only) {
             return false;
         }
     }
 
-    if (!patterns.length) {                     // Non-empty string contains unlimited empty string
+    if (!patterns.length) {
+        // Non-empty string contains unlimited empty string
         return true;
     }
 
     // Match patterns
 
     const regex = new RegExp(`(${patterns.join('|')})`, 'g');
-    const leftovers = ref.replace(regex, ($0, $1) => {
-
+    const leftovers = ref.replace(regex, (_, $1) => {
         ++map.get($1).hits;
-        return '';                              // Remove from string
+        return ''; // Remove from string
     });
 
     // Validate results
 
-    if (options.only &&
-        leftovers) {
-
+    if (options.only && leftovers) {
         return false;
     }
 
@@ -266,9 +282,7 @@ internals.string = function (ref, values, options) {
             continue;
         }
 
-        if (match.hits < match.allowed &&
-            !options.part) {
-
+        if (match.hits < match.allowed && !options.part) {
             return false;
         }
 
@@ -282,11 +296,9 @@ internals.string = function (ref, values, options) {
     return !!any;
 };
 
-
-internals.compare = function (options) {
-
+const compare = function (options: ContainOptions) {
     if (!options.deep) {
-        return internals.shallow;
+        return shallow;
     }
 
     const hasOnly = options.only !== undefined;
@@ -294,14 +306,12 @@ internals.compare = function (options) {
 
     const flags = {
         prototype: hasOnly ? options.only : hasPart ? !options.part : false,
-        part: hasOnly ? !options.only : hasPart ? options.part : false
+        part: hasOnly ? !options.only : hasPart ? options.part : false,
     };
 
-    return (a, b) => DeepEqual(a, b, flags);
+    return <A, B>(a: A, b: B) => DeepEqual(a, b, flags);
 };
 
-
-internals.shallow = function (a, b) {
-
+const shallow = function (a: unknown, b: unknown) {
     return a === b;
 };
diff --git a/src/deepEqual.ts b/src/deepEqual.ts
new file mode 100755
index 00000000..0de0e41b
--- /dev/null
+++ b/src/deepEqual.ts
@@ -0,0 +1,331 @@
+import { prototypes, getInternalProto } from './types.js';
+
+import type { AnyPrototype } from './types.js';
+
+export interface DeepEqualOptions {
+    /**
+     * Compare functions with difference references by comparing their internal code and properties.
+     *
+     * @default false
+     */
+    readonly deepFunction?: boolean;
+
+    /**
+     * Allow partial match.
+     *
+     * @default false
+     */
+    readonly part?: boolean;
+
+    /**
+     * Compare the objects' prototypes.
+     *
+     * @default true
+     */
+    readonly prototype?: boolean;
+
+    /**
+     * List of object keys to ignore different values of.
+     *
+     * @default null
+     */
+    readonly skip?: (string | symbol)[];
+
+    /**
+     * Compare symbol properties.
+     *
+     * @default true
+     */
+    readonly symbols?: boolean;
+}
+
+const MISMATCHED = null;
+
+export const deepEqual = (obj: unknown, ref: unknown, options?: DeepEqualOptions): boolean => {
+    options = Object.assign({ prototype: true }, options);
+
+    return !!isDeepEqual(obj, ref, options, []);
+};
+
+const isDeepEqual = (obj: unknown, ref: unknown, options: DeepEqualOptions, seen: SeenEntry[]) => {
+    if (obj === ref) {
+        // Copied from Deep-eql, copyright(c) 2013 Jake Luer, jake@alogicalparadox.com, MIT Licensed, https://github.com/chaijs/deep-eql
+        return obj !== 0 || 1 / obj === 1 / (ref as never);
+    }
+
+    const type = typeof obj;
+
+    if (type !== typeof ref) {
+        return false;
+    }
+
+    if (obj === null || ref === null) {
+        return false;
+    }
+
+    if (type === 'function') {
+        if (!options.deepFunction || obj!.toString() !== ref!.toString()) {
+            return false;
+        }
+
+        // Continue as object
+    } else if (type !== 'object') {
+        return obj !== obj && ref !== ref; // NaN
+    }
+
+    const instanceType = getSharedType(obj as object, ref, !!options.prototype);
+
+    switch (instanceType) {
+        case prototypes.buffer:
+            return Buffer && Buffer.prototype.equals.call(obj, ref);
+        case prototypes.promise:
+            return obj === ref;
+        case prototypes.regex:
+        case prototypes.url:
+            return obj!.toString() === ref!.toString();
+        case MISMATCHED:
+            return false;
+    }
+
+    for (let i = seen.length - 1; i >= 0; --i) {
+        if (seen[i]!.isSame(obj, ref)) {
+            return true; // If previous comparison failed, it would have stopped execution
+        }
+    }
+
+    seen.push(new SeenEntry(obj, ref));
+
+    try {
+        return isDeepEqualObj(instanceType, obj as never, ref as never, options, seen);
+    } finally {
+        seen.pop();
+    }
+};
+
+const getSharedType = function (obj: object, ref: unknown, checkPrototype: boolean) {
+    if (checkPrototype) {
+        if (Object.getPrototypeOf(obj) !== Object.getPrototypeOf(ref)) {
+            return MISMATCHED;
+        }
+
+        return getInternalProto(obj);
+    }
+
+    const type = getInternalProto(obj);
+    if (type !== getInternalProto(ref as never)) {
+        return MISMATCHED;
+    }
+
+    return type;
+};
+
+const valueOf = function (obj: any) {
+    const objValueOf = obj.valueOf;
+    if (objValueOf === undefined) {
+        return obj;
+    }
+
+    try {
+        return objValueOf.call(obj);
+    } catch (err) {
+        return err;
+    }
+};
+
+const hasOwnEnumerableProperty = function (obj: object, key: string | symbol | number) {
+    return Object.prototype.propertyIsEnumerable.call(obj, key);
+};
+
+const isSetSimpleEqual = function (obj: unknown, ref: unknown) {
+    for (const entry of Set.prototype.values.call(obj)) {
+        if (!Set.prototype.has.call(ref, entry)) {
+            return false;
+        }
+    }
+
+    return true;
+};
+
+const isDeepEqualObj = function (
+    instanceType: (typeof prototypes)[keyof typeof prototypes],
+    obj: AnyPrototype,
+    ref: AnyPrototype,
+    options: DeepEqualOptions,
+    seen: SeenEntry[],
+) {
+    const { keys, getOwnPropertySymbols } = Object;
+
+    if (instanceType === prototypes.array) {
+        const objArr = obj as [];
+        const refArr = ref as [];
+
+        if (options.part) {
+            // Check if any index match any other index
+            for (const objValue of objArr) {
+                for (const refValue of refArr) {
+                    if (isDeepEqual(objValue, refValue, options, seen)) {
+                        return true;
+                    }
+                }
+            }
+        } else {
+            if (objArr.length !== refArr.length) {
+                return false;
+            }
+
+            for (let i = 0; i < objArr.length; ++i) {
+                if (!isDeepEqual(objArr[i], refArr[i], options, seen)) {
+                    return false;
+                }
+            }
+
+            return true;
+        }
+    } else if (instanceType === prototypes.set) {
+        const objSet = obj as Set<any>;
+        const refSet = ref as Set<any>;
+
+        if (objSet.size !== refSet.size) {
+            return false;
+        }
+
+        if (!isSetSimpleEqual(objSet, refSet)) {
+            // Check for deep equality
+
+            const ref2 = new Set(Set.prototype.values.call(refSet));
+            for (const objEntry of Set.prototype.values.call(objSet)) {
+                if (ref2.delete(objEntry)) {
+                    continue;
+                }
+
+                let found = false;
+                for (const refEntry of ref2) {
+                    if (isDeepEqual(objEntry, refEntry, options, seen)) {
+                        ref2.delete(refEntry);
+                        found = true;
+                        break;
+                    }
+                }
+
+                if (!found) {
+                    return false;
+                }
+            }
+        }
+    } else if (instanceType === prototypes.map) {
+        const objMap = obj as Map<any, any>;
+        const refMap = ref as Map<any, any>;
+
+        if (objMap.size !== refMap.size) {
+            return false;
+        }
+
+        for (const [key, value] of Map.prototype.entries.call(objMap)) {
+            if (value === undefined && !Map.prototype.has.call(refMap, key)) {
+                return false;
+            }
+
+            if (!isDeepEqual(value, Map.prototype.get.call(refMap, key), options, seen)) {
+                return false;
+            }
+        }
+    } else if (instanceType === prototypes.error) {
+        const objError = obj as Error;
+        const refError = ref as Error;
+
+        // Always check name and message
+
+        if (objError.name !== refError.name || objError.message !== refError.message) {
+            return false;
+        }
+    }
+
+    // Check .valueOf()
+
+    const valueOfObj = valueOf(obj);
+    const valueOfRef = valueOf(ref);
+    if ((obj !== valueOfObj || ref !== valueOfRef) && !isDeepEqual(valueOfObj, valueOfRef, options, seen)) {
+        return false;
+    }
+
+    const objAsObject = obj as object;
+    const refAsObject = ref as object;
+
+    // Check properties
+
+    const objKeys = keys(objAsObject);
+    if (!options.part && objKeys.length !== keys(refAsObject).length && !options.skip) {
+        return false;
+    }
+
+    let skipped = 0;
+    for (const key of objKeys) {
+        if (options.skip && options.skip.includes(key)) {
+            if (refAsObject[key as never] === undefined) {
+                ++skipped;
+            }
+
+            continue;
+        }
+
+        if (!hasOwnEnumerableProperty(refAsObject, key)) {
+            return false;
+        }
+
+        if (!isDeepEqual(objAsObject[key as never], refAsObject[key as never], options, seen)) {
+            return false;
+        }
+    }
+
+    if (!options.part && objKeys.length - skipped !== keys(refAsObject).length) {
+        return false;
+    }
+
+    // Check symbols
+
+    if (options.symbols !== false) {
+        // Defaults to true
+        const objSymbols = getOwnPropertySymbols(obj);
+        const refSymbols = new Set(getOwnPropertySymbols(ref));
+
+        for (const key of objSymbols) {
+            if (!options.skip?.includes(key)) {
+                if (hasOwnEnumerableProperty(obj, key)) {
+                    if (!hasOwnEnumerableProperty(ref, key)) {
+                        return false;
+                    }
+
+                    if (!isDeepEqual(obj[key as never], ref[key as never], options, seen)) {
+                        return false;
+                    }
+                } else if (hasOwnEnumerableProperty(ref, key)) {
+                    return false;
+                }
+            }
+
+            refSymbols.delete(key);
+        }
+
+        for (const key of refSymbols) {
+            if (hasOwnEnumerableProperty(ref, key)) {
+                return false;
+            }
+        }
+    }
+
+    return true;
+};
+
+class SeenEntry {
+    obj: unknown;
+    ref: unknown;
+
+    constructor(obj: unknown, ref: unknown) {
+        this.obj = obj;
+        this.ref = ref;
+    }
+
+    isSame(obj: unknown, ref: unknown) {
+        return this.obj === obj && this.ref === ref;
+    }
+}
diff --git a/src/escapeHeaderAttribute.ts b/src/escapeHeaderAttribute.ts
new file mode 100755
index 00000000..fabc9519
--- /dev/null
+++ b/src/escapeHeaderAttribute.ts
@@ -0,0 +1,15 @@
+import { assert } from './assert.js';
+
+/**
+ * Escape string for usage as an attribute value in HTTP headers.
+ *
+ * @param attribute - The string to be escaped.
+ * @returns The escaped string. Will throw on invalid characters that are not supported to be escaped.
+ */
+export const escapeHeaderAttribute = function (attribute: string): string {
+    // Allowed value characters: !#$%&'()*+,-./:;<=>?@[]^_`{|}~ and space, a-z, A-Z, 0-9, \, "
+
+    assert(/^[ \w!#$%&'()*+,\-./:;<=>?@[\]^`{|}~"\\]*$/.test(attribute), 'Bad attribute value (' + attribute + ')');
+
+    return attribute.replace(/\\/g, '\\\\').replace(/"/g, '\\"'); // Escape quotes and slash
+};
diff --git a/src/escapeHtml.ts b/src/escapeHtml.ts
new file mode 100755
index 00000000..ddbd901c
--- /dev/null
+++ b/src/escapeHtml.ts
@@ -0,0 +1,74 @@
+export const escapeHtml = function (input?: string | null): string {
+    if (!input) {
+        return '';
+    }
+
+    let escaped = '';
+
+    for (let i = 0; i < input.length; ++i) {
+        const charCode = input.charCodeAt(i);
+
+        if (isSafe(charCode)) {
+            escaped += input[i];
+        } else {
+            escaped += escapeHtmlChar(charCode);
+        }
+    }
+
+    return escaped;
+};
+
+const escapeHtmlChar = function (charCode: number) {
+    const namedEscape = namedHtml.get(charCode);
+    if (namedEscape) {
+        return namedEscape;
+    }
+
+    if (charCode >= 256) {
+        return '&#' + charCode + ';';
+    }
+
+    const hexValue = charCode.toString(16).padStart(2, '0');
+    return `&#x${hexValue};`;
+};
+
+const isSafe = function (charCode: number): boolean {
+    return safeCharCodes.has(charCode);
+};
+
+const namedHtml = new Map([
+    [38, '&amp;'],
+    [60, '&lt;'],
+    [62, '&gt;'],
+    [34, '&quot;'],
+    [160, '&nbsp;'],
+    [162, '&cent;'],
+    [163, '&pound;'],
+    [164, '&curren;'],
+    [169, '&copy;'],
+    [174, '&reg;'],
+]);
+
+const safeCharCodes = (function () {
+    const safe = new Set<number>();
+
+    for (let i = 32; i < 123; ++i) {
+        if (
+            i >= 97 || // a-z
+            (i >= 65 && i <= 90) || // A-Z
+            (i >= 48 && i <= 57) || // 0-9
+            i === 32 || // space
+            i === 46 || // .
+            i === 44 || // ,
+            i === 45 || // -
+            i === 58 || // :
+            i === 95
+        ) {
+            // _
+
+            safe.add(i);
+        }
+    }
+
+    return safe;
+})();
diff --git a/src/escapeJson.ts b/src/escapeJson.ts
new file mode 100755
index 00000000..befab726
--- /dev/null
+++ b/src/escapeJson.ts
@@ -0,0 +1,19 @@
+export const escapeJson = (input?: string | null): string => {
+    if (!input) {
+        return '';
+    }
+
+    return input.replace(/[<>&\u2028\u2029]/g, escape);
+};
+
+const escape = function (char: string): string {
+    return replacements.get(char)!;
+};
+
+const replacements = new Map([
+    ['<', '\\u003c'],
+    ['>', '\\u003e'],
+    ['&', '\\u0026'],
+    ['\u2028', '\\u2028'],
+    ['\u2029', '\\u2029'],
+]);
diff --git a/src/escapeRegex.ts b/src/escapeRegex.ts
new file mode 100755
index 00000000..96bf1505
--- /dev/null
+++ b/src/escapeRegex.ts
@@ -0,0 +1,5 @@
+export const escapeRegex = (string: string): string => {
+    // Escape ^$.*+-?=!:|\/()[]{},
+
+    return string.replace(/[\^$.*+\-?=!:|\\/()[\]{},]/g, '\\$&');
+};
diff --git a/src/flatten.ts b/src/flatten.ts
new file mode 100755
index 00000000..3379fdbe
--- /dev/null
+++ b/src/flatten.ts
@@ -0,0 +1,23 @@
+type Flattened<T> = T extends readonly (infer U)[] ? Flattened<U> : T;
+
+/**
+ * Flatten an array with any level of nested arrays.
+ *
+ * @param array - The array of items or other arrays to flatten.
+ * @param target - If provided, an array to shallow copy the flattened `array` items to.
+ * @returns A flat array of the provided values, appended to `target` if provided. Note that `target` items are copied
+ *   as-is and are never flattened.
+ */
+export const flatten = <T, U = never>(array: Array<T>, target?: Array<U>): (Flattened<T> | U)[] => {
+    const result = (target || []) as unknown[];
+
+    for (const entry of array) {
+        if (Array.isArray(entry)) {
+            flatten(entry, result);
+        } else {
+            result.push(entry);
+        }
+    }
+
+    return result as (Flattened<T> | U)[];
+};
diff --git a/src/ignore.ts b/src/ignore.ts
new file mode 100755
index 00000000..67015be6
--- /dev/null
+++ b/src/ignore.ts
@@ -0,0 +1,2 @@
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+export const ignore = (..._: unknown[]): void => {};
diff --git a/src/index.ts b/src/index.ts
new file mode 100755
index 00000000..b90ddec7
--- /dev/null
+++ b/src/index.ts
@@ -0,0 +1,31 @@
+export { applyToDefaults } from './applyToDefaults.js';
+export { assert } from './assert.js';
+export { AssertError } from './assertError.js';
+export { Bench } from './bench.js';
+export { block } from './block.js';
+export { clone } from './clone.js';
+export { contain } from './contain.js';
+export { deepEqual } from './deepEqual.js';
+export { escapeHeaderAttribute } from './escapeHeaderAttribute.js';
+export { escapeHtml } from './escapeHtml.js';
+export { escapeJson } from './escapeJson.js';
+export { escapeRegex } from './escapeRegex.js';
+export { flatten } from './flatten.js';
+export { ignore } from './ignore.js';
+export { intersect } from './intersect.js';
+export { isPromise } from './isPromise.js';
+export { merge } from './merge.js';
+export { once } from './once.js';
+export { reach } from './reach.js';
+export { reachTemplate } from './reachTemplate.js';
+export { stringify } from './stringify.js';
+export { wait } from './wait.js';
+
+export type { ApplyToDefaultsOptions } from './applyToDefaults.js';
+export type { CloneOptions } from './clone.js';
+export type { ContainOptions } from './contain.js';
+export type { DeepEqualOptions } from './deepEqual.js';
+export type { IntersectArray, IntersectOptions } from './intersect.js';
+export type { MergeOptions } from './merge.js';
+export type { ReachOptions } from './reach.js';
+export type { WaitOptions } from './wait.js';
diff --git a/src/intersect.ts b/src/intersect.ts
new file mode 100755
index 00000000..82094276
--- /dev/null
+++ b/src/intersect.ts
@@ -0,0 +1,58 @@
+export type IntersectArray<T> = Array<T> | Set<T> | Record<number, T> | null;
+
+type ExtractIntersectType<T> = T extends IntersectArray<infer U> ? U : never;
+
+export interface IntersectOptions {
+    /**
+     * When true, return the first overlapping value.
+     *
+     * @default false
+     */
+    readonly first?: boolean;
+}
+
+export function intersect<T1, T2>(
+    array1: IntersectArray<T1>,
+    array2: IntersectArray<T2>,
+    options: { first: true },
+): T1 | T2 | null;
+
+export function intersect<T1 extends IntersectArray<any>, T2 extends IntersectArray<any>>(
+    array1: T1,
+    array2: T2,
+    options?: IntersectOptions,
+): Array<ExtractIntersectType<T1> | ExtractIntersectType<T2>> | null;
+
+export function intersect(array1: any, array2: any, options: IntersectOptions = {}) {
+    if (!array1 || !array2) {
+        return options.first ? null : [];
+    }
+
+    const common = [];
+    const hash = Array.isArray(array1) ? new Set(array1) : array1;
+    const found = new Set();
+
+    for (const value of array2 as Iterable<any>) {
+        if (has(hash, value as never) && !found.has(value)) {
+            if (options.first) {
+                return value;
+            }
+
+            common.push(value);
+            found.add(value);
+        }
+    }
+
+    return options.first ? null : common;
+}
+
+const has = function (ref: NonNullable<IntersectArray<any>>, key: string) {
+    const asSet = ref as Set<any>;
+    const asArray = ref as Array<any>;
+
+    if (typeof asSet.has === 'function') {
+        return asSet.has(key);
+    }
+
+    return asArray[key as any] !== undefined;
+};
diff --git a/src/isPromise.ts b/src/isPromise.ts
new file mode 100755
index 00000000..cd88a837
--- /dev/null
+++ b/src/isPromise.ts
@@ -0,0 +1,9 @@
+/**
+ * Determines if an object is a promise.
+ *
+ * @param promise - The object tested.
+ * @returns True if the object is a promise, otherwise false.
+ */
+export const isPromise = function (promise: unknown): promise is Promise<unknown> {
+    return typeof (promise as Promise<any>)?.then === 'function';
+};
diff --git a/src/merge.ts b/src/merge.ts
new file mode 100755
index 00000000..d46ccbc3
--- /dev/null
+++ b/src/merge.ts
@@ -0,0 +1,118 @@
+import { assert } from './assert.js';
+import { clone } from './clone.js';
+import * as Utils from './utils.js';
+
+export type MergeTypes<T1, T2> = {
+    [K in keyof T1]: K extends keyof T2 ? T2[K] | T1[K] : T1[K];
+} & {
+    [K in keyof T2]: K extends keyof T1 ? T2[K] | T1[K] : T2[K];
+};
+
+export interface MergeOptions {
+    /**
+     * Clone the object's prototype.
+     *
+     * @default true
+     */
+    prototype?: boolean | undefined;
+
+    /**
+     * Include symbol properties.
+     *
+     * @default true
+     */
+    symbols?: boolean | undefined;
+
+    /**
+     * Shallow clone the specified keys.
+     *
+     * @default undefined
+     */
+    shallow?: string[] | string[][] | boolean | undefined;
+
+    /** When true, arrays are merged together. */
+    mergeArrays?: boolean | undefined;
+
+    /** When true, null value from source overrides target. */
+    nullOverride?: boolean | undefined;
+}
+
+export function merge<T1 extends object>(target: T1, source: null | undefined, options?: MergeOptions): T1;
+export function merge<T1 extends object, T2 extends object>(
+    target: T1,
+    source: T2,
+    options?: MergeOptions,
+): MergeTypes<T1, T2>;
+export function merge<T1 extends object, T2 extends object>(target: T1, source: T2, options: MergeOptions = {}) {
+    assert(target && typeof target === 'object', 'Invalid target value: must be an object');
+    assert(
+        source === null || source === undefined || typeof source === 'object',
+        'Invalid source value: must be null, undefined, or an object',
+    );
+
+    if (!source) {
+        return target as T1;
+    }
+
+    options = Object.assign({ nullOverride: true, mergeArrays: true }, options);
+
+    if (Array.isArray(source)) {
+        assert(Array.isArray(target), 'Cannot merge array onto an object');
+
+        if (!options.mergeArrays) {
+            // Must not change target assignment
+            target.length = 0;
+        }
+
+        for (let i = 0; i < source.length; ++i) {
+            target.push(clone(source[i], { symbols: options.symbols }));
+        }
+
+        return target as MergeTypes<T1, T2>;
+    }
+
+    const keys = Utils.keys(source, options);
+
+    for (let i = 0; i < keys.length; ++i) {
+        const key = keys[i]!;
+
+        if (key === '__proto__' || !Object.prototype.propertyIsEnumerable.call(source, key)) {
+            continue;
+        }
+
+        const value = source[key];
+
+        if (value && typeof value === 'object') {
+            const current = target[key as unknown as keyof T1];
+
+            if (current === value) {
+                continue; // Can occur for shallow merges
+            }
+
+            if (
+                !current ||
+                typeof current !== 'object' ||
+                Array.isArray(current) !== Array.isArray(value) ||
+                value instanceof Date ||
+                (Buffer && Buffer.isBuffer(value)) ||
+                value instanceof RegExp
+            ) {
+                // @ts-expect-error - Not possible to express this in TS at q
+                target[key] = clone(value, { symbols: options.symbols });
+            } else {
+                merge(current, value, options);
+            }
+        } else {
+            // Explicit to preserve empty strings
+            if (value !== null && value !== undefined) {
+                // @ts-expect-error - Not possible to express this in TS at q
+                target[key] = value;
+            } else if (options.nullOverride) {
+                // @ts-expect-error - Not possible to express this in TS at q
+                target[key] = value;
+            }
+        }
+    }
+
+    return target as MergeTypes<T1, T2>;
+}
diff --git a/src/once.ts b/src/once.ts
new file mode 100755
index 00000000..84fa6893
--- /dev/null
+++ b/src/once.ts
@@ -0,0 +1,25 @@
+const wrapped: unique symbol = Symbol('wrapped');
+
+interface WrappedFunction {
+    (...args: any[]): any;
+    [wrapped]?: boolean | undefined;
+}
+
+export function once<T extends WrappedFunction>(method: T): T {
+    if (method[wrapped]) {
+        return method;
+    }
+
+    let didRun = false;
+
+    const wrappedFn = function (...args: Parameters<T>) {
+        if (!didRun) {
+            didRun = true;
+            method(...args);
+        }
+    };
+
+    wrappedFn[wrapped] = true;
+
+    return wrappedFn as T;
+}
diff --git a/src/reach.ts b/src/reach.ts
new file mode 100755
index 00000000..654aa2ed
--- /dev/null
+++ b/src/reach.ts
@@ -0,0 +1,127 @@
+import { assert } from './assert.js';
+
+export interface ReachOptions {
+    /**
+     * String to split chain path on. Defaults to '.'.
+     *
+     * @default false
+     */
+    readonly separator?: string;
+
+    /**
+     * Value to return if the path or value is not present. No default value.
+     *
+     * @default false
+     */
+    readonly default?: any;
+
+    /**
+     * If true, will throw an error on missing member in the chain. Default to false.
+     *
+     * @default false
+     */
+    readonly strict?: boolean;
+
+    /**
+     * If true, allows traversing functions for properties. false will throw an error if a function is part of the
+     * chain.
+     *
+     * @default true
+     */
+    readonly functions?: boolean;
+
+    /**
+     * If true, allows traversing Set and Map objects for properties. false will return undefined regardless of the Set
+     * or Map passed.
+     *
+     * @default false
+     */
+    readonly iterables?: boolean;
+}
+
+/**
+ * Convert an object key chain string to reference.
+ *
+ * @param obj - The object from which to look up the value.
+ * @param chain - The string path of the requested value. The chain string is split into key names using
+ *   `options.separator`, or an array containing each individual key name. A chain including negative numbers will work
+ *   like a negative index on an array.
+ * @param options - Optional settings. Can be a string with the separator character, or ReachOptions
+ * @returns The value referenced by the chain if found, otherwise undefined. If chain is null, undefined, or false, the
+ *   object itself will be returned.
+ */
+export const reach = <T>(
+    obj: object | null,
+    chain?: string | (string | number | symbol)[] | false | null | undefined,
+    options?: ReachOptions | string,
+): T => {
+    if (chain === false || chain === null || chain === undefined) {
+        return obj as T;
+    }
+
+    options = options || {};
+
+    if (typeof options === 'string') {
+        options = { separator: options };
+    }
+
+    const isChainArray = Array.isArray(chain);
+
+    assert(!isChainArray || !options.separator, 'Separator option is not valid for array-based chain');
+
+    const path = isChainArray ? chain : chain.split(options.separator || '.');
+    let ref = obj;
+    for (let i = 0; i < path.length; ++i) {
+        let key = path[i];
+        // Defaults to false, in which case Set and Map are traversed as plain objects
+
+        const isSetType = !!options.iterables && isSet(ref);
+        const isMapType = !!options.iterables && isMap(ref);
+        const isIterable = isSetType || isMapType;
+
+        if (Array.isArray(ref) || isSetType) {
+            const number = Number(key);
+
+            if (Number.isInteger(number)) {
+                const length = isSetType ? (ref as Set<any>).size : (ref as Array<any>).length;
+                key = number < 0 ? length + number : number;
+            }
+        }
+
+        if (
+            !ref ||
+            (typeof ref === 'function' && options.functions === false) || // Defaults to true
+            (!isIterable && ref[key as keyof typeof ref] === undefined)
+        ) {
+            assert(!options.strict || i + 1 === path.length, 'Missing segment', key!, 'in reach path ', chain);
+            assert(
+                typeof ref === 'object' || options.functions === true || typeof ref !== 'function',
+                'Invalid segment',
+                key!,
+                'in reach path ',
+                chain,
+            );
+            ref = options.default;
+            break;
+        }
+
+        if (!isIterable) {
+            ref = ref[key as keyof typeof ref];
+        } else if (isSetType) {
+            ref = [...(ref as Set<any>)][Number(key)];
+        } else {
+            // isMapType — the only remaining iterable (isIterable === isSetType || isMapType)
+            ref = (ref as Map<any, any>).get(key);
+        }
+    }
+
+    return ref as T;
+};
+
+const isSet = function (ref: unknown): ref is Set<any> {
+    return ref instanceof Set;
+};
+
+const isMap = function (ref: unknown): ref is Map<any, any> {
+    return ref instanceof Map;
+};
diff --git a/src/reachTemplate.ts b/src/reachTemplate.ts
new file mode 100755
index 00000000..b0973ce6
--- /dev/null
+++ b/src/reachTemplate.ts
@@ -0,0 +1,19 @@
+import { reach } from './reach.js';
+
+import type { ReachOptions } from './reach.js';
+
+/**
+ * Replace string parameters (using format "{path.to.key}") with their corresponding object key values using
+ * `Hoek.reach()`.
+ *
+ * @param obj - The object from which to look up the value.
+ * @param template - The string containing {} enclosed key paths to be replaced.
+ * @param options - Optional settings. Can be a string with the separator character, or ReachOptions
+ * @returns The template string with the {} enclosed keys replaced with looked-up values.
+ */
+export const reachTemplate = (obj: object | null, template: string, options?: ReachOptions | string): string => {
+    return template.replace(/{([^{}]+)}/g, (_: string, chain: string) => {
+        const value = reach(obj, chain, options) as string | null;
+        return value ?? '';
+    });
+};
diff --git a/src/stringify.ts b/src/stringify.ts
new file mode 100755
index 00000000..ed84665e
--- /dev/null
+++ b/src/stringify.ts
@@ -0,0 +1,20 @@
+type StringifyParams = Parameters<typeof JSON.stringify>;
+
+/**
+ * Converts a JavaScript value to a JavaScript Object Notation (JSON) string with protection against thrown errors.
+ *
+ * @param value A JavaScript value, usually an object or array, to be converted.
+ * @param replacer The JSON.stringify() `replacer` argument.
+ * @param space Adds indentation, white space, and line break characters to the return-value JSON text to make it easier
+ *   to read.
+ * @returns The JSON string. If the operation fails, an error string value is returned (no exception thrown).
+ */
+export const stringify = (value: any, replacer?: StringifyParams[1], space?: StringifyParams[2]): string => {
+    try {
+        return JSON.stringify(value, replacer, space);
+    } catch (err) {
+        const error = err as Error;
+
+        return '[Cannot display object: ' + error.message + ']';
+    }
+};
diff --git a/src/types.ts b/src/types.ts
new file mode 100755
index 00000000..0580fb58
--- /dev/null
+++ b/src/types.ts
@@ -0,0 +1,64 @@
+export const prototypes = {
+    array: Array.prototype,
+    buffer: Buffer && Buffer.prototype,
+    date: Date.prototype,
+    error: Error.prototype,
+    generic: Object.prototype,
+    map: Map.prototype,
+    promise: Promise.prototype,
+    regex: RegExp.prototype,
+    set: Set.prototype,
+    url: URL.prototype,
+    weakMap: WeakMap.prototype,
+    weakSet: WeakSet.prototype,
+};
+
+export type AnyPrototype =
+    | Array<any>
+    | Buffer
+    | Date
+    | Error
+    | Map<any, any>
+    | Promise<any>
+    | RegExp
+    | Set<any>
+    | URL
+    | WeakMap<WeakKey, any>
+    | WeakSet<WeakKey>;
+
+const typeEntries: [string, AnyPrototype][] = [
+    ['[object Error]', prototypes.error],
+    ['[object Map]', prototypes.map],
+    ['[object Promise]', prototypes.promise],
+    ['[object Set]', prototypes.set],
+    ['[object URL]', prototypes.url],
+    ['[object WeakMap]', prototypes.weakMap],
+    ['[object WeakSet]', prototypes.weakSet],
+];
+
+const typeMap = new Map(typeEntries);
+
+export const getInternalProto = <T>(obj: T) => {
+    if (Array.isArray(obj)) {
+        return prototypes.array;
+    }
+
+    if (Buffer && obj instanceof Buffer) {
+        return prototypes.buffer;
+    }
+
+    if (obj instanceof Date) {
+        return prototypes.date;
+    }
+
+    if (obj instanceof RegExp) {
+        return prototypes.regex;
+    }
+
+    if (obj instanceof Error) {
+        return prototypes.error;
+    }
+
+    const objName = Object.prototype.toString.call(obj);
+    return typeMap.get(objName) || prototypes.generic;
+};
diff --git a/src/utils.ts b/src/utils.ts
new file mode 100755
index 00000000..0b8adb6f
--- /dev/null
+++ b/src/utils.ts
@@ -0,0 +1,6 @@
+export const keys = <T extends object>(obj: T, options: { symbols?: boolean | undefined } = {}) => {
+    // Defaults to true
+    const res = options.symbols !== false ? Reflect.ownKeys(obj) : Object.getOwnPropertyNames(obj);
+
+    return res as (keyof T)[];
+};
diff --git a/src/wait.ts b/src/wait.ts
new file mode 100644
index 00000000..945e16af
--- /dev/null
+++ b/src/wait.ts
@@ -0,0 +1,53 @@
+const MAX_TIMER = 2 ** 31 - 1; // ~25 days
+
+export interface WaitOptions {
+    /**
+     * SetTimeout function to be used by wait.
+     *
+     * @param callback - A function to be executed after the timer expires.
+     * @param delay - The time, in milliseconds that the timer should wait before the specified function is executed.
+     */
+    readonly setTimeout?: (callback: Function, delay: number) => void;
+}
+
+/**
+ * Returns a Promise that resolves after the requested timeout.
+ *
+ * @param timeout - The number of milliseconds to wait before resolving the Promise.
+ * @param returnValue - The value that the Promise will resolve to.
+ * @returns A Promise that resolves with `returnValue`.
+ */
+export function wait<T = void>(
+    timeout?: bigint | number | undefined,
+    returnValue?: T,
+    options?: WaitOptions,
+): Promise<T> {
+    if (typeof timeout !== 'number' && typeof timeout !== 'bigint' && timeout !== undefined) {
+        throw new TypeError('Timeout must be a number or bigint');
+    }
+
+    if (typeof timeout === 'bigint') {
+        timeout = Number(timeout);
+    }
+
+    if (timeout! >= Number.MAX_SAFE_INTEGER) {
+        // Thousands of years
+        timeout = Infinity;
+    }
+
+    return new Promise((resolve) => {
+        const _setTimeout = options?.setTimeout ?? setTimeout;
+
+        const activate = () => {
+            const time = Math.min(timeout as number, MAX_TIMER);
+
+            timeout = (timeout as number) - time;
+
+            _setTimeout(() => ((timeout as number) > 0 ? activate() : resolve(returnValue as T)), time);
+        };
+
+        if (timeout !== Infinity) {
+            activate();
+        }
+    });
+}
diff --git a/test/barrel.ts b/test/barrel.ts
new file mode 100644
index 00000000..1d4bfef2
--- /dev/null
+++ b/test/barrel.ts
@@ -0,0 +1,34 @@
+import { describe, it, expect } from 'vitest';
+
+import * as Hoek from '../src/index.js';
+
+describe('index', () => {
+    it('exports the expected keys', () => {
+        expect(Object.keys(Hoek).sort()).toMatchInlineSnapshot(`
+          [
+            "AssertError",
+            "Bench",
+            "applyToDefaults",
+            "assert",
+            "block",
+            "clone",
+            "contain",
+            "deepEqual",
+            "escapeHeaderAttribute",
+            "escapeHtml",
+            "escapeJson",
+            "escapeRegex",
+            "flatten",
+            "ignore",
+            "intersect",
+            "isPromise",
+            "merge",
+            "once",
+            "reach",
+            "reachTemplate",
+            "stringify",
+            "wait",
+          ]
+        `);
+    });
+});
diff --git a/test/clone.js b/test/clone.ts
similarity index 50%
rename from test/clone.js
rename to test/clone.ts
index 2ed00f24..f6435f7a 100755
--- a/test/clone.js
+++ b/test/clone.ts
@@ -1,115 +1,100 @@
-'use strict';
-
-const Code = require('@hapi/code');
-const Hoek = require('..');
-const Lab = require('@hapi/lab');
-
-
-const internals = {};
-
-
-const { describe, it } = exports.lab = Lab.script();
-const expect = Code.expect;
+import { describe, it, expect } from 'vitest';
 
+import * as Hoek from '../src/index.js';
 
 const nestedObj = {
     v: [7, 8, 9],
-    w: /^something$/igm,
+    w: /^something$/gim,
     x: {
         a: [1, 2, 3],
         b: 123456,
         c: new Date(),
-        d: /hi/igm,
-        e: /hello/
+        d: /hi/gim,
+        e: /hello/,
     },
-    y: 'y',
-    z: new Date(1378775452757)
+    y: 'y' as string | number,
+    z: new Date(1378775452757),
 };
 
-
 describe('clone()', () => {
-
     it('clones a nested object', () => {
-
         const a = nestedObj;
         const b = Hoek.clone(a);
 
-        expect(a).to.equal(b);
-        expect(a.z.getTime()).to.equal(b.z.getTime());
+        expect(a).toHoequal(b);
+        expect(a.z.getTime()).toEqual(b.z.getTime());
     });
 
     it('clones a null object', () => {
-
         const b = Hoek.clone(null);
 
-        expect(b).to.equal(null);
+        expect(b).toBeNull();
     });
 
     it('should not convert undefined properties to null', () => {
-
         const obj = { something: undefined };
         const b = Hoek.clone(obj);
 
-        expect(typeof b.something).to.equal('undefined');
+        expect(typeof b.something).toEqual('undefined');
     });
 
     it('should not throw on circular reference', () => {
-
-        const a = {};
+        const a = {} as any;
         a.x = a;
 
         expect(() => {
-
             Hoek.clone(a);
-        }).to.not.throw();
+        }).not.toThrow();
     });
 
     it('clones circular reference', () => {
+        type Nested = {
+            z: Date;
+            y: Nested;
+        };
 
         const x = {
-            'z': new Date()
-        };
+            z: new Date(),
+        } as Nested;
+
         x.y = x;
 
         const b = Hoek.clone(x);
-        expect(Object.keys(b.y)).to.equal(Object.keys(x));
-        expect(b.z).to.not.shallow.equal(x.z);
-        expect(b.y).to.not.shallow.equal(x.y);
-        expect(b.y.z).to.not.shallow.equal(x.y.z);
-        expect(b.y).to.equal(b);
-        expect(b.y.y.y.y).to.equal(b);
+        expect(Object.keys(b.y)).toEqual(Object.keys(x));
+        expect(b.z).not.toBe(x.z);
+        expect(b.y).not.toBe(x.y);
+        expect(b.y.z).not.toBe(x.y.z);
+        expect(b.y).toHoequal(b);
+        expect(b.y.y.y.y).toHoequal(b);
     });
 
     it('clones an object with a null prototype', () => {
-
         const obj = Object.create(null);
         const b = Hoek.clone(obj);
 
-        expect(b).to.equal(obj);
+        expect(b).toHoequal(obj);
     });
 
     it('clones deeply nested object', () => {
-
         const a = {
             x: {
                 y: {
                     a: [1, 2, 3],
                     b: 123456,
                     c: new Date(),
-                    d: /hi/igm,
-                    e: /hello/
-                }
-            }
+                    d: /hi/gim,
+                    e: /hello/,
+                },
+            },
         };
 
         const b = Hoek.clone(a);
 
-        expect(a).to.equal(b);
-        expect(a.x.y.c.getTime()).to.equal(b.x.y.c.getTime());
+        expect(a).toHoequal(b);
+        expect(a.x.y.c.getTime()).toEqual(b.x.y.c.getTime());
     });
 
     it('clones deeply nested set with circular references', () => {
-
         const s = new Set();
         s.add('a');
         s.add('b');
@@ -118,27 +103,27 @@ describe('clone()', () => {
         const a = {
             x: {
                 y: {
-                    a: s
-                }
-            }
+                    a: s,
+                },
+            },
         };
 
         const b = Hoek.clone(a);
 
-        expect(b).to.equal(a);
-        expect(b).to.not.equal(new Set(['a', 'b', s]));
-        expect(b).to.not.shallow.equal(a);
+        expect(b).toHoequal(a);
 
-        // Verify ordering
+        // @ts-expect-error - intentionally testing circular reference
+        expect(b).not.toHoequal(new Set(['a', 'b', s]));
+        expect(b).not.toBe(a);
 
+        // Verify ordering
         const aIter = a.x.y.a.values();
         for (const value of b.x.y.a.values()) {
-            expect(value).to.equal(aIter.next().value);
+            expect(value).toHoequal(aIter.next().value);
         }
     });
 
     it('shallow clones set', () => {
-
         const set = new Set();
         set.add('a');
         set.add('b');
@@ -146,12 +131,11 @@ describe('clone()', () => {
 
         const clone = Hoek.clone(set, { shallow: true });
 
-        expect(clone).to.equal(set);
-        expect(clone.has(set)).to.be.true();
+        expect(clone).toHoequal(set);
+        expect(clone.has(set)).toBe(true);
     });
 
     it('clones deeply nested map with circular references', () => {
-
         const m = new Map();
         m.set('a', 'a');
         m.set('b', 'b');
@@ -160,9 +144,9 @@ describe('clone()', () => {
         const a = {
             x: {
                 y: {
-                    a: m
-                }
-            }
+                    a: m,
+                },
+            },
         };
 
         const b = Hoek.clone(a);
@@ -171,204 +155,217 @@ describe('clone()', () => {
 
         const aIter = a.x.y.a.keys();
         for (const key of b.x.y.a.keys()) {
-            expect(key).to.equal(aIter.next().value);
+            expect(key).toHoequal(aIter.next().value);
         }
     });
 
     it('shallow clones map', () => {
-
         const map = new Map();
         map.set('a', { x: 1 });
         map.set(map, map);
 
         const clone = Hoek.clone(map, { shallow: true });
 
-        expect(clone).to.equal(map);
-        expect(clone.has(map)).to.be.true();
-        expect(clone.get('a')).to.shallow.equal(map.get('a'));
+        expect(clone).toHoequal(map);
+        expect(clone.has(map)).toBe(true);
+        expect(clone.get('a')).toBe(map.get('a'));
     });
 
     it('clones arrays', () => {
-
         const a = [1, 2, 3];
 
         const b = Hoek.clone(a);
 
-        expect(a).to.equal(b);
+        expect(a).toHoequal(b);
     });
 
     it('clones holey arrays', () => {
-
         const a = new Array(3);
         a[1] = 'one';
 
         const b = Hoek.clone(a);
 
-        expect(a).to.equal(b);
+        expect(a).toHoequal(b);
     });
 
     it('clones array-based class', () => {
-
         const A = class extends Array {
             __x = 1;
 
             __y() {
-
                 return 2;
             }
         };
 
-        const a = new A(1, 2, 3);
+        const a = new A(1);
 
         const b = Hoek.clone(a);
 
-        expect(a).to.equal(b);
-        expect(b.__x).to.equal(1);
-        expect(b.__y).to.exist();
-        expect(b.__y()).to.equal(2);
+        expect(a).toHoequal(b);
+        expect(b.__x).toEqual(1);
+        expect(b.__y).toBeDefined();
+        expect(b.__y()).toEqual(2);
     });
 
     it('clones array-based class (without prototype)', () => {
-
         const A = class extends Array {
             __x = 1;
 
             __y() {
-
                 return 2;
             }
         };
 
-        const a = new A(1, 2, 3);
+        const a = new A(1);
 
         const b = Hoek.clone(a, { prototype: false });
 
-        expect(a).to.equal(b);
-        expect(b.__x).to.equal(1);
-        expect(b.__y).to.not.exist();
+        expect(a).toHoequal(b);
+        expect(b.__x).toEqual(1);
+        expect(b.__y).toBeUndefined();
     });
 
     it('clones symbol properties', () => {
-
         const sym1 = Symbol(1);
         const sym2 = Symbol(2);
-        const a = { [sym1]: 1 };
+        const a = { [sym1]: 1 } as { [sym1]: number; [sym2]: number };
         Object.defineProperty(a, sym2, { value: 2 });
 
         const b = Hoek.clone(a);
 
-        expect(a).to.equal(b);
-        expect(b[sym1]).to.be.equal(1);
-        expect(b[sym2]).to.be.equal(2);
+        expect(a).toHoequal(b);
+        expect(b[sym1]).toEqual(1);
+        expect(b[sym2]).toEqual(2);
 
-        expect(Hoek.deepEqual(a, b)).to.be.true();
+        expect(Hoek.deepEqual(a, b)).toBe(true);
     });
 
     it('performs actual copy for shallow keys (no pass by reference)', () => {
-
         const x = Hoek.clone(nestedObj);
         const y = Hoek.clone(nestedObj);
 
         // Date
-        expect(x.z).to.not.shallow.equal(nestedObj.z);
-        expect(x.z).to.not.shallow.equal(y.z);
+        expect(x.z).not.toBe(nestedObj.z);
+        expect(x.z).not.toBe(y.z);
 
         // Regex
-        expect(x.w).to.not.shallow.equal(nestedObj.w);
-        expect(x.w).to.not.shallow.equal(y.w);
+        expect(x.w).not.toBe(nestedObj.w);
+        expect(x.w).not.toBe(y.w);
 
         // Array
-        expect(x.v).to.not.shallow.equal(nestedObj.v);
-        expect(x.v).to.not.shallow.equal(y.v);
+        expect(x.v).not.toBe(nestedObj.v);
+        expect(x.v).not.toBe(y.v);
 
         // Immutable(s)
         x.y = 5;
-        expect(x.y).to.not.equal(nestedObj.y);
-        expect(x.y).to.not.equal(y.y);
+
+        // @ts-expect-error - intentionally testing immutability
+        expect(x.y).not.toHoequal(nestedObj.y);
+
+        // @ts-expect-error - intentionally testing immutability
+        expect(x.y).not.toHoequal(y.y);
     });
 
     it('performs actual copy for deep keys (no pass by reference)', () => {
-
         const x = Hoek.clone(nestedObj);
         const y = Hoek.clone(nestedObj);
 
-        expect(x.x.c).to.not.shallow.equal(nestedObj.x.c);
-        expect(x.x.c).to.not.shallow.equal(y.x.c);
+        expect(x.x.c).not.toBe(nestedObj.x.c);
+        expect(x.x.c).not.toBe(y.x.c);
 
-        expect(x.x.c.getTime()).to.equal(nestedObj.x.c.getTime());
-        expect(x.x.c.getTime()).to.equal(y.x.c.getTime());
+        expect(x.x.c.getTime()).toHoequal(nestedObj.x.c.getTime());
+        expect(x.x.c.getTime()).toEqual(y.x.c.getTime());
     });
 
     it('copies functions with properties', () => {
-
         const a = {
             x: function () {
-
                 return 1;
             },
-            y: {}
+            y: {},
+        } as {
+            x: Function & {
+                z?: string;
+                v?: Function;
+            };
+            y: {
+                u?: any;
+            };
         };
+
         a.x.z = 'string in function';
         a.x.v = function () {
-
             return 2;
         };
 
         a.y.u = a.x;
 
         const b = Hoek.clone(a);
-        expect(b.x()).to.equal(1);
-        expect(b.x.v()).to.equal(2);
-        expect(b.y.u).to.equal(b.x);
-        expect(b.x.z).to.equal('string in function');
+        expect(b.x()).toEqual(1);
+        expect(b.x.v!()).toEqual(2);
+        expect(b.y.u).toHoequal(b.x);
+        expect(b.x.z).toEqual('string in function');
     });
 
     it('should copy a buffer', () => {
-
         const tls = {
             key: Buffer.from([1, 2, 3, 4, 5]),
-            cert: Buffer.from([1, 2, 3, 4, 5, 6, 10])
+            cert: Buffer.from([1, 2, 3, 4, 5, 6, 10]),
         };
 
         const copiedTls = Hoek.clone(tls);
-        expect(Buffer.isBuffer(copiedTls.key)).to.equal(true);
-        expect(JSON.stringify(copiedTls.key)).to.equal(JSON.stringify(tls.key));
-        expect(Buffer.isBuffer(copiedTls.cert)).to.equal(true);
-        expect(JSON.stringify(copiedTls.cert)).to.equal(JSON.stringify(tls.cert));
+        expect(Buffer.isBuffer(copiedTls.key)).toBe(true);
+        expect(JSON.stringify(copiedTls.key)).toEqual(JSON.stringify(tls.key));
+        expect(Buffer.isBuffer(copiedTls.cert)).toBe(true);
+        expect(JSON.stringify(copiedTls.cert)).toEqual(JSON.stringify(tls.cert));
 
         tls.key.write('hi');
-        expect(JSON.stringify(copiedTls.key)).to.not.equal(JSON.stringify(tls.key));
+        expect(JSON.stringify(copiedTls.key)).not.toEqual(JSON.stringify(tls.key));
     });
 
     it('clones an object with a prototype', () => {
+        type ObjInst = {
+            b: () => 'c';
+            a: number;
+            x: number;
+        };
 
-        const Obj = function () {
+        interface ObjFn extends ObjInst {
+            new (): ObjInst;
+        }
 
+        const Obj = function (this: ObjFn) {
             this.a = 5;
-        };
+        } as unknown as ObjFn;
 
         Obj.prototype.b = function () {
-
             return 'c';
         };
 
         const a = new Obj();
         const b = Hoek.clone(a);
 
-        expect(b.a).to.equal(5);
-        expect(b.b()).to.equal('c');
-        expect(a).to.equal(b);
+        expect(b.a).toEqual(5);
+        expect(b.b()).toEqual('c');
+        expect(a).toHoequal(b);
     });
 
     it('clones an object without a prototype', () => {
+        type ObjInst = {
+            b: () => 'c';
+            a: number;
+            x: number;
+        };
 
-        const Obj = function () {
+        interface ObjFn extends ObjInst {
+            new (): ObjInst;
+        }
 
+        const Obj = function (this: ObjFn) {
             this.a = 5;
-        };
+        } as unknown as ObjFn;
 
         Obj.prototype.b = function () {
-
             return 'c';
         };
 
@@ -377,54 +374,62 @@ describe('clone()', () => {
 
         const b = Hoek.clone(a, { prototype: false });
 
-        expect(a).to.equal(b);
-        expect(a).to.not.equal(b, { prototype: true });
-        expect(b.a).to.equal(5);
-        expect(b.b).to.not.exist();
-        expect(b.x).to.equal(123);
+        expect(a).toHoequal(b);
+        expect(a).not.toHoequal(b, { prototype: true });
+        expect(b.a).toEqual(5);
+        expect(b.b).toBeUndefined();
+        expect(b.x).toEqual(123);
     });
 
     it('reuses cloned Date object', () => {
-
         const obj = {
-            a: new Date()
+            a: new Date(),
+        } as {
+            a: Date;
+            b?: Date;
         };
 
         obj.b = obj.a;
 
         const copy = Hoek.clone(obj);
-        expect(copy.a).to.equal(copy.b);
+        expect(copy.a).toHoequal(copy.b!);
     });
 
     it('shallow copies an object with a prototype and isImmutable flag', () => {
+        type ObjInst = {
+            b: () => 'c';
+            value: number;
+            x: number;
+        };
 
-        const Obj = function () {
+        interface ObjFn extends ObjInst {
+            new (): ObjInst;
+        }
 
+        const Obj = function (this: ObjFn) {
             this.value = 5;
-        };
+        } as unknown as ObjFn;
 
         Obj.prototype.b = function () {
-
             return 'c';
         };
 
         Obj.prototype.isImmutable = true;
 
         const obj = {
-            a: new Obj()
+            a: new Obj(),
         };
 
         const copy = Hoek.clone(obj);
 
-        expect(obj.a.value).to.equal(5);
-        expect(copy.a.value).to.equal(5);
-        expect(copy.a.b()).to.equal('c');
-        expect(obj.a).to.equal(copy.a);
+        expect(obj.a.value).toEqual(5);
+        expect(copy.a.value).toEqual(5);
+        expect(copy.a.b()).toEqual('c');
+        expect(obj.a).toHoequal(copy.a);
     });
 
     it('clones an object with property getter without executing it', () => {
-
-        const obj = {};
+        const obj = {} as { test?: number };
         const value = 1;
         let execCount = 0;
 
@@ -432,105 +437,101 @@ describe('clone()', () => {
             enumerable: true,
             configurable: true,
             get: function () {
-
                 ++execCount;
                 return value;
-            }
+            },
         });
 
         const copy = Hoek.clone(obj);
-        expect(execCount).to.equal(0);
-        expect(copy.test).to.equal(1);
-        expect(execCount).to.equal(1);
+        expect(execCount).toEqual(0);
+        expect(copy.test).toEqual(1);
+        expect(execCount).toEqual(1);
     });
 
     it('clones an object with property getter and setter', () => {
-
         const obj = {
-            _test: 0
+            _test: 0,
+        } as {
+            _test: number;
+            test?: number;
         };
 
         Object.defineProperty(obj, 'test', {
             enumerable: true,
             configurable: true,
             get: function () {
-
                 return this._test;
             },
             set: function (value) {
-
                 this._test = value - 1;
-            }
+            },
         });
 
         const copy = Hoek.clone(obj);
-        expect(copy.test).to.equal(0);
+        expect(copy.test).toEqual(0);
         copy.test = 5;
-        expect(copy.test).to.equal(4);
+        expect(copy.test).toEqual(4);
     });
 
     it('clones an object with only property setter', () => {
-
         const obj = {
-            _test: 0
+            _test: 0,
+        } as {
+            _test: number;
+            test?: number;
         };
 
         Object.defineProperty(obj, 'test', {
             enumerable: true,
             configurable: true,
             set: function (value) {
-
                 this._test = value - 1;
-            }
+            },
         });
 
         const copy = Hoek.clone(obj);
-        expect(copy._test).to.equal(0);
+        expect(copy._test).toEqual(0);
         copy.test = 5;
-        expect(copy._test).to.equal(4);
+        expect(copy._test).toEqual(4);
     });
 
     it('clones an object with non-enumerable properties', () => {
-
         const obj = {
-            _test: 0
+            _test: 0,
+        } as {
+            _test: number;
+            test?: number;
         };
 
         Object.defineProperty(obj, 'test', {
             enumerable: false,
             configurable: true,
             set: function (value) {
-
                 this._test = value - 1;
-            }
+            },
         });
 
         const copy = Hoek.clone(obj);
-        expect(copy._test).to.equal(0);
+        expect(copy._test).toEqual(0);
         copy.test = 5;
-        expect(copy._test).to.equal(4);
+        expect(copy._test).toEqual(4);
     });
 
     it('clones an object where getOwnPropertyDescriptor returns undefined', () => {
-
         const oldGetOwnPropertyDescriptor = Object.getOwnPropertyDescriptor;
         const obj = { a: 'b' };
         Object.getOwnPropertyDescriptor = function () {
-
             return undefined;
         };
 
         const copy = Hoek.clone(obj);
         Object.getOwnPropertyDescriptor = oldGetOwnPropertyDescriptor;
-        expect(copy).to.equal(obj);
+        expect(copy).toHoequal(obj);
     });
 
     it('clones own property when class property is not writable', () => {
-
         const Cl = class {
-
             get x() {
-
                 return 'hi';
             }
         };
@@ -538,121 +539,124 @@ describe('clone()', () => {
         const obj = new Cl();
 
         Object.defineProperty(obj, 'x', {
-            value: 0, writable: true
+            value: 0,
+            writable: true,
         });
 
         const copy = Hoek.clone(obj);
-        expect(copy).to.equal(obj);
+        expect(copy).toHoequal(obj);
     });
 
     it('clones a Set', () => {
-
         const a = new Set([1, 2, 3]);
         const b = Hoek.clone(a);
 
-        expect(b).to.equal(a);
-        expect(b).to.not.equal(new Set([2, 3, 4]));
-        expect(b).to.not.shallow.equal(a);
+        expect(b).toHoequal(a);
+        expect(b).not.toHoequal(new Set([2, 3, 4]));
+        expect(b).not.toBe(a);
 
         // Verify ordering
 
         const aIter = a.values();
         for (const value of b.values()) {
-            expect(value).to.equal(aIter.next().value);
+            expect(value).toHoequal(aIter.next().value!);
         }
     });
 
     it('clones properties set on a Set', () => {
+        const a = new Set([1]) as Set<number> & {
+            val: { b: number };
+        };
 
-        const a = new Set([1]);
         a.val = { b: 2 };
 
         const b = Hoek.clone(a);
 
-        expect(b).to.equal(a);
-        expect(b.val).to.equal(a.val);
-        expect(b.val).to.not.shallow.equal(a.val);
+        expect(b).toHoequal(a);
+        expect(b.val).toHoequal(a.val);
+        expect(b.val).not.toBe(a.val);
     });
 
     it('clones subclassed Set', () => {
-
-        const MySet = class extends Set { };
+        const MySet = class extends Set {};
 
         const a = new MySet([1]);
         const b = Hoek.clone(a);
 
-        expect(b).to.equal(a);
-        expect(b).to.be.instanceof(MySet);
+        expect(b).toHoequal(a);
+        expect(b).toBeInstanceOf(MySet);
 
         const c = Hoek.clone(a, { prototype: false });
 
-        expect(c).to.not.equal(a, { prototype: true });
-        expect(c).to.equal(a, { prototype: false });
-        expect(c).to.be.instanceof(Set);
-        expect(c).to.not.be.instanceof(MySet);
+        expect(c).not.toHoequal(a, { prototype: true });
+        expect(c).toHoequal(a, { prototype: false });
+        expect(c).toBeInstanceOf(Set);
+        expect(c).not.toBeInstanceOf(MySet);
     });
 
     it('clones Set containing objects (no pass by reference)', () => {
+        const a = new Set<number | typeof nestedObj>([1, 2, 3]);
 
-        const a = new Set([1, 2, 3]);
         a.add(nestedObj);
 
         const b = Hoek.clone(a);
 
-        expect(b).to.equal(a);
-        expect(b).to.not.shallow.equal(a);
-        expect(b.has(nestedObj)).to.be.false(a);
+        expect(b).toHoequal(a);
+        expect(b).not.toBe(a);
+        expect(b.has(nestedObj)).toBe(false);
     });
 
     it('clones a Map', () => {
-
-        const a = new Map([['a', 1], ['b', 2], ['c', 3]]);
+        const a = new Map([
+            ['a', 1],
+            ['b', 2],
+            ['c', 3],
+        ]);
         const b = Hoek.clone(a);
 
-        expect(b).to.equal(a);
-        expect(b).to.not.equal(new Map());
-        expect(b).to.not.shallow.equal(a);
+        expect(b).toHoequal(a);
+        expect(b).not.toHoequal(new Map());
+        expect(b).not.toBe(a);
 
         // Verify key ordering
 
         const aIter = a.keys();
         for (const key of b.keys()) {
-            expect(key).to.equal(aIter.next().value);
+            expect(key).toHoequal(aIter.next().value!);
         }
     });
 
     it('clones properties set on Map', () => {
-
-        const a = new Map([['a', 1]]);
+        const a = new Map([['a', 1]]) as Map<string, number> & {
+            val: { b: number };
+        };
         a.val = { b: 2 };
 
         const b = Hoek.clone(a);
 
-        expect(b).to.equal(a);
-        expect(b.val).to.equal(a.val);
-        expect(b.val).to.not.shallow.equal(a.val);
+        expect(b).toHoequal(a);
+        expect(b.val).toHoequal(a.val);
+        expect(b.val).not.toBe(a.val);
     });
 
     it('clones subclassed Map', () => {
-
-        const MyMap = class extends Map { };
+        const MyMap = class extends Map<string, number> {};
 
         const a = new MyMap([['a', 1]]);
         const b = Hoek.clone(a);
 
-        expect(b).to.equal(a);
-        expect(b).to.be.instanceof(MyMap);
+        expect(b).toHoequal(a);
+        expect(b).toBeInstanceOf(MyMap);
 
         const c = Hoek.clone(a, { prototype: false });
 
-        expect(c).to.not.equal(a, { prototype: true });
-        expect(c).to.equal(a, { prototype: false });
-        expect(c).to.be.instanceof(Map);
-        expect(c).to.not.be.instanceof(MyMap);
+        expect(c).not.toHoequal(a, { prototype: true });
+        expect(c).toHoequal(a, { prototype: false });
+        expect(c).toBeInstanceOf(Map);
+        expect(c).not.toBeInstanceOf(MyMap);
     });
 
     it('clones Map containing objects as values (no pass by reference)', () => {
-
         const a = new Map();
         a.set('a', 1);
         a.set('b', 2);
@@ -660,14 +664,13 @@ describe('clone()', () => {
 
         const b = Hoek.clone(a);
 
-        expect(b).to.equal(a);
-        expect(b).to.not.shallow.equal(a);
-        expect(b.get('c')).to.equal(a.get('c'));
-        expect(b.get('c')).to.not.shallow.equal(a.get('c'));
+        expect(b).toHoequal(a);
+        expect(b).not.toBe(a);
+        expect(b.get('c')).toHoequal(a.get('c'));
+        expect(b.get('c')).not.toBe(a.get('c'));
     });
 
     it('clones Map containing objects as keys (passed by reference)', () => {
-
         const a = new Map();
         a.set('a', 1);
         a.set('b', 2);
@@ -675,201 +678,199 @@ describe('clone()', () => {
 
         const b = Hoek.clone(a);
 
-        expect(b).to.equal(a);
-        expect(b).to.not.shallow.equal(a);
-        expect(b.get(nestedObj)).to.equal(a.get(nestedObj));
+        expect(b).toHoequal(a);
+        expect(b).not.toBe(a);
+        expect(b.get(nestedObj)).toHoequal(a.get(nestedObj));
     });
 
     it('clones an URL', () => {
-
         const a = new URL('https://hapi.dev/');
         const b = Hoek.clone(a);
 
-        expect(b.href).to.equal(a.href);
-        expect(b).to.not.shallow.equal(a);
+        expect(b.href).toEqual(a.href);
+        expect(b).not.toBe(a);
     });
 
     it('clones Error', () => {
-
         class CustomError extends Error {
             name = 'CustomError';
+            test?: symbol;
         }
 
         const a = new CustomError('bad');
+
         a.test = Symbol('test');
 
         const b = Hoek.clone(a);
 
-        expect(b).to.equal(a);
-        expect(b).to.not.shallow.equal(a);
-        expect(b).to.be.instanceOf(CustomError);
-        expect(b.stack).to.equal(a.stack);                 // Explicitly validate the .stack getters
+        expect(b).toHoequal(a);
+        expect(b).not.toBe(a);
+        expect(b).toBeInstanceOf(CustomError);
+        expect(b.stack).toHoequal(a.stack); // Explicitly validate the .stack getters
     });
 
-    it('clones Error with cause', { skip: process.version.startsWith('v14') }, () => {
-
-        const a = new TypeError('bad', { cause: new Error('embedded') });
+    it('clones Error with cause', () => {
+        const a = new TypeError('bad', { cause: new Error('embedded') }) as TypeError & {
+            cause?: Error;
+        };
         const b = Hoek.clone(a);
 
-        expect(b).to.equal(a);
-        expect(b).to.not.shallow.equal(a);
-        expect(b).to.be.instanceOf(TypeError);
-        expect(b.stack).to.equal(a.stack);                 // Explicitly validate the .stack getters
-        expect(b.cause.stack).to.equal(a.cause.stack);     // Explicitly validate the .stack getters
+        expect(b).toHoequal(a);
+        expect(b).not.toBe(a);
+        expect(b).toBeInstanceOf(TypeError);
+        expect(b.stack).toHoequal(a.stack); // Explicitly validate the .stack getters
+        expect(b.cause!.stack).toHoequal(a.cause!.stack); // Explicitly validate the .stack getters
     });
 
     it('clones Error with error message', () => {
-
         const a = new Error();
-        a.message = new Error('message');
+        a.message = new Error('message') as unknown as string;
 
         const b = Hoek.clone(a);
 
-        //expect(b).to.equal(a);                           // deepEqual() always compares message using ===
-        expect(b.message).to.equal(a.message);
-        expect(b.message).to.not.shallow.equal(a.message);
-        expect(b.stack).to.equal(a.stack);
+        //expect(b).toHoequal(a);                           // deepEqual() always compares message using ===
+        expect(b.message).toHoequal(a.message);
+        expect(b.message).not.toBe(a.message);
+        expect(b.stack).toHoequal(a.stack);
     });
 
     it('clones Error with function property', () => {
-
-        const a = new Error('hello');
+        const a: any = new Error('hello');
         a.fun = new Function();
 
         const b = Hoek.clone(a);
 
-        expect(b).to.equal(a);
-        expect(b.stack).to.equal(a.stack);
+        expect(b).toEqual(a);
+        expect(b.stack).toEqual(a.stack);
     });
 
     it('clones legacy extended Error with function property', () => {
-
-        const CustomError = function () {
-
+        const CustomError = function (this: any) {
             Error.call(this);
         };
 
         Object.setPrototypeOf(CustomError.prototype, Error.prototype);
 
-        const a = new CustomError('hello');
+        const a: any = new (CustomError as any)('hello');
         a.fun = new Function();
 
         const b = Hoek.clone(a);
 
-        expect(b).to.equal(a);
-        expect(b.stack).to.equal(a.stack);
+        expect(b).toEqual(a);
+        expect(b.stack).toEqual(a.stack);
     });
 
     it('cloned Error handles late stack update', () => {
-
         const a = new Error('bad');
         const b = Hoek.clone(a);
 
         a.stack = 'late update';
 
-        expect(b).to.equal(a);
-        expect(b.stack).to.not.equal(a.stack);
+        expect(b).toHoequal(a);
+        expect(b.stack).not.toHoequal(a.stack);
     });
 
     it('ignores symbols', () => {
-
         const sym = Symbol();
         const source = {
             a: {
-                b: 5
+                b: 5,
             },
             [sym]: {
-                d: 6
-            }
+                d: 6,
+            },
         };
 
         const copy = Hoek.clone(source, { symbols: false });
-        expect(copy).to.equal(source, { symbols: false });
-        expect(Hoek.deepEqual(source, copy)).to.be.false();
-        expect(copy).to.not.shallow.equal(source);
-        expect(copy.a).to.not.shallow.equal(source.a);
-        expect(copy[sym]).to.not.exist();
+        expect(copy).toHoequal(source, { symbols: false });
+        expect(Hoek.deepEqual(source, copy)).toBe(false);
+        expect(copy).not.toBe(source);
+        expect(copy.a).not.toBe(source.a);
+        expect(copy[sym]).toBeUndefined();
     });
 
     it('deep clones except for listed keys', () => {
-
         const source = {
             a: {
-                b: 5
+                b: 5,
             },
             c: {
-                d: 6
+                d: 6,
             },
-            e() { }
+            e() {},
         };
 
         const copy = Hoek.clone(source, { shallow: ['c', 'e'] });
-        expect(copy).to.equal(source);
-        expect(copy).to.not.shallow.equal(source);
-        expect(copy.a).to.not.shallow.equal(source.a);
-        expect(copy.c).to.shallow.equal(source.c);
-        expect(copy.e).to.shallow.equal(source.e);
+        expect(copy).toHoequal(source);
+        expect(copy).not.toBe(source);
+        expect(copy.a).not.toBe(source.a);
+        expect(copy.c).toBe(source.c);
+        expect(copy.e).toBe(source.e);
     });
 
     it('returns immutable value', () => {
-
-        expect(Hoek.clone(5, { shallow: [] })).to.equal(5);
+        expect(Hoek.clone(5, { shallow: [] })).toEqual(5);
     });
 
     it('returns null value', () => {
-
-        expect(Hoek.clone(null, { shallow: [] })).to.equal(null);
+        expect(Hoek.clone(null, { shallow: [] })).toBeNull();
     });
 
     it('returns undefined value', () => {
-
-        expect(Hoek.clone(undefined, { shallow: [] })).to.equal(undefined);
+        expect(Hoek.clone(undefined, { shallow: [] })).toBeUndefined();
     });
 
     it('deep clones except for listed keys (including missing keys)', () => {
-
         const source = {
             a: {
-                b: 5
+                b: 5,
             },
             c: {
-                d: 6
-            }
+                d: 6,
+            },
         };
 
         const copy = Hoek.clone(source, { shallow: ['c', 'v'] });
-        expect(copy).to.equal(source);
-        expect(copy).to.not.shallow.equal(source);
-        expect(copy.a).to.not.shallow.equal(source.a);
-        expect(copy.b).to.equal(source.b);
+        expect(copy).toHoequal(source);
+        expect(copy).not.toBe(source);
+        expect(copy.a).not.toBe(source.a);
+
+        // @ts-expect-error - intentionally testing missing key
+        expect(copy.b).toHoequal(source.b);
     });
 
     it('supports shallow symbols', () => {
-
         const sym = Symbol();
         const source = {
             a: {
-                b: 5
+                b: 5,
             },
             [sym]: {
-                d: 6
-            }
+                d: 6,
+            },
         };
 
         const copy = Hoek.clone(source, { shallow: [[sym]], symbols: true });
-        expect(copy).to.equal(source);
-        expect(copy).to.not.shallow.equal(source);
-        expect(copy.a).to.not.shallow.equal(source.a);
-        expect(copy[sym]).to.equal(source[sym]);
+        expect(copy).toHoequal(source);
+        expect(copy).not.toBe(source);
+        expect(copy.a).not.toBe(source.a);
+        expect(copy[sym]).toHoequal(source[sym]);
     });
 
     it('shallow clones an entire object', () => {
+        type Nested = {
+            a: {
+                b: number;
+            };
+            x?: Nested;
+            test?: number;
+        };
 
         const obj = {
             a: {
-                b: 1
-            }
-        };
+                b: 1,
+            },
+        } as Nested;
 
         obj.x = obj;
 
@@ -880,67 +881,70 @@ describe('clone()', () => {
             enumerable: true,
             configurable: true,
             get: function () {
-
                 ++execCount;
                 return value;
-            }
+            },
         });
 
         const copy = Hoek.clone(obj, { shallow: true });
-        expect(execCount).to.equal(0);
-        expect(copy.test).to.equal(1);
-        expect(execCount).to.equal(1);
-        expect(copy.a).to.shallow.equal(obj.a);
-        expect(copy.x).to.shallow.equal(obj);
+        expect(execCount).toEqual(0);
+        expect(copy.test).toEqual(1);
+        expect(execCount).toEqual(1);
+        expect(copy.a).toBe(obj.a);
+        expect(copy.x).toBe(obj);
     });
 
     it('does not invoke setter when shallow cloning', () => {
-
-        const obj = {};
+        const obj = {} as {
+            a: object;
+            b: object;
+        };
 
         Object.defineProperty(obj, 'a', { enumerable: true, value: {} });
         Object.defineProperty(obj, 'b', { enumerable: true, value: {} });
 
         const copy = Hoek.clone(obj, { shallow: ['a'] });
 
-        expect(copy).equal({ a: {}, b: {} });
-        expect(copy.a).to.shallow.equal(obj.a);
+        expect(copy).toHoequal({ a: {}, b: {} });
+        expect(copy.a).toBe(obj.a);
     });
 
     it('prevents prototype poisoning', () => {
-
         const a = JSON.parse('{ "__proto__": { "x": 1 } }');
-        expect(a.x).to.not.exist();
+        expect(a.x).toBeUndefined();
 
         const b = Hoek.clone(a);
-        expect(b.x).to.not.exist();
+        expect(b.x).toBeUndefined();
     });
 
-    it('handles structuredClone not returning proper Error instances', { skip: typeof structuredClone !== 'function' }, () => {
+    it(
+        'handles structuredClone not returning proper Error instances',
+        { skip: typeof structuredClone !== 'function' },
+        () => {
+            // This can happen when running in a VM
 
-        // This can happen when running in a VM
+            const error = new Error('blam');
+            let cloned: Error | undefined;
 
-        const error = new Error('blam');
+            const origStructuredClone = structuredClone;
 
-        const origStructuredClone = structuredClone;
-        try {
-            structuredClone = function (obj) {
+            try {
+                global.structuredClone = function <T>(this: typeof structuredClone, obj: T): T {
+                    const clone = origStructuredClone.call(this, obj);
+                    if (obj === error) {
+                        Object.setPrototypeOf(clone, Object);
+                    }
 
-                const clone = origStructuredClone.call(this, obj);
-                if (obj === error) {
-                    Object.setPrototypeOf(clone, Object);
-                }
-
-                return clone;
-            };
+                    return clone as T;
+                } as unknown as typeof structuredClone;
 
-            var cloned = Hoek.clone(error);
-        }
-        finally {
-            structuredClone = origStructuredClone;
-        }
+                cloned = Hoek.clone(error);
+            } finally {
+                global.structuredClone = origStructuredClone;
+            }
 
-        expect(cloned).to.be.instanceOf(Error);
-        expect(cloned).to.equal(error);
-    });
+            expect(cloned).toBeInstanceOf(Error);
+            expect(cloned).toHoequal(error);
+        },
+    );
 });
diff --git a/test/escaper.js b/test/escaper.ts
similarity index 50%
rename from test/escaper.js
rename to test/escaper.ts
index 5452f0a5..b92295a8 100755
--- a/test/escaper.js
+++ b/test/escaper.ts
@@ -1,123 +1,94 @@
-'use strict';
-
-const Code = require('@hapi/code');
-const Hoek = require('..');
-const Lab = require('@hapi/lab');
-
-
-const internals = {};
-
-
-const { describe, it } = exports.lab = Lab.script();
-const expect = Code.expect;
+import { describe, it, expect } from 'vitest';
 
+import * as Hoek from '../src/index.js';
 
 describe('escapeHtml()', () => {
-
     it('encodes / characters', () => {
-
         const encoded = Hoek.escapeHtml('<script>alert(1)</script>');
-        expect(encoded).to.equal('&lt;script&gt;alert&#x28;1&#x29;&lt;&#x2f;script&gt;');
+        expect(encoded).toEqual('&lt;script&gt;alert&#x28;1&#x29;&lt;&#x2f;script&gt;');
     });
 
     it('encodes < and > as named characters', () => {
-
         const encoded = Hoek.escapeHtml('<script><>');
-        expect(encoded).to.equal('&lt;script&gt;&lt;&gt;');
+        expect(encoded).toEqual('&lt;script&gt;&lt;&gt;');
     });
 
     it('encodes large unicode characters', () => {
-
         const encoded = Hoek.escapeHtml(String.fromCharCode(500) + String.fromCharCode(1000));
-        expect(encoded).to.equal('&#500;&#1000;');
+        expect(encoded).toEqual('&#500;&#1000;');
     });
 
-    it('doesn\'t throw an exception when passed null', () => {
-
+    it("doesn't throw an exception when passed null", () => {
         const encoded = Hoek.escapeHtml(null);
-        expect(encoded).to.equal('');
+        expect(encoded).toEqual('');
     });
 
     it('encodes {} characters', () => {
-
         const encoded = Hoek.escapeHtml('{}');
-        expect(encoded).to.equal('&#x7b;&#x7d;');
+        expect(encoded).toEqual('&#x7b;&#x7d;');
     });
 });
 
 describe('escapeJson()', () => {
-
     it('encodes < and > as unicode escaped equivalents', () => {
-
         const encoded = Hoek.escapeJson('<script><>');
-        expect(encoded).to.equal('\\u003cscript\\u003e\\u003c\\u003e');
+        expect(encoded).toEqual('\\u003cscript\\u003e\\u003c\\u003e');
     });
 
-    it('doesn\'t encode \0 as hex escaped equivalent', () => {
-
+    it("doesn't encode \0 as hex escaped equivalent", () => {
         const encoded = Hoek.escapeJson('\0');
-        expect(encoded).to.equal('\0');
+        expect(encoded).toEqual('\0');
     });
 
     it('encodes & (ampersand) as unicode escaped equivalent', () => {
-
         const encoded = Hoek.escapeJson('&&');
-        expect(encoded).to.equal('\\u0026\\u0026');
+        expect(encoded).toEqual('\\u0026\\u0026');
     });
 
     it('encodes line seperator as unicode escaped equivalent', () => {
-
         const lineSeparator = String.fromCharCode(0x2028);
         const encoded = Hoek.escapeJson(lineSeparator);
-        expect(encoded).to.equal('\\u2028');
+        expect(encoded).toEqual('\\u2028');
     });
 
     it('encodes paragraph seperator as unicode escaped equivalent', () => {
-
         const paragraphSeparator = String.fromCharCode(0x2029);
         const encoded = Hoek.escapeJson(paragraphSeparator);
-        expect(encoded).to.equal('\\u2029');
+        expect(encoded).toEqual('\\u2029');
     });
 
-    it('doesn\'t encode U+13F0 Cherokee Letter Ye as unicode escaped equivalent', () => {
-
+    it("doesn't encode U+13F0 Cherokee Letter Ye as unicode escaped equivalent", () => {
         const encoded = Hoek.escapeJson('Ᏸ');
-        expect(encoded).to.equal('Ᏸ');
+        expect(encoded).toEqual('Ᏸ');
     });
 
-    it('doesn\'t encode U+1F4A9 PILE OF POO as unicode escaped equivalent', () => {
-
+    it("doesn't encode U+1F4A9 PILE OF POO as unicode escaped equivalent", () => {
         const encoded = Hoek.escapeJson('💩');
-        expect(encoded).to.equal('💩');
+        expect(encoded).toEqual('💩');
     });
 
-    it('doesn\'t encode U+1D306 TETRAGRAM FOR CENTRE as unicode escaped equivalent', () => {
-
+    it("doesn't encode U+1D306 TETRAGRAM FOR CENTRE as unicode escaped equivalent", () => {
         const encoded = Hoek.escapeJson('𝌆');
-        expect(encoded).to.equal('𝌆');
+        expect(encoded).toEqual('𝌆');
     });
 
-    it('doesn\'t encode \\ (backslash)', () => {
-
+    it("doesn't encode \\ (backslash)", () => {
         const encoded = Hoek.escapeJson('\\');
-        expect(encoded).to.equal('\\');
+        expect(encoded).toEqual('\\');
     });
 
-    it('doesn\'t throw an exception when passed null', () => {
-
+    it("doesn't throw an exception when passed null", () => {
         const encoded = Hoek.escapeJson(null);
-        expect(encoded).to.equal('');
+        expect(encoded).toEqual('');
     });
 
-    it('doesn\'t encode {} characters', () => {
-
+    it("doesn't encode {} characters", () => {
         const encoded = Hoek.escapeJson('{}');
-        expect(encoded).to.equal('{}');
+        expect(encoded).toEqual('{}');
     });
 
-    it('doesn\'t encode / (slash) character', () => {
-
+    it("doesn't encode / (slash) character", () => {
         const encoded = Hoek.escapeJson('<script>alert(1)</script>');
-        expect(encoded).to.equal('\\u003cscript\\u003ealert(1)\\u003c/script\\u003e');
+        expect(encoded).toEqual('\\u003cscript\\u003ealert(1)\\u003c/script\\u003e');
     });
 });
diff --git a/test/exports.js b/test/exports.js
deleted file mode 100644
index 4cdf1f9f..00000000
--- a/test/exports.js
+++ /dev/null
@@ -1,88 +0,0 @@
-'use strict';
-
-const Code = require('@hapi/code');
-const Lab = require('@hapi/lab');
-const Hoek = require('..');
-
-
-const internals = {};
-
-
-const { before, describe, it } = exports.lab = Lab.script();
-const expect = Code.expect;
-
-
-internals.uncapitalize = (str) => {
-
-    // Used capitalized classes like "Bench" and "Error"
-
-    return str[0].toLowerCase() + str.slice(1);
-};
-
-
-describe('ESM', () => {
-
-    let esmHoek;
-
-    before(async () => {
-
-        esmHoek = await import('@hapi/hoek');
-    });
-
-    it('exposes all methods and classes as named imports', () => {
-
-        const rlist = Object.keys(Hoek).sort();
-        const mlist = Object.keys(esmHoek).sort();
-
-        expect(mlist).to.equal(rlist);
-        expect(esmHoek).to.equal(Hoek);
-        expect(esmHoek).to.not.shallow.equal(Hoek);
-    });
-
-    it('exposes all methods and classes as direct imports', async () => {
-
-        const exported = await Promise.all(Object.keys(Hoek).map((item) => import(`@hapi/hoek/${internals.uncapitalize(item)}`)));
-        const defaulted = exported.map((item) => item.default);
-
-        expect(defaulted).to.equal(Object.values(Hoek));
-    });
-
-    it('can call an exported destructured method', () => {
-
-        const { assert } = esmHoek;
-
-        expect(() => assert(false, 'oops')).to.throw('oops');
-    });
-
-    it('exports identical classes as CJS', async () => {
-
-        const error = (await import(`@hapi/hoek/assertError`)).default;
-
-        expect(error).to.shallow.equal(Hoek.AssertError);
-        expect(error).to.shallow.equal(esmHoek.AssertError);
-    });
-});
-
-
-describe('package', () => {
-
-    it('exports all methods and classes', () => {
-
-        const exported = Object.keys(Hoek).map((item) => require(`@hapi/hoek/${internals.uncapitalize(item)}`));
-
-        expect(exported).to.equal(Object.values(Hoek));
-    });
-
-    it('can call an exported method', () => {
-
-        const assert = require(`@hapi/hoek/assert`);
-
-        expect(() => assert(false, 'oops')).to.throw('oops');
-    });
-
-    it('does not export unlisted modules', () => {
-
-        expect(() => require('@hapi/hoek/types')).to.throw();
-        expect(() => require('@hapi/hoek/utils')).to.throw();
-    });
-});
diff --git a/test/index.js b/test/index.js
deleted file mode 100755
index 4b45b842..00000000
--- a/test/index.js
+++ /dev/null
@@ -1,2523 +0,0 @@
-'use strict';
-
-const Util = require('util');
-
-const Code = require('@hapi/code');
-const Hoek = require('..');
-const Lab = require('@hapi/lab');
-
-
-const internals = {};
-
-
-const { describe, it } = exports.lab = Lab.script();
-const expect = Code.expect;
-
-
-const nestedObj = {
-    v: [7, 8, 9],
-    w: /^something$/igm,
-    x: {
-        a: [1, 2, 3],
-        b: 123456,
-        c: new Date(),
-        d: /hi/igm,
-        e: /hello/
-    },
-    y: 'y',
-    z: new Date(1378775452757)
-};
-
-
-describe('merge()', () => {
-
-    it('deep copies source items', () => {
-
-        const sym1 = Symbol('1');
-        const sym2 = Symbol('2');
-        const sym3 = Symbol('3');
-
-        const target = {
-            b: 3,
-            d: [],
-            [sym1]: true,
-            [sym3]: true
-        };
-
-        const source = {
-            c: {
-                d: 1
-            },
-            d: [{ e: 1 }],
-            [sym2]: true,
-            [sym3]: false
-        };
-
-        Hoek.merge(target, source);
-        expect(target.c).to.not.shallow.equal(source.c);
-        expect(target.c).to.equal(source.c);
-        expect(target.d).to.not.shallow.equal(source.d);
-        expect(target.d[0]).to.not.shallow.equal(source.d[0]);
-        expect(target.d).to.equal(source.d);
-
-        expect(target[sym1]).to.be.true();
-        expect(target[sym2]).to.be.true();
-        expect(target[sym3]).to.be.false();
-    });
-
-    it('deep copies source items without symbols', () => {
-
-        const sym1 = Symbol('1');
-        const sym2 = Symbol('2');
-        const sym3 = Symbol('3');
-
-        const target = {
-            b: 3,
-            d: [],
-            [sym1]: true,
-            [sym3]: true
-        };
-
-        const source = {
-            c: {
-                d: 1
-            },
-            d: [{ e: 1 }],
-            [sym2]: true,
-            [sym3]: false
-        };
-
-        Hoek.merge(target, source, { symbols: false });
-        expect(target.c).to.not.shallow.equal(source.c);
-        expect(target.c).to.equal(source.c);
-        expect(target.d).to.not.shallow.equal(source.d);
-        expect(target.d[0]).to.not.shallow.equal(source.d[0]);
-        expect(target.d).to.equal(source.d);
-
-        expect(target[sym1]).to.be.true();
-        expect(target[sym2]).to.not.exist();
-        expect(target[sym3]).to.be.true();
-    });
-
-    it('merges array over an object', () => {
-
-        const a = {
-            x: ['n', 'm']
-        };
-
-        const b = {
-            x: {
-                n: '1',
-                m: '2'
-            }
-        };
-
-        Hoek.merge(b, a);
-        expect(a.x[0]).to.equal('n');
-        expect(a.x.n).to.not.exist();
-    });
-
-    it('merges object over an array', () => {
-
-        const a = {
-            x: ['n', 'm']
-        };
-
-        const b = {
-            x: {
-                n: '1',
-                m: '2'
-            }
-        };
-
-        Hoek.merge(a, b);
-        expect(a.x.n).to.equal('1');
-        expect(a.x[0]).to.not.exist();
-    });
-
-    it('merges from null prototype objects', () => {
-
-        const a = {};
-
-        const b = Object.create(null);
-        b.x = true;
-
-        Hoek.merge(a, b);
-        expect(a.x).to.be.true();
-    });
-
-    it('skips non-enumerable properties', () => {
-
-        const a = { x: 0 };
-
-        const b = {};
-        Object.defineProperty(b, 'x', {
-            enumerable: false,
-            value: 1
-        });
-
-        Hoek.merge(a, b);
-        expect(a.x).to.equal(0);
-    });
-
-    it('does not throw if source is null', () => {
-
-        const a = {};
-        const b = null;
-        let c = null;
-
-        expect(() => {
-
-            c = Hoek.merge(a, b);
-        }).to.not.throw();
-
-        expect(c).to.equal(a);
-    });
-
-    it('does not throw if source is undefined', () => {
-
-        const a = {};
-        const b = undefined;
-        let c = null;
-
-        expect(() => {
-
-            c = Hoek.merge(a, b);
-        }).to.not.throw();
-
-        expect(c).to.equal(a);
-    });
-
-    it('throws if source is not an object', () => {
-
-        expect(() => {
-
-            const a = {};
-            const b = 0;
-
-            Hoek.merge(a, b);
-        }).to.throw('Invalid source value: must be null, undefined, or an object');
-    });
-
-    it('throws if target is not an object', () => {
-
-        expect(() => {
-
-            const a = 0;
-            const b = {};
-
-            Hoek.merge(a, b);
-        }).to.throw('Invalid target value: must be an object');
-    });
-
-    it('throws if target is not an array and source is', () => {
-
-        expect(() => {
-
-            const a = {};
-            const b = [1, 2];
-
-            Hoek.merge(a, b);
-        }).to.throw('Cannot merge array onto an object');
-    });
-
-    it('returns the same object when merging arrays', () => {
-
-        const a = [];
-        const b = [1, 2];
-
-        expect(Hoek.merge(a, b)).to.equal(a);
-    });
-
-    it('combines an empty object with a non-empty object', () => {
-
-        const a = {};
-        const b = nestedObj;
-
-        const c = Hoek.merge(a, b);
-        expect(a).to.equal(b);
-        expect(c).to.equal(b);
-    });
-
-    it('overrides values in target', () => {
-
-        const a = { x: 1, y: 2, z: 3, v: 5, t: 'test', s: 1, m: 'abc' };
-        const b = { x: null, z: 4, v: 0, t: { u: 6 }, s: undefined, m: '123' };
-
-        const c = Hoek.merge(a, b);
-        expect(c.x).to.equal(null);
-        expect(c.y).to.equal(2);
-        expect(c.z).to.equal(4);
-        expect(c.v).to.equal(0);
-        expect(c.m).to.equal('123');
-        expect(c.t).to.equal({ u: 6 });
-        expect(c.s).to.equal(undefined);
-    });
-
-    it('overrides values in target (flip)', () => {
-
-        const a = { x: 1, y: 2, z: 3, v: 5, t: 'test', s: 1, m: 'abc' };
-        const b = { x: null, z: 4, v: 0, t: { u: 6 }, s: undefined, m: '123' };
-
-        const d = Hoek.merge(b, a);
-        expect(d.x).to.equal(1);
-        expect(d.y).to.equal(2);
-        expect(d.z).to.equal(3);
-        expect(d.v).to.equal(5);
-        expect(d.m).to.equal('abc');
-        expect(d.t).to.equal('test');
-        expect(d.s).to.equal(1);
-    });
-
-    it('retains Date properties', () => {
-
-        const a = { x: new Date(1378776452757) };
-
-        const b = Hoek.merge({}, a);
-        expect(a.x.getTime()).to.equal(b.x.getTime());
-    });
-
-    it('retains Date properties when merging keys', () => {
-
-        const a = { x: new Date(1378776452757) };
-
-        const b = Hoek.merge({ x: {} }, a);
-        expect(a.x.getTime()).to.equal(b.x.getTime());
-    });
-
-    it('overrides Buffer', () => {
-
-        const a = { x: Buffer.from('abc') };
-
-        Hoek.merge({ x: {} }, a);
-        expect(a.x.toString()).to.equal('abc');
-    });
-
-    it('overrides RegExp', () => {
-
-        const a = { x: /test/ };
-
-        Hoek.merge({ x: {} }, a);
-        expect(a.x).to.equal(/test/);
-    });
-
-    it('overrides Symbol properties', () => {
-
-        const sym = Symbol();
-        const a = { [sym]: 1 };
-
-        Hoek.merge({ [sym]: {} }, a);
-        expect(a[sym]).to.equal(1);
-    });
-
-    it('skips __proto__', () => {
-
-        const a = '{ "ok": "value", "__proto__": { "test": "value" } }';
-
-        const b = Hoek.merge({}, JSON.parse(a));
-        expect(b).to.equal({ ok: 'value' });
-        expect(b.test).to.equal(undefined);
-    });
-});
-
-describe('applyToDefaults()', () => {
-
-    it('throws when target is null', () => {
-
-        expect(() => {
-
-            Hoek.applyToDefaults(null, {});
-        }).to.throw('Invalid defaults value: must be an object');
-    });
-
-    it('throws when options are invalid', () => {
-
-        expect(() => {
-
-            Hoek.applyToDefaults({}, {}, false);
-        }).to.throw('Invalid options: must be an object');
-
-        expect(() => {
-
-            Hoek.applyToDefaults({}, {}, 123);
-        }).to.throw('Invalid options: must be an object');
-    });
-
-    it('returns null if source is false', () => {
-
-        const defaults = {
-            a: 1,
-            b: 2,
-            c: {
-                d: 3,
-                e: [5, 6]
-            },
-            f: 6,
-            g: 'test'
-        };
-
-        const result = Hoek.applyToDefaults(defaults, false);
-        expect(result).to.equal(null);
-    });
-
-    it('returns null if source is null', () => {
-
-        const defaults = {
-            a: 1,
-            b: 2,
-            c: {
-                d: 3,
-                e: [5, 6]
-            },
-            f: 6,
-            g: 'test'
-        };
-
-        const result = Hoek.applyToDefaults(defaults, null);
-        expect(result).to.equal(null);
-    });
-
-    it('returns null if source is undefined', () => {
-
-        const defaults = {
-            a: 1,
-            b: 2,
-            c: {
-                d: 3,
-                e: [5, 6]
-            },
-            f: 6,
-            g: 'test'
-        };
-
-        const result = Hoek.applyToDefaults(defaults, undefined);
-        expect(result).to.equal(null);
-    });
-
-    it('returns a copy of defaults if source is true', () => {
-
-        const defaults = {
-            a: 1,
-            b: 2,
-            c: {
-                d: 3,
-                e: [5, 6]
-            },
-            f: 6,
-            g: 'test'
-        };
-
-        const result = Hoek.applyToDefaults(defaults, true);
-        expect(result).to.equal(defaults);
-    });
-
-    it('applies object to defaults', () => {
-
-        const defaults = {
-            a: 1,
-            b: 2,
-            c: {
-                d: 3,
-                e: [5, 6]
-            },
-            f: 6,
-            g: 'test'
-        };
-
-        const obj = {
-            a: null,
-            c: {
-                e: [4]
-            },
-            f: 0,
-            g: {
-                h: 5
-            }
-        };
-
-        const result = Hoek.applyToDefaults(defaults, obj);
-        expect(result.c.e).to.equal([4]);
-        expect(result.a).to.equal(1);
-        expect(result.b).to.equal(2);
-        expect(result.f).to.equal(0);
-        expect(result.g).to.equal({ h: 5 });
-    });
-
-    it('applies object to defaults with null', () => {
-
-        const defaults = {
-            a: 1,
-            b: 2,
-            c: {
-                d: 3,
-                e: [5, 6]
-            },
-            f: 6,
-            g: 'test'
-        };
-
-        const obj = {
-            a: null,
-            c: {
-                e: [4]
-            },
-            f: 0,
-            g: {
-                h: 5
-            }
-        };
-
-        const result = Hoek.applyToDefaults(defaults, obj, { nullOverride: true });
-        expect(result.c.e).to.equal([4]);
-        expect(result.a).to.equal(null);
-        expect(result.b).to.equal(2);
-        expect(result.f).to.equal(0);
-        expect(result.g).to.equal({ h: 5 });
-    });
-
-    it('shallow copies the listed keys from source without merging', () => {
-
-        const defaults = {
-            a: {
-                b: 5,
-                e: 3
-            },
-            c: {
-                d: 7,
-                g: 1
-            }
-        };
-
-        const source = {
-            a: {
-                b: 4
-            },
-            c: {
-                d: 6,
-                f: 7
-            }
-        };
-
-        const merged = Hoek.applyToDefaults(defaults, source, { shallow: ['a'] });
-        expect(merged).to.equal({ a: { b: 4 }, c: { d: 6, g: 1, f: 7 } });
-        expect(merged.a).to.shallow.equal(source.a);
-        expect(merged.a).to.not.equal(defaults.a);
-        expect(merged.c).to.not.equal(source.c);
-        expect(merged.c).to.not.equal(defaults.c);
-    });
-
-    it('shallow copies the nested keys (override)', () => {
-
-        const defaults = {
-            a: {
-                b: 5
-            },
-            c: {
-                d: 7,
-                g: 1
-            }
-        };
-
-        const source = {
-            a: {
-                b: 4
-            },
-            c: {
-                d: 6,
-                g: {
-                    h: 8
-                }
-            }
-        };
-
-        const merged = Hoek.applyToDefaults(defaults, source, { shallow: ['c.g'] });
-        expect(merged).to.equal({ a: { b: 4 }, c: { d: 6, g: { h: 8 } } });
-        expect(merged.c.g).to.shallow.equal(source.c.g);
-    });
-
-    it('shallow copies the nested keys (missing)', () => {
-
-        const defaults = {
-            a: {
-                b: 5
-            }
-        };
-
-        const source = {
-            a: {
-                b: 4
-            },
-            c: {
-                g: {
-                    h: 8
-                }
-            }
-        };
-
-        const merged = Hoek.applyToDefaults(defaults, source, { shallow: ['c.g'] });
-        expect(merged).to.equal({ a: { b: 4 }, c: { g: { h: 8 } } });
-        expect(merged.c.g).to.shallow.equal(source.c.g);
-    });
-
-    it('shallow copies the nested keys (override)', () => {
-
-        const defaults = {
-            a: {
-                b: 5
-            },
-            c: {
-                g: {
-                    d: 7
-                }
-            }
-        };
-
-        const source = {
-            a: {
-                b: 4
-            },
-            c: {
-                g: {
-                    h: 8
-                }
-            }
-        };
-
-        const merged = Hoek.applyToDefaults(defaults, source, { shallow: ['c.g'] });
-        expect(merged).to.equal({ a: { b: 4 }, c: { g: { h: 8 } } });
-        expect(merged.c.g).to.shallow.equal(source.c.g);
-    });
-
-    it('shallow copies the nested keys (deeper)', () => {
-
-        const defaults = {
-            a: {
-                b: 5
-            }
-        };
-
-        const source = {
-            a: {
-                b: 4
-            },
-            c: {
-                g: {
-                    r: {
-                        h: 8
-                    }
-                }
-            }
-        };
-
-        const merged = Hoek.applyToDefaults(defaults, source, { shallow: ['c.g.r'] });
-        expect(merged).to.equal({ a: { b: 4 }, c: { g: { r: { h: 8 } } } });
-        expect(merged.c.g.r).to.shallow.equal(source.c.g.r);
-    });
-
-    it('shallow copies the nested keys (not present)', () => {
-
-        const defaults = {
-            a: {
-                b: 5
-            }
-        };
-
-        const source = {
-            a: {
-                b: 4
-            },
-            c: {
-                g: {
-                    r: {
-                        h: 8
-                    }
-                }
-            }
-        };
-
-        const merged = Hoek.applyToDefaults(defaults, source, { shallow: ['x.y'] });
-        expect(merged).to.equal({ a: { b: 4 }, c: { g: { r: { h: 8 } } } });
-    });
-
-    it('shallow copies the nested keys (non-object)', () => {
-
-        const defaults = {
-            // All falsy values:
-            _undefined: {
-                a: 1
-            },
-            _null: {
-                a: 2
-            },
-            _false: {
-                a: 3
-            },
-            _emptyString: {
-                a: 4
-            },
-            _zero: {
-                a: 5
-            },
-            _NaN: {
-                a: 6
-            },
-            // Other non-object values:
-            _string: {
-                a: 7
-            },
-            _number: {
-                a: 8
-            },
-            _true: {
-                a: 9
-            },
-            _function: {
-                a: 10
-            }
-        };
-
-        const source = {
-            _undefined: undefined,
-            _null: null,
-            _false: false,
-            _emptyString: '',
-            _zero: 0,
-            _NaN: NaN,
-            _string: 'foo',
-            _number: 42,
-            _true: true,
-            _function: () => {}
-        };
-
-        const merged = Hoek.applyToDefaults(defaults, source, { shallow: [
-            '_undefined.a',
-            '_null.a',
-            '_false.a',
-            '_emptyString.a',
-            '_zero.a',
-            '_NaN.a',
-            '_string.a',
-            '_number.a',
-            '_true.a',
-            '_function.a'
-        ] });
-        expect(merged).to.equal({
-            _undefined: { a: 1 },
-            _null: { a: 2 },
-            _false: false,
-            _emptyString: '',
-            _zero: 0,
-            _NaN: NaN,
-            _string: 'foo',
-            _number: 42,
-            _true: true,
-            _function: source._function
-        });
-    });
-
-    it('shallow copies the listed keys in the defaults', () => {
-
-        const defaults = {
-            a: {
-                b: 1
-            }
-        };
-
-        const merged = Hoek.applyToDefaults(defaults, {}, { shallow: ['a'] });
-        expect(merged.a).to.shallow.equal(defaults.a);
-    });
-
-    it('shallow copies the listed keys in the defaults (true)', () => {
-
-        const defaults = {
-            a: {
-                b: 1
-            }
-        };
-
-        const merged = Hoek.applyToDefaults(defaults, true, { shallow: ['a'] });
-        expect(merged.a).to.shallow.equal(defaults.a);
-    });
-
-    it('returns null on false', () => {
-
-        const defaults = {
-            a: {
-                b: 1
-            }
-        };
-
-        const merged = Hoek.applyToDefaults(defaults, false, { shallow: ['a'] });
-        expect(merged).to.equal(null);
-    });
-
-    it('handles missing shallow key in defaults', () => {
-
-        const defaults = {
-            a: {
-                b: 1
-            }
-        };
-
-        const options = {
-            a: {
-                b: 4
-            },
-            c: {
-                d: 2
-            }
-        };
-
-        const merged = Hoek.applyToDefaults(defaults, options, { shallow: ['c'] });
-        expect(merged).to.equal({ a: { b: 4 }, c: { d: 2 } });
-        expect(merged.c).to.shallow.equal(options.c);
-
-        expect(Hoek.applyToDefaults(defaults, true, { shallow: ['c'] })).to.equal({ a: { b: 1 } });
-    });
-
-    it('throws on missing defaults', () => {
-
-        expect(() => Hoek.applyToDefaults(null, {}, { shallow: ['a'] })).to.throw('Invalid defaults value: must be an object');
-    });
-
-    it('throws on invalid defaults', () => {
-
-        expect(() => Hoek.applyToDefaults('abc', {}, { shallow: ['a'] })).to.throw('Invalid defaults value: must be an object');
-    });
-
-    it('throws on invalid source', () => {
-
-        expect(() => Hoek.applyToDefaults({}, 'abc', { shallow: ['a'] })).to.throw('Invalid source value: must be true, falsy or an object');
-    });
-
-    it('throws on missing keys', () => {
-
-        expect(() => Hoek.applyToDefaults({}, true, { shallow: 123 })).to.throw('Invalid keys');
-    });
-
-    it('handles array keys', () => {
-
-        const sym = Symbol();
-
-        const defaults = {
-            a: {
-                b: 5,
-                e: 3
-            },
-            c: {
-                d: 7,
-                [sym]: {
-                    f: 9
-                }
-            }
-        };
-
-        const options = {
-            a: {
-                b: 4
-            },
-            c: {
-                d: 6,
-                [sym]: {
-                    g: 1
-                }
-            }
-        };
-
-        const merged = Hoek.applyToDefaults(defaults, options, { shallow: [['c', sym]] });
-        expect(merged).to.equal({ a: { b: 4, e: 3 }, c: { d: 6, [sym]: { g: 1 } } });
-        expect(merged.c[sym]).to.shallow.equal(options.c[sym]);
-    });
-
-    it('does not modify shallow entries in source', () => {
-
-        const defaults = {
-            a: {
-                b: 5
-            }
-        };
-
-        const source = {};
-
-        Object.defineProperty(source, 'a', { value: { b: 4 } });
-
-        const merged = Hoek.applyToDefaults(defaults, source, { shallow: ['a'] });
-        expect(merged).to.equal({ a: { b: 4 } });
-        expect(merged.a).to.shallow.equal(source.a);
-        expect(merged.a).to.not.equal(defaults.a);
-    });
-
-    it('should respect nullOverride when shallow is used', () => {
-
-        const defaults = { host: 'localhost', port: 8000 };
-        const source = { host: null, port: 8080 };
-
-        const result = Hoek.applyToDefaults(defaults, source, { nullOverride: true, shallow: [] });
-        expect(result.host).to.equal(null);
-        expect(result.port).to.equal(8080);
-    });
-});
-
-describe('deepEqual()', () => {
-
-    it('compares identical references', () => {
-
-        const x = {};
-        expect(Hoek.deepEqual(x, x)).to.be.true();
-    });
-
-    it('compares simple values', () => {
-
-        expect(Hoek.deepEqual('x', 'x')).to.be.true();
-        expect(Hoek.deepEqual('x', 'y')).to.be.false();
-        expect(Hoek.deepEqual('x1', 'x')).to.be.false();
-        expect(Hoek.deepEqual(-0, +0)).to.be.false();
-        expect(Hoek.deepEqual(-0, -0)).to.be.true();
-        expect(Hoek.deepEqual(+0, +0)).to.be.true();
-        expect(Hoek.deepEqual(+0, -0)).to.be.false();
-        expect(Hoek.deepEqual(1, 1)).to.be.true();
-        expect(Hoek.deepEqual(0, 0)).to.be.true();
-        expect(Hoek.deepEqual(-1, 1)).to.be.false();
-        expect(Hoek.deepEqual(NaN, 0)).to.be.false();
-        expect(Hoek.deepEqual(NaN, NaN)).to.be.true();
-    });
-
-    it('compares different types', () => {
-
-        expect(Hoek.deepEqual([], 5, { prototype: false })).to.be.false();
-        expect(Hoek.deepEqual(5, [], { prototype: false })).to.be.false();
-        expect(Hoek.deepEqual({}, null, { prototype: false })).to.be.false();
-        expect(Hoek.deepEqual(null, {}, { prototype: false })).to.be.false();
-        expect(Hoek.deepEqual('abc', {}, { prototype: false })).to.be.false();
-        expect(Hoek.deepEqual({}, 'abc', { prototype: false })).to.be.false();
-    });
-
-    it('compares empty structures', () => {
-
-        expect(Hoek.deepEqual([], [])).to.be.true();
-        expect(Hoek.deepEqual({}, {})).to.be.true();
-        expect(Hoek.deepEqual([], {})).to.be.false();
-        expect(Hoek.deepEqual([], {}, { prototype: false })).to.be.false();
-        expect(Hoek.deepEqual({}, [], { prototype: false })).to.be.false();
-    });
-
-    it('compares empty arguments object', () => {
-
-        const compare = function () {
-
-            expect(Hoek.deepEqual([], arguments)).to.be.false();            // eslint-disable-line prefer-rest-params
-        };
-
-        compare();
-    });
-
-    it('compares empty arguments objects', () => {
-
-        const compare = function () {
-
-            const arg1 = arguments;                                         // eslint-disable-line prefer-rest-params
-
-            const inner = function () {
-
-                // callee is not supported in strict mode, was previously false becuse callee was different
-                expect(Hoek.deepEqual(arg1, arguments)).to.be.true();       // eslint-disable-line prefer-rest-params
-            };
-
-            inner();
-        };
-
-        compare();
-    });
-
-    it('compares symbol object properties', () => {
-
-        const sym = Symbol();
-
-        const ne = {};
-        Object.defineProperty(ne, sym, { value: true });
-
-        expect(Hoek.deepEqual({ [sym]: { c: true } }, { [sym]: { c: true } })).to.be.true();
-        expect(Hoek.deepEqual({ [sym]: { c: true } }, { [sym]: { c: false } })).to.be.false();
-        expect(Hoek.deepEqual({ [sym]: { c: true } }, { [sym]: true })).to.be.false();
-        expect(Hoek.deepEqual({ [sym]: undefined }, { [sym]: undefined })).to.be.true();
-        expect(Hoek.deepEqual({ [sym]: undefined }, {})).to.be.false();
-        expect(Hoek.deepEqual({}, { [sym]: undefined })).to.be.false();
-
-        expect(Hoek.deepEqual({}, ne)).to.be.true();
-        expect(Hoek.deepEqual(ne, {})).to.be.true();
-        expect(Hoek.deepEqual({ [sym]: true }, ne)).to.be.false();
-        expect(Hoek.deepEqual(ne, { [sym]: true })).to.be.false();
-        expect(Hoek.deepEqual(ne, { [Symbol()]: undefined })).to.be.false();
-
-        expect(Hoek.deepEqual({ [sym]: true }, { [sym]: true })).to.be.true();
-        expect(Hoek.deepEqual({ [sym]: true }, {})).to.be.false();
-        expect(Hoek.deepEqual({ [sym]: true }, {}, { symbols: false })).to.be.true();
-    });
-
-    it('compares dates', () => {
-
-        expect(Hoek.deepEqual(new Date(2015, 1, 1), new Date('2015/02/01'))).to.be.true();
-        expect(Hoek.deepEqual(new Date(100), new Date(101))).to.be.false();
-        expect(Hoek.deepEqual(new Date(), {})).to.be.false();
-        expect(Hoek.deepEqual(new Date(2015, 1, 1), new Date('2015/02/01'), { prototype: false })).to.be.true();
-        expect(Hoek.deepEqual(new Date(), {}, { prototype: false })).to.be.false();
-        expect(Hoek.deepEqual({}, new Date(), { prototype: false })).to.be.false();
-    });
-
-    it('compares regular expressions', () => {
-
-        expect(Hoek.deepEqual(/\s/, new RegExp('\\\s'))).to.be.true();
-        expect(Hoek.deepEqual(/\s/g, /\s/g)).to.be.true();
-        expect(Hoek.deepEqual(/a/, {}, { prototype: false })).to.be.false();
-        expect(Hoek.deepEqual(/\s/g, /\s/i)).to.be.false();
-        expect(Hoek.deepEqual(/a/g, /b/g)).to.be.false();
-    });
-
-    it('compares errors', () => {
-
-        expect(Hoek.deepEqual(new Error('a'), new Error('a'))).to.be.true();
-        expect(Hoek.deepEqual(new Error('a'), new Error('b'))).to.be.false();
-
-        expect(Hoek.deepEqual(new Error('a'), new TypeError('a'))).to.be.false();
-        expect(Hoek.deepEqual(new Error('a'), new TypeError('a'), { prototype: false })).to.be.false();
-
-        expect(Hoek.deepEqual(new Error(), {})).to.be.false();
-        expect(Hoek.deepEqual(new Error(), {}, { prototype: false })).to.be.false();
-
-        expect(Hoek.deepEqual({}, new Error())).to.be.false();
-        expect(Hoek.deepEqual({}, new Error(), { prototype: false })).to.be.false();
-
-        const error = new Error('a');
-        expect(Hoek.deepEqual(Hoek.clone(error), error)).to.be.true();
-        expect(Hoek.deepEqual(Hoek.clone(error), error, { prototype: false })).to.be.true();
-    });
-
-    it('compares arrays', () => {
-
-        expect(Hoek.deepEqual([[1]], [[1]])).to.be.true();
-        expect(Hoek.deepEqual([1, 2, 3], [1, 2, 3])).to.be.true();
-        expect(Hoek.deepEqual([1, 2, 3], [1, 3, 2])).to.be.false();
-        expect(Hoek.deepEqual([1, 2, 3], [1, 2])).to.be.false();
-        expect(Hoek.deepEqual([1], [1])).to.be.true();
-        const item1 = { key: 'value1' };
-        const item2 = { key: 'value2' };
-        expect(Hoek.deepEqual([item1, item1], [item1, item2])).to.be.false();
-    });
-
-    it('compares sets', () => {
-
-        expect(Hoek.deepEqual(new Set(), new Set())).to.be.true();
-        expect(Hoek.deepEqual(new Set([1]), new Set([1]))).to.be.true();
-        expect(Hoek.deepEqual(new Set([]), new Set([]))).to.be.true();
-        expect(Hoek.deepEqual(new Set([1, 2, 3]), new Set([1, 2, 3]))).to.be.true();
-        expect(Hoek.deepEqual(new Set([1, 2, 3]), new Set([3, 2, 1]))).to.be.true();
-        expect(Hoek.deepEqual(new Set([1, 2, 3]), new Set([1, 2, 4]))).to.be.false();
-        expect(Hoek.deepEqual(new Set([1, 2, 3]), new Set([1, 2]))).to.be.false();
-        expect(Hoek.deepEqual(new Set([1, 2, 1]), new Set([1, 2]))).to.be.true();
-        expect(Hoek.deepEqual(new Set([+0]), new Set([-0]))).to.be.true();
-        expect(Hoek.deepEqual(new Set([NaN]), new Set([NaN]))).to.be.true();
-        expect(Hoek.deepEqual(new Set([1, {}]), new Set([1, {}]))).to.be.true();
-        expect(Hoek.deepEqual(new Set([1, {}]), new Set([{}, 1]))).to.be.true();
-        expect(Hoek.deepEqual(new Set([1, {}, {}]), new Set([{}, 1, {}]))).to.be.true();
-        expect(Hoek.deepEqual(new Set([1, { a: 1 }]), new Set([{ a: 0 }, 1]))).to.be.false();
-        expect(Hoek.deepEqual(new WeakSet(), new WeakSet())).to.be.true();
-        const obj = {};
-        expect(Hoek.deepEqual(new WeakSet([obj]), new WeakSet())).to.be.true();
-        expect(Hoek.deepEqual(new WeakSet(), new Set()), { prototype: false }).to.be.false();
-
-        const sets = [new Set(), new Set()].map((set) => {
-
-            set.modified = true;
-            return set;
-        });
-        expect(Hoek.deepEqual(sets[0], sets[1])).to.be.true();
-        expect(Hoek.deepEqual(sets[0], new Set())).to.be.false();
-    });
-
-    it('compares extended sets', () => {
-
-        class PrivateSet extends Set {
-
-            has() {
-
-                throw new Error('not allowed');
-            }
-        }
-
-        const entries = ['a', undefined];
-        expect(Hoek.deepEqual(new PrivateSet(), new PrivateSet())).to.be.true();
-        expect(Hoek.deepEqual(new PrivateSet(entries), new PrivateSet(entries))).to.be.true();
-        expect(Hoek.deepEqual(new PrivateSet(entries), new Set(entries), { prototype: false })).to.be.true();
-        expect(Hoek.deepEqual(new PrivateSet(entries), new Set(entries), { prototype: true })).to.be.false();
-        expect(Hoek.deepEqual(new PrivateSet(), new PrivateSet(entries))).to.be.false();
-        expect(Hoek.deepEqual(new PrivateSet(entries), new PrivateSet())).to.be.false();
-
-        class LockableSet extends Set {
-
-            constructor(values, locked = true) {
-
-                super(values);
-                this.locked = locked;
-            }
-
-            has() {
-
-                if (this.locked) {
-                    throw new Error('not allowed');
-                }
-            }
-        }
-
-        expect(Hoek.deepEqual(new LockableSet(), new LockableSet())).to.be.true();
-        expect(Hoek.deepEqual(new LockableSet(entries), new LockableSet(entries))).to.be.true();
-        expect(Hoek.deepEqual(new LockableSet(entries, false), new LockableSet(entries, false))).to.be.true();
-        expect(Hoek.deepEqual(new LockableSet(entries, true), new LockableSet(entries, false))).to.be.false();
-        expect(Hoek.deepEqual(new LockableSet(entries, false), new LockableSet(entries, true))).to.be.false();
-        expect(Hoek.deepEqual(new LockableSet(entries), new Set(entries), { prototype: false })).to.be.false();
-        expect(Hoek.deepEqual(new LockableSet(entries), new PrivateSet(entries), { prototype: false })).to.be.false();
-    });
-
-    it('compares maps', () => {
-
-        const item1 = { key: 'value1' };
-        const item2 = { key: 'value2' };
-        expect(Hoek.deepEqual(new Map(), new Map())).to.be.true();
-        expect(Hoek.deepEqual(new Map([[1, {}]]), new Map([[1, {}]]))).to.be.true();
-        expect(Hoek.deepEqual(new Map([[1, item1]]), new Map([[1, item1]]))).to.be.true();
-        expect(Hoek.deepEqual(new Map([[1, item1]]), new Map([[1, item2]]))).to.be.false();
-        expect(Hoek.deepEqual(new Map([[1, undefined]]), new Map([[1, undefined]]))).to.be.true();
-        expect(Hoek.deepEqual(new Map([[1, undefined]]), new Map([[2, undefined]]))).to.be.false();
-        expect(Hoek.deepEqual(new Map([[1, {}]]), new Map([[1, {}], [2, {}]]))).to.be.false();
-        expect(Hoek.deepEqual(new Map([[item1, 1]]), new Map([[item1, 1]]))).to.be.true();
-        expect(Hoek.deepEqual(new Map([[{}, 1]]), new Map([[{}, 1]]))).to.be.false();
-        expect(Hoek.deepEqual(new WeakMap(), new WeakMap())).to.be.true();
-        expect(Hoek.deepEqual(new WeakMap([[item1, 1]]), new WeakMap())).to.be.true();
-        expect(Hoek.deepEqual(new WeakMap(), new Map()), { prototype: false }).to.be.false();
-
-        const maps = [new Map(), new Map()].map((map) => {
-
-            map.modified = true;
-            return map;
-        });
-        expect(Hoek.deepEqual(maps[0], maps[1])).to.be.true();
-        expect(Hoek.deepEqual(maps[0], new Map())).to.be.false();
-    });
-
-    it('compares extended maps', () => {
-
-        class PrivateMap extends Map {
-
-            get() {
-
-                throw new Error('not allowed');
-            }
-        }
-
-        const entries = [['a', 1], ['b', undefined]];
-        expect(Hoek.deepEqual(new PrivateMap(), new PrivateMap())).to.be.true();
-        expect(Hoek.deepEqual(new PrivateMap(entries), new PrivateMap(entries))).to.be.true();
-        expect(Hoek.deepEqual(new PrivateMap(entries), new Map(entries), { prototype: false })).to.be.true();
-        expect(Hoek.deepEqual(new PrivateMap(entries), new Map(entries), { prototype: true })).to.be.false();
-        expect(Hoek.deepEqual(new PrivateMap(), new PrivateMap(entries))).to.be.false();
-        expect(Hoek.deepEqual(new PrivateMap(entries), new PrivateMap())).to.be.false();
-
-        class LockableMap extends Map {
-
-            constructor(kvs, locked = true) {
-
-                super(kvs);
-                this.locked = locked;
-            }
-
-            get() {
-
-                if (this.locked) {
-                    throw new Error('not allowed');
-                }
-            }
-        }
-
-        expect(Hoek.deepEqual(new LockableMap(), new LockableMap())).to.be.true();
-        expect(Hoek.deepEqual(new LockableMap(entries), new LockableMap(entries))).to.be.true();
-        expect(Hoek.deepEqual(new LockableMap(entries, false), new LockableMap(entries, false))).to.be.true();
-        expect(Hoek.deepEqual(new LockableMap(entries, true), new LockableMap(entries, false))).to.be.false();
-        expect(Hoek.deepEqual(new LockableMap(entries, false), new LockableMap(entries, true))).to.be.false();
-        expect(Hoek.deepEqual(new LockableMap(entries), new Map(entries), { prototype: false })).to.be.false();
-        expect(Hoek.deepEqual(new LockableMap(entries), new PrivateMap(entries), { prototype: false })).to.be.false();
-    });
-
-    it('compares promises', () => {
-
-        const a = new Promise(() => { });
-
-        expect(Hoek.deepEqual(a, a)).to.be.true();
-        expect(Hoek.deepEqual(a, new Promise(() => { }))).to.be.false();
-    });
-
-    it('compares urls', () => {
-
-        const a = new URL('https://hapi.dev/');
-
-        expect(Hoek.deepEqual(a, a)).to.be.true();
-        expect(Hoek.deepEqual(a, new URL('https://hapi.dev/?new'))).to.be.false();
-        expect(Hoek.deepEqual(a, {}, { prototype: false })).to.be.false();
-    });
-
-    it('compares buffers', () => {
-
-        expect(Hoek.deepEqual(Buffer.from([1, 2, 3]), Buffer.from([1, 2, 3]))).to.be.true();
-        expect(Hoek.deepEqual(Buffer.from([1, 2, 3]), Buffer.from([1, 3, 2]))).to.be.false();
-        expect(Hoek.deepEqual(Buffer.from([1, 2, 3]), Buffer.from([1, 2]))).to.be.false();
-        expect(Hoek.deepEqual(Buffer.from([1, 2, 3]), {})).to.be.false();
-        expect(Hoek.deepEqual(Buffer.from([1, 2, 3]), [1, 2, 3])).to.be.false();
-    });
-
-    it('compares string objects', () => {
-
-        /* eslint-disable no-new-wrappers */
-        expect(Hoek.deepEqual(new String('a'), new String('a'))).to.be.true();
-        expect(Hoek.deepEqual(new String('a'), new String('b'))).to.be.false();
-        expect(Hoek.deepEqual(new String(''), {}, { prototype: false })).to.be.false();
-        expect(Hoek.deepEqual({}, new String(''), { prototype: false })).to.be.false();
-        expect(Hoek.deepEqual(new String('a'), 'a', { prototype: false })).to.be.false();
-        expect(Hoek.deepEqual('a', new String('a'), { prototype: false })).to.be.false();
-        /* eslint-enable no-new-wrappers */
-    });
-
-    it('compares number objects', () => {
-
-        /* eslint-disable no-new-wrappers */
-        expect(Hoek.deepEqual(new Number(1), new Number(1))).to.be.true();
-        expect(Hoek.deepEqual(new Number(1), new Number(2))).to.be.false();
-        expect(Hoek.deepEqual(new Number(+0), new Number(-0))).to.be.false();
-        expect(Hoek.deepEqual(new Number(NaN), new Number(NaN))).to.be.true();
-        expect(Hoek.deepEqual(new Number(0), {}, { prototype: false })).to.be.false();
-        expect(Hoek.deepEqual({}, new Number(0), { prototype: false })).to.be.false();
-        expect(Hoek.deepEqual(new Number(1), 1, { prototype: false })).to.be.false();
-        expect(Hoek.deepEqual(1, new Number(1), { prototype: false })).to.be.false();
-        /* eslint-enable no-new-wrappers */
-    });
-
-    it('compares boolean objects', () => {
-
-        /* eslint-disable no-new-wrappers */
-        expect(Hoek.deepEqual(new Boolean(true), new Boolean(true))).to.be.true();
-        expect(Hoek.deepEqual(new Boolean(true), new Boolean(false))).to.be.false();
-        expect(Hoek.deepEqual(new Boolean(false), {}, { prototype: false })).to.be.false();
-        expect(Hoek.deepEqual({}, new Boolean(false), { prototype: false })).to.be.false();
-        expect(Hoek.deepEqual(new Boolean(true), true, { prototype: false })).to.be.false();
-        expect(Hoek.deepEqual(true, new Boolean(true), { prototype: false })).to.be.false();
-        /* eslint-enable no-new-wrappers */
-    });
-
-    it('compares objects', () => {
-
-        expect(Hoek.deepEqual({ a: 1, b: 2, c: 3 }, { a: 1, b: 2, c: 3 })).to.be.true();
-        expect(Hoek.deepEqual({ foo: 'bar' }, { foo: 'baz' })).to.be.false();
-        expect(Hoek.deepEqual({ foo: { bar: 'foo' } }, { foo: { bar: 'baz' } })).to.be.false();
-        expect(Hoek.deepEqual({ foo: undefined }, {})).to.be.false();
-        expect(Hoek.deepEqual({}, { foo: undefined })).to.be.false();
-        expect(Hoek.deepEqual({ foo: undefined }, { bar: undefined })).to.be.false();
-    });
-
-    it('compares functions', () => {
-
-        const f1 = () => 1;
-        const f2 = () => 2;
-        const f2a = () => 2;
-
-        expect(Hoek.deepEqual({ f1 }, { f1 })).to.be.true();
-        expect(Hoek.deepEqual({ f1 }, { f1: f2 })).to.be.false();
-        expect(Hoek.deepEqual({ f2 }, { f2: f2a })).to.be.false();
-        expect(Hoek.deepEqual({ f2 }, { f2: f2a }, { deepFunction: true })).to.be.true();
-        expect(Hoek.deepEqual({ f2 }, { f2: f1 }, { deepFunction: true })).to.be.false();
-
-        const f3 = () => 3;
-        f3.x = 1;
-
-        const f3a = () => 3;
-        f3a.x = 1;
-
-        const f3b = () => 3;
-        f3b.x = 2;
-
-        expect(Hoek.deepEqual({ f3 }, { f3: f3a }, { deepFunction: true })).to.be.true();
-        expect(Hoek.deepEqual({ f3 }, { f3: f3b }, { deepFunction: true })).to.be.false();
-    });
-
-    it('skips keys', () => {
-
-        expect(Hoek.deepEqual({ a: 1, b: 2, c: 3 }, { a: 1, b: 2, c: 4 })).to.be.false();
-        expect(Hoek.deepEqual({ a: 1, b: 2, c: 3 }, { a: 1, b: 2, c: 4 }, { skip: ['c'] })).to.be.true();
-
-        expect(Hoek.deepEqual({ a: 1, b: 2, c: 3 }, { a: 1, b: 2 })).to.be.false();
-        expect(Hoek.deepEqual({ a: 1, b: 2, c: 3 }, { a: 1, b: 2 }, { skip: ['c'] })).to.be.true();
-
-        const sym = Symbol('test');
-        expect(Hoek.deepEqual({ a: 1, b: 2, [sym]: 3 }, { a: 1, b: 2, [sym]: 4 })).to.be.false();
-        expect(Hoek.deepEqual({ a: 1, b: 2, [sym]: 3 }, { a: 1, b: 2, [sym]: 4 }, { skip: [sym] })).to.be.true();
-
-        expect(Hoek.deepEqual({ a: 1, b: 2, [sym]: 3 }, { a: 1, b: 2 })).to.be.false();
-        expect(Hoek.deepEqual({ a: 1, b: 2, [sym]: 3 }, { a: 1, b: 2 }, { skip: [sym] })).to.be.true();
-        expect(Hoek.deepEqual({ a: 1, b: 2, [sym]: 3, [Symbol('other')]: true }, { a: 1, b: 2 }, { skip: [sym] })).to.be.false();
-
-        expect(Hoek.deepEqual({ a: 1, b: 2 }, { a: 1 }, { skip: ['a'] })).to.be.false();
-        expect(Hoek.deepEqual({ a: 1 }, { a: 1, b: 2 }, { skip: ['a'] })).to.be.false();
-    });
-
-    it('handles circular dependency', () => {
-
-        const a = {};
-        a.x = a;
-
-        const b = Hoek.clone(a);
-        expect(Hoek.deepEqual(a, b)).to.be.true();
-    });
-
-    it('handles obj only circular dependency', () => {
-
-        const a = {};
-        a.x = a;
-
-        const b = { x: {} };
-        expect(Hoek.deepEqual(a, b)).to.be.false();
-        expect(Hoek.deepEqual(b, a)).to.be.false();
-    });
-
-    it('handles irregular circular dependency', () => {
-
-        const a = {};
-        a.x = a;
-
-        const b = { x: {} };
-        b.x.x = b;
-
-        const c = { x: { x: {} } };
-        c.x.x.x = c;
-        expect(Hoek.deepEqual(a, b)).to.be.true();
-        expect(Hoek.deepEqual(b, a)).to.be.true();
-        expect(Hoek.deepEqual(a, c)).to.be.true();
-        expect(Hoek.deepEqual(b, c)).to.be.true();
-        expect(Hoek.deepEqual(c, a)).to.be.true();
-        expect(Hoek.deepEqual(c, b)).to.be.true();
-        b.x.y = 1;
-        expect(Hoek.deepEqual(a, b)).to.be.false();
-        expect(Hoek.deepEqual(b, a)).to.be.false();
-    });
-
-    it('handles cross circular dependency', () => {
-
-        const a = {};
-        const b = { x: {}, y: a };
-        b.x.x = b;
-        b.x.y = b.x;
-        a.x = b;
-        a.y = a;
-        expect(Hoek.deepEqual(b, a)).to.be.true();
-        expect(Hoek.deepEqual(a, b)).to.be.true();
-        b.x.y = 1;
-        expect(Hoek.deepEqual(b, a)).to.be.false();
-        expect(Hoek.deepEqual(a, b)).to.be.false();
-    });
-
-    it('handles reuse of objects', () => {
-
-        const date1 = { year: 2018, month: 1, day: 1 };
-        const date2 = { year: 2000, month: 1, day: 1 };
-
-        expect(Hoek.deepEqual({ start: date1, end: date1 }, { start: date1, end: date2 })).to.be.false();
-    });
-
-    it('handles valueOf() that throws', () => {
-
-        const throwing = class {
-
-            constructor(value) {
-
-                this.value = value;
-            }
-
-            valueOf() {
-
-                throw new Error('failed');
-            }
-        };
-
-        expect(Hoek.deepEqual(new throwing('a'), new throwing('a'))).to.be.true();
-        expect(Hoek.deepEqual(new throwing('a'), new throwing('b'))).to.be.false();
-        expect(Hoek.deepEqual(new throwing('a'), { value: 'a' }, { prototype: false })).to.be.false();
-        expect(Hoek.deepEqual({ value: 'a' }, new throwing('a'), { prototype: false })).to.be.false();
-    });
-
-    it('handles valueOf() that returns similar value', () => {
-
-        const identity = class {
-
-            constructor(value) {
-
-                this.value = value;
-            }
-
-            valueOf() {
-
-                return { value: this.value };
-            }
-        };
-
-        expect(Hoek.deepEqual(new identity('a'), new identity('a'))).to.be.true();
-        expect(Hoek.deepEqual(new identity('a'), new identity('b'))).to.be.false();
-        expect(Hoek.deepEqual(new identity('a'), { value: 'a' }, { prototype: true })).to.be.false();
-        expect(Hoek.deepEqual(new identity('a'), { value: 'a' }, { prototype: false })).to.be.true();
-        expect(Hoek.deepEqual({ value: 'a' }, new identity('a'), { prototype: true })).to.be.false();
-        expect(Hoek.deepEqual({ value: 'a' }, new identity('a'), { prototype: false })).to.be.true();
-    });
-
-    it('skips enumerable properties on prototype chain', () => {
-
-        const base = function (value, surprice) {
-
-            this.value = value;
-            if (surprice) {
-                this.surprice = surprice;
-            }
-        };
-
-        Object.defineProperty(base.prototype, 'enum', {
-            enumerable: true,
-            configurable: true,
-            value: true
-        });
-
-        expect('enum' in new base('a')).to.be.true();
-        expect(Hoek.deepEqual(new base('a'), new base('a'))).to.be.true();
-        expect(Hoek.deepEqual(new base('a'), new base('b'))).to.be.false();
-        expect(Hoek.deepEqual(new base('a'), { value: 'a' }, { prototype: false })).to.be.true();
-        expect(Hoek.deepEqual({ value: 'a' }, new base('a'), { prototype: false })).to.be.true();
-        expect(Hoek.deepEqual(new base('a', 1), { value: 'a', enum: true }, { prototype: false })).to.be.false();
-        expect(Hoek.deepEqual({ value: 'a', enum: true }, new base('a', 1), { prototype: false })).to.be.false();
-    });
-
-    it('skips non-enumerable properties', () => {
-
-        const base = function Base(value, surprice) {
-
-            this.value = value;
-            if (surprice) {
-                this.surprice = surprice;
-            }
-        };
-
-        const createObj = (...args) => {
-
-            const obj = new base(...args);
-
-            Object.defineProperty(obj, 'hidden', {
-                enumerable: false,
-                configurable: true,
-                value: true
-            });
-
-            return obj;
-        };
-
-        expect(Hoek.deepEqual(createObj('a'), createObj('a'))).to.be.true();
-        expect(Hoek.deepEqual(createObj('a'), createObj('b'))).to.be.false();
-        expect(Hoek.deepEqual(createObj('a'), { value: 'a' }, { prototype: false })).to.be.true();
-        expect(Hoek.deepEqual({ value: 'a' }, createObj('a'), { prototype: false })).to.be.true();
-        expect(Hoek.deepEqual(createObj('a', 1), { value: 'a', hidden: true }, { prototype: false })).to.be.false();
-        expect(Hoek.deepEqual({ value: 'a', hidden: true }, createObj('a', 1), { prototype: false })).to.be.false();
-    });
-
-    it('compares an object with property getter while executing it', () => {
-
-        const obj = {};
-        const value = 1;
-        let execCount = 0;
-
-        Object.defineProperty(obj, 'test', {
-            enumerable: true,
-            configurable: true,
-            get: function () {
-
-                ++execCount;
-                return value;
-            }
-        });
-
-        const copy = Hoek.clone(obj);
-        expect(Hoek.deepEqual(obj, copy)).to.be.true();
-        expect(execCount).to.equal(2);
-        expect(copy.test).to.equal(1);
-        expect(execCount).to.equal(3);
-    });
-
-    it('compares objects with property getters', () => {
-
-        const obj = {};
-        Object.defineProperty(obj, 'test', {
-            enumerable: true,
-            configurable: true,
-            get: function () {
-
-                return 1;
-            }
-        });
-
-        const ref = {};
-        Object.defineProperty(ref, 'test', {
-            enumerable: true,
-            configurable: true,
-            get: function () {
-
-                return 2;
-            }
-        });
-
-        expect(Hoek.deepEqual(obj, ref)).to.be.false();
-    });
-
-    it('compares object prototypes', () => {
-
-        const Obj = function () {
-
-            this.a = 5;
-        };
-
-        Obj.prototype.b = function () {
-
-            return this.a;
-        };
-
-        const Ref = function () {
-
-            this.a = 5;
-        };
-
-        Ref.prototype.b = function () {
-
-            return this.a;
-        };
-
-        expect(Hoek.deepEqual(new Obj(), new Ref())).to.be.false();
-        expect(Hoek.deepEqual(new Obj(), new Obj())).to.be.true();
-        expect(Hoek.deepEqual(new Ref(), new Ref())).to.be.true();
-    });
-
-    it('compares plain objects', () => {
-
-        const a = Object.create(null);
-        const b = Object.create(null);
-
-        a.b = 'c';
-        b.b = 'c';
-
-        expect(Hoek.deepEqual(a, b)).to.be.true();
-        expect(Hoek.deepEqual(a, { b: 'c' })).to.be.false();
-    });
-
-    it('compares an object with an empty object', () => {
-
-        const a = { a: 1, b: 2 };
-
-        expect(Hoek.deepEqual({}, a)).to.be.false();
-        expect(Hoek.deepEqual(a, {})).to.be.false();
-    });
-
-    it('compares an object ignoring the prototype', () => {
-
-        const a = Object.create(null);
-        const b = {};
-
-        expect(Hoek.deepEqual(a, b, { prototype: false })).to.be.true();
-    });
-
-    it('compares an object ignoring the prototype recursively', () => {
-
-        const a = [Object.create(null)];
-        const b = [{}];
-
-        expect(Hoek.deepEqual(a, b, { prototype: false })).to.be.true();
-    });
-});
-
-describe('intersect()', () => {
-
-    it('returns the common objects of two arrays', () => {
-
-        const array1 = [1, 2, 3, 4, 4, 5, 5];
-        const array2 = [5, 4, 5, 6, 7];
-        const common = Hoek.intersect(array1, array2);
-        expect(common).to.equal([5, 4]);
-    });
-
-    it('returns the common objects of array and set', () => {
-
-        const array1 = new Set([1, 2, 3, 4, 4, 5, 5]);
-        const array2 = [5, 4, 5, 6, 7];
-        const common = Hoek.intersect(array1, array2);
-        expect(common).to.equal([5, 4]);
-    });
-
-    it('returns the common objects of set and array', () => {
-
-        const array1 = [1, 2, 3, 4, 4, 5, 5];
-        const array2 = new Set([5, 4, 5, 6, 7]);
-        const common = Hoek.intersect(array1, array2);
-        expect(common).to.equal([5, 4]);
-    });
-
-    it('returns the common objects of two sets', () => {
-
-        const array1 = new Set([1, 2, 3, 4, 4, 5, 5]);
-        const array2 = new Set([5, 4, 5, 6, 7]);
-        const common = Hoek.intersect(array1, array2);
-        expect(common).to.equal([5, 4]);
-    });
-
-    it('returns just the first common object of two arrays', () => {
-
-        const array1 = [1, 2, 3, 4, 4, 5, 5];
-        const array2 = [5, 4, 5, 6, 7];
-        const common = Hoek.intersect(array1, array2, { first: true });
-        expect(common).to.equal(5);
-    });
-
-    it('returns null when no common and returning just the first common object of two arrays', () => {
-
-        const array1 = [1, 2, 3, 4, 4, 5, 5];
-        const array2 = [6, 7];
-        const common = Hoek.intersect(array1, array2, { first: true });
-        expect(common).to.equal(null);
-    });
-
-    it('returns an empty array if either input is null', () => {
-
-        expect(Hoek.intersect([1], null).length).to.equal(0);
-        expect(Hoek.intersect(null, [1]).length).to.equal(0);
-        expect(Hoek.intersect(null, [1], { first: true })).to.be.null();
-    });
-
-    it('returns the common objects of object and array', () => {
-
-        const array1 = { 1: true, 2: true, 3: true, 4: true, 5: true };
-        const array2 = [5, 4, 5, 6, 7];
-        const common = Hoek.intersect(array1, array2);
-        expect(common.length).to.equal(2);
-    });
-});
-
-describe('contain()', () => {
-
-    it('tests strings', () => {
-
-        expect(Hoek.contain('abc', 'ab')).to.be.true();
-        expect(Hoek.contain('abc', 'abc', { only: true })).to.be.true();
-        expect(Hoek.contain('aaa', 'a', { only: true })).to.be.true();
-        expect(Hoek.contain('aaa', 'a', { only: true, once: true })).to.be.false();
-        expect(Hoek.contain('abc', 'b', { once: true })).to.be.true();
-        expect(Hoek.contain('abc', ['a', 'c'])).to.be.true();
-        expect(Hoek.contain('abc', ['a', 'd'], { part: true })).to.be.true();
-        expect(Hoek.contain('aaa', ['a', 'a'], { only: true, once: true })).to.be.false();
-        expect(Hoek.contain('aaa', ['a', 'a'], { only: true })).to.be.true();
-        expect(Hoek.contain('aaa', ['a', 'a', 'a'], { only: true, once: true })).to.be.true();
-
-        expect(Hoek.contain('abc', 'ac')).to.be.false();
-        expect(Hoek.contain('abcd', 'abc', { only: true })).to.be.false();
-        expect(Hoek.contain('aab', 'a', { only: true })).to.be.false();
-        expect(Hoek.contain('abb', 'b', { once: true })).to.be.false();
-        expect(Hoek.contain('abc', ['a', 'd'])).to.be.false();
-        expect(Hoek.contain('abc', ['ab', 'bc'])).to.be.false();                      // Overlapping values not supported
-
-        expect(Hoek.contain('', 'a')).to.be.false();
-        expect(Hoek.contain('', 'a', { only: true })).to.be.false();
-
-        expect(Hoek.contain('', '')).to.be.true();
-        expect(Hoek.contain('', ''), { only: true }).to.be.true();
-        expect(Hoek.contain('', ''), { once: true }).to.be.true();
-        expect(Hoek.contain('', ['', ''])).to.be.true();
-        expect(Hoek.contain('', ['', ''], { only: true })).to.be.true();
-        expect(Hoek.contain('', ['', ''], { once: true })).to.be.false();
-
-        expect(Hoek.contain('a', '')).to.be.true();
-        expect(Hoek.contain('a', '', { only: true })).to.be.false();
-        expect(Hoek.contain('a', '', { once: true })).to.be.false();
-        expect(Hoek.contain('a', ['', ''])).to.be.true();
-        expect(Hoek.contain('a', ['', ''], { only: true })).to.be.false();
-        expect(Hoek.contain('a', ['', ''], { once: true })).to.be.false();
-
-        expect(Hoek.contain('ab', ['a', 'b', 'c'])).to.be.false();
-        expect(Hoek.contain('ab', ['a', 'b', 'c'], { only: true })).to.be.false();
-        expect(Hoek.contain('ab', ['a', 'b', 'c'], { only: true, once: true })).to.be.false();
-
-        expect(Hoek.contain('ab', ['c'], { part: true })).to.be.false();
-        expect(Hoek.contain('ab', ['b'], { part: true })).to.be.true();
-    });
-
-    it('tests arrays', () => {
-
-        expect(Hoek.contain([1, 2, 3], 1)).to.be.true();
-        expect(Hoek.contain([{ a: 1 }], { a: 1 }, { deep: true })).to.be.true();
-        expect(Hoek.contain([1, 2, 3], [1, 2])).to.be.true();
-        expect(Hoek.contain([{ a: 1 }], [{ a: 1 }], { deep: true })).to.be.true();
-        expect(Hoek.contain([1, 1, 2], [1, 2], { only: true })).to.be.true();
-        expect(Hoek.contain([1, 2], [1, 2], { once: true })).to.be.true();
-        expect(Hoek.contain([1, 2, 3], [1, 4], { part: true })).to.be.true();
-        expect(Hoek.contain([null, 2, 3], [null, 4], { part: true })).to.be.true();
-        expect(Hoek.contain([null], null, { deep: true })).to.be.true();
-        expect(Hoek.contain([[1], [2]], [[1]], { deep: true })).to.be.true();
-        expect(Hoek.contain([[1], [2], 3], [[1]], { deep: true })).to.be.true();
-        expect(Hoek.contain([[1, 2]], [[1]], { deep: true, part: true })).to.be.true();
-        expect(Hoek.contain([[1, 2]], [[1], 2], { deep: true, part: true })).to.be.true();
-        expect(Hoek.contain([1, 2, 1], [1, 1, 2], { only: true })).to.be.true();
-        expect(Hoek.contain([1, 2, 1], [1, 1, 2], { only: true, once: true })).to.be.true();
-        expect(Hoek.contain([1, 2, 1], [1, 2, 2], { only: true })).to.be.false();
-        expect(Hoek.contain([1, 2, 1], [1, 2, 2], { only: true, part: true })).to.be.true();
-        expect(Hoek.contain([1, 1, 1], [1, 1, 1, 1])).to.be.false();
-        expect(Hoek.contain([1, 1, 1], [1, 1, 1, 1], { part: true })).to.be.true();
-
-        expect(Hoek.contain([1, 2, 3], 4)).to.be.false();
-        expect(Hoek.contain([{ a: 1 }], { a: 2 }, { deep: true })).to.be.false();
-        expect(Hoek.contain([{ a: 1 }, { a: 1 }], [{ a: 1 }, { a: 1 }], { deep: true, once: true, only: true })).to.be.true();
-        expect(Hoek.contain([{ a: 1 }, { a: 1 }], [{ a: 1 }, { a: 2 }], { deep: true, once: true, only: true })).to.be.false();
-        expect(Hoek.contain([{ a: 1 }], { a: 1 })).to.be.false();
-        expect(Hoek.contain([1, 2, 3], [4, 5])).to.be.false();
-        expect(Hoek.contain([[3], [2]], [[1]])).to.be.false();
-        expect(Hoek.contain([[1], [2]], [[1]])).to.be.false();
-        expect(Hoek.contain([[1, 2]], [[1]], { deep: true })).to.be.false();
-        expect(Hoek.contain([{ a: 1 }], [{ a: 2 }], { deep: true })).to.be.false();
-        expect(Hoek.contain([1, 3, 2], [1, 2], { only: true })).to.be.false();
-        expect(Hoek.contain([1, 2, 2], [1, 2], { once: true })).to.be.false();
-        expect(Hoek.contain([0, 2, 3], [1, 4], { part: true })).to.be.false();
-        expect(Hoek.contain([1, 2, 1], [1, 2, 2], { only: true, once: true })).to.be.false();
-        expect(Hoek.contain([1, 2, 1], [1, 2], { only: true, once: true })).to.be.false();
-
-        expect(Hoek.contain([], 1)).to.be.false();
-        expect(Hoek.contain([], 1, { only: true })).to.be.false();
-
-        expect(Hoek.contain(['a', 'b'], ['a', 'b', 'c'])).to.be.false();
-        expect(Hoek.contain(['a', 'b'], ['a', 'b', 'c'], { only: true })).to.be.false();
-        expect(Hoek.contain(['a', 'b'], ['a', 'b', 'c'], { only: true, once: true })).to.be.false();
-
-        expect(Hoek.contain(['a', 'b'], ['c'], { part: true })).to.be.false();
-        expect(Hoek.contain(['a', 'b'], ['b'], { part: true })).to.be.true();
-
-        expect(Hoek.contain([{ a: 1 }], [1], { deep: true })).to.be.false();
-    });
-
-    it('tests objects', () => {
-
-        expect(Hoek.contain({ a: 1, b: 2, c: 3 }, 'a')).to.be.true();
-        expect(Hoek.contain({ a: 1, b: 2, c: 3 }, ['a', 'c'])).to.be.true();
-        expect(Hoek.contain({ a: 1, b: 2, c: 3 }, ['a', 'b', 'c'], { only: true })).to.be.true();
-        expect(Hoek.contain({ a: 1, b: 2, c: 3 }, { a: 1 })).to.be.true();
-        expect(Hoek.contain({ a: 1, b: 2, c: 3 }, { a: 1, c: 3 })).to.be.true();
-        expect(Hoek.contain({ a: 1, b: 2, c: 3 }, { a: 1, d: 4 }, { part: true })).to.be.true();
-        expect(Hoek.contain({ a: 1, b: 2, c: 3 }, { a: 1, b: 2, c: 3 }, { only: true })).to.be.true();
-        expect(Hoek.contain({ a: [1], b: [2], c: [3] }, { a: [1], c: [3] }, { deep: true })).to.be.true();
-        expect(Hoek.contain({ a: [{ b: 1 }, { c: 2 }, { d: 3, e: 4 }] }, { a: [{ b: 1 }, { d: 3 }] }, { deep: true })).to.be.false();
-        expect(Hoek.contain({ a: [{ b: 1 }, { c: 2 }, { d: 3, e: 4 }] }, { a: [{ b: 1 }, { d: 3 }] }, { deep: true, part: true })).to.be.true();
-        expect(Hoek.contain({ a: [{ b: 1 }, { c: 2 }, { d: 3, e: 4 }] }, { a: [{ b: 1 }, { d: 3 }] }, { deep: true, part: false })).to.be.false();
-        expect(Hoek.contain({ a: [{ b: 1 }, { c: 2 }, { d: 3, e: 4 }] }, { a: [{ b: 1 }, { d: 3 }] }, { deep: true, only: true })).to.be.false();
-        expect(Hoek.contain({ a: [{ b: 1 }, { c: 2 }, { d: 3, e: 4 }] }, { a: [{ b: 1 }, { d: 3 }] }, { deep: true, only: false })).to.be.true();
-        expect(Hoek.contain({ a: [1, 2, 3] }, { a: [2, 4, 6] }, { deep: true, part: true })).to.be.true();
-
-        expect(Hoek.contain({ a: 1, b: 2, c: 3 }, 'd')).to.be.false();
-        expect(Hoek.contain({ a: 1, b: 2, c: 3 }, ['a', 'd'])).to.be.false();
-        expect(Hoek.contain({ a: 1, b: 2, c: 3, d: 4 }, ['a', 'b', 'c'], { only: true })).to.be.false();
-        expect(Hoek.contain({ a: 1, b: 2, c: 3 }, { a: 2 })).to.be.false();
-        expect(Hoek.contain({ a: 1, b: 2, c: 3 }, { a: 2, b: 2 }, { part: true })).to.be.false();             // part does not ignore bad value
-        expect(Hoek.contain({ a: 1, b: 2, c: 3 }, { a: 1, d: 3 })).to.be.false();
-        expect(Hoek.contain({ a: 1, b: 2, c: 3 }, { a: 1, d: 4 })).to.be.false();
-        expect(Hoek.contain({ a: 1, b: 2, c: 3 }, { a: 1, b: 2 }, { only: true })).to.be.false();
-        expect(Hoek.contain({ a: [1], b: [2], c: [3] }, { a: [1], c: [3] })).to.be.false();
-        expect(Hoek.contain({ a: { b: { c: 1, d: 2 } } }, { a: { b: { c: 1 } } })).to.be.false();
-        expect(Hoek.contain({ a: { b: { c: 1, d: 2 } } }, { a: { b: { c: 1 } } }, { deep: true })).to.be.false();
-        expect(Hoek.contain({ a: { b: { c: 1, d: 2 } } }, { a: { b: { c: 1 } } }, { deep: true, only: true })).to.be.false();
-        expect(Hoek.contain({ a: { b: { c: 1, d: 2 } } }, { a: { b: { c: 1 } } }, { deep: true, only: false })).to.be.true();
-        expect(Hoek.contain({ a: { b: { c: 1, d: 2 } } }, { a: { b: { c: 1 } } }, { deep: true, part: true })).to.be.true();
-        expect(Hoek.contain({ a: { b: { c: 1, d: 2 } } }, { a: { b: { c: 1 } } }, { deep: true, part: false })).to.be.false();
-        expect(Hoek.contain({ a: [1, 2, 3] }, { a: [4, 5, 6] }, { deep: true, part: true })).to.be.false();
-
-        expect(Hoek.contain({}, 'a')).to.be.false();
-        expect(Hoek.contain({}, 'a', { only: true })).to.be.false();
-
-        expect(Hoek.contain({ a: 'foo', b: 'bar' }, ['a', 'b', 'c'])).to.be.false();
-        expect(Hoek.contain({ a: 'foo', b: 'bar' }, ['a', 'b', 'c'], { only: true })).to.be.false();
-        expect(Hoek.contain({ a: 'foo', b: 'bar' }, { a: 'foo', b: 'bar', c: 'x' })).to.be.false();
-        expect(Hoek.contain({ a: 'foo', b: 'bar' }, { a: 'foo', b: 'bar', c: 'x' }, { only: true })).to.be.false();
-
-        expect(Hoek.contain({ a: 1, b: 2 }, ['c'], { part: true })).to.be.false();
-        expect(Hoek.contain({ a: 1, b: 2 }, ['b'], { part: true })).to.be.true();
-
-        // Getter check
-
-        {
-            const Foo = function (bar) {
-
-                this.bar = bar;
-            };
-
-            const getBar = function () {
-
-                return this.bar;
-            };
-
-            const createFoo = (value) => {
-
-                const foo = new Foo(value);
-                Object.defineProperty(foo, 'baz', {
-                    enumerable: true,
-                    get: getBar
-                });
-
-                return foo;
-            };
-
-            expect(Hoek.contain({ a: createFoo('b') }, { a: createFoo('b') }, { deep: true })).to.be.true();
-            expect(Hoek.contain({ a: createFoo('b') }, { a: createFoo('b') }, { deep: true, part: true })).to.be.true();
-            expect(Hoek.contain({ a: createFoo('b') }, { a: { bar: 'b', baz: 'b' } }, { deep: true })).to.be.true();
-            expect(Hoek.contain({ a: createFoo('b') }, { a: { bar: 'b', baz: 'b' } }, { deep: true, only: true })).to.be.false();
-            expect(Hoek.contain({ a: createFoo('b') }, { a: { baz: 'b' } }, { deep: true, part: false })).to.be.false();
-            expect(Hoek.contain({ a: createFoo('b') }, { a: { baz: 'b' } }, { deep: true, part: true })).to.be.true();
-            expect(Hoek.contain({ a: createFoo('b') }, { a: createFoo('b') }, { deep: true })).to.be.true();
-        }
-
-        // Properties on prototype not visible
-
-        {
-            const Foo = function () {
-
-                this.a = 1;
-            };
-
-            Object.defineProperty(Foo.prototype, 'b', {
-                enumerable: true,
-                value: 2
-            });
-
-            const Bar = function () {
-
-                Foo.call(this);
-                this.c = 3;
-            };
-
-            Util.inherits(Bar, Foo);
-
-            expect((new Bar()).a).to.equal(1);
-            expect((new Bar()).b).to.equal(2);
-            expect((new Bar()).c).to.equal(3);
-            expect(Hoek.contain(new Bar(), { 'a': 1, 'c': 3 }, { only: true })).to.be.true();
-            expect(Hoek.contain(new Bar(), 'b')).to.be.false();
-        }
-
-        // Non-Enumerable properties
-
-        {
-            const foo = { a: 1, b: 2 };
-
-            Object.defineProperty(foo, 'c', {
-                enumerable: false,
-                value: 3
-            });
-
-            expect(Hoek.contain(foo, 'c')).to.be.true();
-            expect(Hoek.contain(foo, { 'c': 3 })).to.be.true();
-            expect(Hoek.contain(foo, { 'a': 1, 'b': 2, 'c': 3 }, { only: true })).to.be.true();
-        }
-    });
-
-    it('supports symbols', () => {
-
-        const sym = Symbol();
-
-        expect(Hoek.contain([sym], sym)).to.be.true();
-        expect(Hoek.contain({ [sym]: 1 }, sym)).to.be.true();
-        expect(Hoek.contain({ [sym]: 1, a: 2 }, { [sym]: 1 })).to.be.true();
-
-        expect(Hoek.contain([sym], Symbol())).to.be.false();
-        expect(Hoek.contain({ [sym]: 1 }, Symbol())).to.be.false();
-    });
-
-    it('compares error keys', () => {
-
-        const error = new Error('test');
-        expect(Hoek.contain(error, { x: 1 })).to.be.false();
-        expect(Hoek.contain(error, { x: 1 }, { part: true })).to.be.false();
-
-        error.x = 1;
-
-        expect(Hoek.contain(error, { x: 1 })).to.be.true();
-        expect(Hoek.contain(error, { x: 1 }, { part: true })).to.be.true();
-
-        expect(Hoek.contain(error, { x: 1, y: 2 })).to.be.false();
-        expect(Hoek.contain(error, { x: 1, y: 2 }, { part: true })).to.be.true();
-    });
-});
-
-describe('flatten()', () => {
-
-    it('returns a flat array', () => {
-
-        const result = Hoek.flatten([1, 2, [3, 4, [5, 6], [7], 8], [9], [10, [11, 12]], 13]);
-        expect(result.length).to.equal(13);
-        expect(result).to.equal([1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13]);
-    });
-});
-
-describe('reach()', () => {
-
-    const sym = Symbol();
-    const obj = {
-        a: {
-            b: {
-                c: {
-                    d: 1,
-                    e: 2
-                },
-                f: 'hello'
-            },
-            g: {
-                h: 3
-            },
-            '-2': true,
-            [sym]: {
-                v: true
-            }
-        },
-        i: function () { },
-        j: null,
-        k: [4, 8, 9, 1]
-    };
-
-    obj.i.x = 5;
-
-    it('returns object itself', () => {
-
-        expect(Hoek.reach(obj, null)).to.equal(obj);
-        expect(Hoek.reach(obj, false)).to.equal(obj);
-        expect(Hoek.reach(obj)).to.equal(obj);
-        expect(Hoek.reach(obj, [])).to.equal(obj);
-    });
-
-    it('returns values of array', () => {
-
-        expect(Hoek.reach(obj, 'k.0')).to.equal(4);
-        expect(Hoek.reach(obj, 'k.1')).to.equal(8);
-    });
-
-    it('returns last value of array using negative index', () => {
-
-        expect(Hoek.reach(obj, 'k.-1')).to.equal(1);
-        expect(Hoek.reach(obj, 'k.-2')).to.equal(9);
-    });
-
-    it('returns object property with negative index for non-array', () => {
-
-        expect(Hoek.reach(obj, 'a.-2')).to.be.equal(true);
-    });
-
-    it('returns a valid member', () => {
-
-        expect(Hoek.reach(obj, 'a.b.c.d')).to.equal(1);
-    });
-
-    it('returns a valid member with separator override', () => {
-
-        expect(Hoek.reach(obj, 'a/b/c/d', '/')).to.equal(1);
-    });
-
-    it('returns undefined on null object', () => {
-
-        expect(Hoek.reach(null, 'a.b.c.d')).to.equal(undefined);
-    });
-
-    it('returns undefined on missing object member', () => {
-
-        expect(Hoek.reach(obj, 'a.b.c.d.x')).to.equal(undefined);
-    });
-
-    it('returns undefined on missing function member', () => {
-
-        expect(Hoek.reach(obj, 'i.y', { functions: true })).to.equal(undefined);
-    });
-
-    it('throws on missing member in strict mode', () => {
-
-        expect(() => {
-
-            Hoek.reach(obj, 'a.b.c.o.x', { strict: true });
-        }).to.throw('Missing segment o in reach path  a.b.c.o.x');
-
-    });
-
-    it('returns undefined on invalid member', () => {
-
-        expect(Hoek.reach(obj, 'a.b.c.d-.x')).to.equal(undefined);
-        expect(Hoek.reach(obj, 'k.x')).to.equal(undefined);
-        expect(Hoek.reach(obj, 'k.1000')).to.equal(undefined);
-        expect(Hoek.reach(obj, 'k/0.5', '/')).to.equal(undefined);
-    });
-
-    it('returns function member', () => {
-
-        expect(typeof Hoek.reach(obj, 'i')).to.equal('function');
-    });
-
-    it('returns function property', () => {
-
-        expect(Hoek.reach(obj, 'i.x')).to.equal(5);
-    });
-
-    it('returns null', () => {
-
-        expect(Hoek.reach(obj, 'j')).to.equal(null);
-    });
-
-    it('throws on function property when functions not allowed', () => {
-
-        expect(() => {
-
-            Hoek.reach(obj, 'i.x', { functions: false });
-        }).to.throw('Invalid segment x in reach path  i.x');
-    });
-
-    it('will return a default value if property is not found', () => {
-
-        expect(Hoek.reach(obj, 'a.b.q', { default: 'defaultValue' })).to.equal('defaultValue');
-    });
-
-    it('will return a default value if path is not found', () => {
-
-        expect(Hoek.reach(obj, 'q', { default: 'defaultValue' })).to.equal('defaultValue');
-    });
-
-    it('allows a falsey value to be used as the default value', () => {
-
-        expect(Hoek.reach(obj, 'q', { default: '' })).to.equal('');
-    });
-
-    it('allows array-based lookup', () => {
-
-        expect(Hoek.reach(obj, ['a', 'b', 'c', 'd'])).to.equal(1);
-        expect(Hoek.reach(obj, ['k', '1'])).to.equal(8);
-        expect(Hoek.reach(obj, ['k', 1])).to.equal(8);
-        expect(Hoek.reach(obj, ['k', '-2'])).to.equal(9);
-        expect(Hoek.reach(obj, ['k', -2])).to.equal(9);
-    });
-
-    it('allows array-based lookup with symbols', () => {
-
-        expect(Hoek.reach(obj, ['a', sym, 'v'])).to.equal(true);
-        expect(Hoek.reach(obj, ['a', Symbol(), 'v'])).to.equal(undefined);
-    });
-
-    it('returns character in string', () => {
-
-        expect(Hoek.reach(['abc'], [0])).to.equal('abc');
-        expect(Hoek.reach(['abc'], ['0'])).to.equal('abc');
-    });
-
-    it('reaches sets and maps', () => {
-
-        const value = {
-            a: {
-                b: new Set([
-                    { x: 1 },
-                    { x: 2 },
-                    {
-                        y: new Map([
-                            ['v', 4],
-                            ['w', 5]
-                        ])
-                    }
-                ])
-            }
-        };
-
-        expect(Hoek.reach(value, 'a.b.2.y.w')).to.not.exist();
-        expect(Hoek.reach(value, 'a.b.2.y.w', { iterables: true })).to.equal(5);
-    });
-});
-
-describe('reachTemplate()', () => {
-
-    it('applies object to template', () => {
-
-        const obj = {
-            a: {
-                b: {
-                    c: {
-                        d: 1
-                    }
-                }
-            },
-            j: null,
-            k: [4, 8, 9, 1]
-        };
-
-        const template = '{k.0}:{k.-2}:{a.b.c.d}:{x.y}:{j}';
-
-        expect(Hoek.reachTemplate(obj, template)).to.equal('4:9:1::');
-    });
-
-    it('applies object to template (options)', () => {
-
-        const obj = {
-            a: {
-                b: {
-                    c: {
-                        d: 1
-                    }
-                }
-            },
-            j: null,
-            k: [4, 8, 9, 1]
-        };
-
-        const template = '{k/0}:{k/-2}:{a/b/c/d}:{x/y}:{j}';
-
-        expect(Hoek.reachTemplate(obj, template, '/')).to.equal('4:9:1::');
-    });
-
-    it('isn\'t prone to ReDoS given an adversarial template', () => {
-
-        const sizes = [0, 1, 2, 3, 4]; // Should be evenly-spaced
-        const times = [];
-        const diffs = [];
-
-        for (const size of sizes) {
-            const start = Date.now();
-            Hoek.reachTemplate({}, '{'.repeat(size * 10000));
-            times.push(Date.now() - start);
-        }
-
-        for (let i = 1; i < times.length; ++i) {
-            diffs.push(times[i] - times[i - 1]);
-        }
-
-        // Under ReDoS, as the size of the input increases the timing accelerates upwards,
-        // i.e. each timing diff would be greater than the last.
-
-        const diffsMonotonic = diffs[0] < diffs[1] && diffs[1] < diffs[2] && diffs[2] < diffs[3];
-
-        expect(diffsMonotonic, 'Timing diffs monotonic').to.be.false();
-    });
-});
-
-describe('assert()', () => {
-
-    it('throws an Error when using assert in a test', () => {
-
-        expect(() => {
-
-            Hoek.assert(false, 'my error message');
-        }).to.throw(Hoek.AssertError, 'my error message');
-    });
-
-    it('throws an Error when using assert in a test with no message', () => {
-
-        expect(() => {
-
-            Hoek.assert(false);
-        }).to.throw(Hoek.AssertError, 'Unknown error');
-    });
-
-    it('throws an Error when using assert in a test with multipart message', () => {
-
-        expect(() => {
-
-            Hoek.assert(false, 'This', 'is', 'my message');
-        }).to.throw(Hoek.AssertError, 'This is my message');
-    });
-
-    it('throws an Error when using assert in a test with multipart message (empty)', () => {
-
-        expect(() => {
-
-            Hoek.assert(false, 'This', 'is', '', 'my message');
-        }).to.throw(Hoek.AssertError, 'This is my message');
-    });
-
-    it('throws an Error when using assert in a test with object message', () => {
-
-        expect(() => {
-
-            Hoek.assert(false, 'This', 'is', { spinal: 'tap' });
-        }).to.throw(Hoek.AssertError, 'This is {"spinal":"tap"}');
-    });
-
-    it('throws an Error when using assert in a test with multipart string and error messages', () => {
-
-        expect(() => {
-
-            Hoek.assert(false, new Error('This'), 'is', 'spinal', new Error('tap'));
-        }).to.throw(Hoek.AssertError, 'This is spinal tap');
-    });
-
-    it('throws an Error when using assert in a test with error object message', () => {
-
-        const err = new TypeError('This is spinal tap');
-        const got = expect(() => Hoek.assert(false, err)).to.throw(TypeError, 'This is spinal tap');
-        expect(got).to.shallow.equal(err);
-    });
-
-    it('throws the same Error that is passed to it if there is only one error passed', () => {
-
-        const error = new Error('ruh roh');
-        const error2 = new Error('ruh roh');
-
-        const fn = function () {
-
-            Hoek.assert(false, error);
-        };
-
-        try {
-            fn();
-        }
-        catch (err) {
-            expect(err).to.equal(error);  // should be the same reference
-            expect(err).to.not.shallow.equal(error2); // error with the same message should not match
-        }
-    });
-});
-
-describe('AssertError', () => {
-
-    it('takes an optional message', () => {
-
-        expect(new Hoek.AssertError().message).to.equal('Unknown error');
-        expect(new Hoek.AssertError(null).message).to.equal('Unknown error');
-        expect(new Hoek.AssertError('msg').message).to.equal('msg');
-    });
-
-    it('has AssertError name property', () => {
-
-        expect(new Hoek.AssertError().name).to.equal('AssertError');
-        expect(new Hoek.AssertError('msg').name).to.equal('AssertError');
-    });
-
-    it('uses ctor argument to hide stack', { skip: typeof Error.captureStackTrace !== 'function' }, () => {
-
-        const parentFn = () => {
-
-            throw new Hoek.AssertError('msg', parentFn);
-        };
-
-        const err = expect(parentFn).to.throw(Hoek.AssertError);
-
-        expect(err.stack).to.not.contain('parentFn');
-    });
-});
-
-describe('Bench', () => {
-
-    it('returns time elapsed', async () => {
-
-        const timer = new Hoek.Bench();
-        await Hoek.wait(12);
-        expect(timer.elapsed()).to.be.above(9);
-    });
-});
-
-describe('escapeRegex()', () => {
-
-    it('escapes all special regular expression characters', () => {
-
-        const a = Hoek.escapeRegex('4^f$s.4*5+-_?%=#!:@|~\\/`"(>)[<]d{}s,');
-        expect(a).to.equal('4\\^f\\$s\\.4\\*5\\+\\-_\\?%\\=#\\!\\:@\\|~\\\\\\/`"\\(>\\)\\[<\\]d\\{\\}s\\,');
-    });
-});
-
-describe('escapeHeaderAttribute()', () => {
-
-    it('should not alter ascii values', () => {
-
-        const a = Hoek.escapeHeaderAttribute('My Value');
-        expect(a).to.equal('My Value');
-    });
-
-    it('escapes all special HTTP header attribute characters', () => {
-
-        const a = Hoek.escapeHeaderAttribute('I said go!!!#"' + String.fromCharCode(92));
-        expect(a).to.equal('I said go!!!#\\"\\\\');
-    });
-
-    it('throws on large unicode characters', () => {
-
-        expect(() => {
-
-            Hoek.escapeHeaderAttribute('this is a test' + String.fromCharCode(500) + String.fromCharCode(300));
-        }).to.throw(Error);
-    });
-
-    it('throws on CRLF to prevent response splitting', () => {
-
-        expect(() => {
-
-            Hoek.escapeHeaderAttribute('this is a test\r\n');
-        }).to.throw(Error);
-    });
-});
-
-describe('escapeHtml()', () => {
-
-    it('escapes all special HTML characters', () => {
-
-        const a = Hoek.escapeHtml('&<>"\'`');
-        expect(a).to.equal('&amp;&lt;&gt;&quot;&#x27;&#x60;');
-    });
-
-    it('returns empty string on falsy input', () => {
-
-        const a = Hoek.escapeHtml('');
-        expect(a).to.equal('');
-    });
-
-    it('returns unchanged string on no reserved input', () => {
-
-        const a = Hoek.escapeHtml('abc');
-        expect(a).to.equal('abc');
-    });
-});
-
-describe('once()', () => {
-
-    it('allows function to only execute once', () => {
-
-        let gen = 0;
-        let add = function (x) {
-
-            gen += x;
-        };
-
-        add(5);
-        expect(gen).to.equal(5);
-        add = Hoek.once(add);
-        add(5);
-        expect(gen).to.equal(10);
-        add(5);
-        expect(gen).to.equal(10);
-    });
-
-    it('double once wraps one time', () => {
-
-        let method = function () { };
-        method = Hoek.once(method);
-        method.x = 1;
-        method = Hoek.once(method);
-        expect(method.x).to.equal(1);
-    });
-});
-
-describe('ignore()', () => {
-
-    it('exists', () => {
-
-        expect(Hoek.ignore).to.exist();
-        expect(typeof Hoek.ignore).to.equal('function');
-    });
-});
-
-describe('stringify()', () => {
-
-    it('converts object to string', () => {
-
-        const obj = { a: 1 };
-        expect(Hoek.stringify(obj)).to.equal('{"a":1}');
-    });
-
-    it('returns error in result string', () => {
-
-        const obj = { a: 1 };
-        obj.b = obj;
-        expect(Hoek.stringify(obj)).to.contain('Cannot display object');
-    });
-});
-
-describe('isPromise()', () => {
-
-    it('determines if an object is a promise', async () => {
-
-        expect(Hoek.isPromise({})).to.be.false();
-        expect(Hoek.isPromise(null)).to.be.false();
-        expect(Hoek.isPromise(false)).to.be.false();
-        expect(Hoek.isPromise(0)).to.be.false();
-        expect(Hoek.isPromise('')).to.be.false();
-        expect(Hoek.isPromise({ then: 1 })).to.be.false();
-        expect(Hoek.isPromise([])).to.be.false();
-
-        const items = [
-            Promise.resolve(),
-            Promise.reject()
-        ];
-
-        expect(Hoek.isPromise(items[0])).to.be.true();
-        expect(Hoek.isPromise(items[1])).to.be.true();
-        expect(Hoek.isPromise(new Promise(Hoek.ignore))).to.be.true();
-        expect(Hoek.isPromise({ then: Hoek.ignore })).to.be.true();
-
-        try {
-            await Promise.all(items);
-        }
-        catch (err) { }
-    });
-});
-
-describe('wait()', () => {
-
-    it('delays for timeout ms', async () => {
-
-        const timeout = {};
-        setTimeout(() => (timeout.before = true), 10);
-        const wait = Hoek.wait(10);
-        setTimeout(() => (timeout.after = true), 10);
-
-        await wait;
-
-        expect(timeout.before).to.be.true();
-        expect(timeout.after).to.be.undefined();
-    });
-
-    it('delays for timeout ms as bigint', async () => {
-
-        const timeout = {};
-        setTimeout(() => (timeout.before = true), 10);
-        const wait = Hoek.wait(10n);
-        setTimeout(() => (timeout.after = true), 10);
-
-        await wait;
-
-        expect(timeout.before).to.be.true();
-        expect(timeout.after).to.be.undefined();
-    });
-
-    it('handles timeouts >= 2^31', async () => {
-
-        const flow = [];
-        let no = 0;
-
-        const fakeTimeout = function (cb, time) {
-
-            const timer = ++no;
-
-            flow.push(`CALL(${timer}): ${time}`);
-            setImmediate(() => {
-
-                flow.push(`PRE(${timer})`);
-                cb();
-                flow.push(`POST(${timer})`);
-            });
-        };
-
-        await Hoek.wait(2 ** 31, null, { setTimeout: fakeTimeout });
-        flow.push('DONE1');
-        await Hoek.wait(2 ** 32 + 2 ** 30, null, { setTimeout: fakeTimeout });
-        flow.push('DONE2');
-
-        expect(flow).to.equal([
-            'CALL(1): 2147483647',
-            'PRE(1)',
-            'CALL(2): 1',
-            'POST(1)',
-            'PRE(2)',
-            'POST(2)',
-            'DONE1',
-            'CALL(3): 2147483647',
-            'PRE(3)',
-            'CALL(4): 2147483647',
-            'POST(3)',
-            'PRE(4)',
-            'CALL(5): 1073741826',
-            'POST(4)',
-            'PRE(5)',
-            'POST(5)',
-            'DONE2'
-        ]);
-    });
-
-    it('returns never resolving promise when timeout >= Number.MAX_SAFE_INTEGER', async () => {
-
-        let calls = 0;
-        const fakeTimeout = function (cb) {
-
-            ++calls;
-            process.nextTick(cb);
-        };
-
-        await Hoek.wait(2 ** 31 - 1, null, { setTimeout: fakeTimeout });
-        expect(calls).to.equal(1);
-
-        const waited = Symbol('waited');
-
-        const result = await Promise.race([
-            Hoek.wait(1, waited),
-            Hoek.wait(Number.MAX_SAFE_INTEGER, null, { setTimeout: fakeTimeout }),
-            Hoek.wait(Infinity, null, { setTimeout: fakeTimeout })
-        ]);
-
-        expect(result).to.be.equal(waited);
-        expect(calls).to.equal(1);
-    });
-
-    it('handles a return value', async () => {
-
-        const uniqueValue = {};
-        const timeout = {};
-        setTimeout(() => (timeout.before = true), 10);
-        const wait = Hoek.wait(10, uniqueValue);
-        setTimeout(() => (timeout.after = true), 10);
-
-        expect(await wait).to.shallow.equal(uniqueValue);
-        expect(timeout.before).to.be.true();
-        expect(timeout.after).to.be.undefined();
-    });
-
-    it('undefined timeout resolves immediately', async () => {
-
-        const waited = Symbol('waited');
-        const result = await Promise.race([
-            Hoek.wait(undefined, waited),
-            Hoek.wait(0)
-        ]);
-
-        expect(result).to.equal(waited);
-    });
-
-    it('NaN timeout resolves immediately', async () => {
-
-        const waited = Symbol('waited');
-        const result = await Promise.race([
-            Hoek.wait(Number.NaN, waited),
-            Hoek.wait(0)
-        ]);
-
-        expect(result).to.equal(waited);
-    });
-
-    it('rejects on weird timeout values', async () => {
-
-        await expect(() => Hoek.wait({})).to.throw();
-        await expect(() => Hoek.wait(Symbol('hi'))).to.throw();
-    });
-});
-
-describe('block()', () => {
-
-    it('returns a promise', () => {
-
-        expect(Hoek.block()).to.be.instanceOf(Promise);
-    });
-
-    it('does not immediately reject or resolve', async () => {
-
-        const promise = Hoek.block();
-        const waited = Symbol('waited');
-
-        const result = await Promise.race([
-            Hoek.wait(1, waited),
-            promise
-        ]);
-
-        expect(result).to.be.equal(waited);
-    });
-});
diff --git a/test/index.ts b/test/index.ts
index 322cc7da..d4310a1c 100755
--- a/test/index.ts
+++ b/test/index.ts
@@ -1,364 +1,2481 @@
-import * as Hoek from '..';
-import * as Lab from '@hapi/lab';
-import deepEqual = require('../lib/deepEqual');
-
-
-const { expect } = Lab.types;
-
-// Direct module import
-expect.type<Function>(deepEqual);
-expect.type<boolean>(deepEqual(1, 2));
-
-interface Foo {
-    a?: number;
-    b?: string;
+// oxlint-disable unicorn/no-thenable
+
+import Util from 'util';
+
+import { describe, it, expect } from 'vitest';
+
+import * as Hoek from '../src/index.js';
+import { type MergeTypes } from '../src/merge.js';
+
+const nestedObj = {
+    v: [7, 8, 9],
+    w: /^something$/gim,
+    x: {
+        a: [1, 2, 3],
+        b: 123456,
+        c: new Date(),
+        d: /hi/gim,
+        e: /hello/,
+    },
+    y: 'y',
+    z: new Date(1378775452757),
 };
 
-interface Bar {
-    b?: string;
-    c?: boolean;
-};
-
-
-// deepEqual()
-
-Hoek.deepEqual('some', 'some');
-Hoek.deepEqual('some', 3);
-Hoek.deepEqual({}, {});
-Hoek.deepEqual({}, {}, { prototype: false, symbols: true, part: false, deepFunction: true });
-Hoek.deepEqual({}, {}, { skip: ['a', 'b', Symbol('test')] });
-
-expect.type<boolean>(Hoek.deepEqual(1, 2));
-
-expect.error(Hoek.deepEqual());
-expect.error(Hoek.deepEqual(1, 2, {}, 'x'));
-expect.error(Hoek.deepEqual({}, {}, { unknown: true }));
-expect.error(Hoek.deepEqual({}, {}, { skip: [1] }))
-
-
-// clone()
-
-Hoek.clone('string');
-Hoek.clone(123);
-Hoek.clone({ a: 1 });
-Hoek.clone({ a: 1 }, { prototype: true, symbols: true });
-Hoek.clone({}, { shallow: [] });
-Hoek.clone(1, { shallow: [] });
-Hoek.clone(null, { shallow: [] });
-Hoek.clone({ a: 1, b: { c: [2] } }, { shallow: true });
-Hoek.clone({ a: 1, b: { c: [2] } }, { shallow: ['b'] });
-Hoek.clone({ a: 1, b: { c: [2] } }, { shallow: [['b']] });
-Hoek.clone({ a: 1, b: { c: [2] } }, { shallow: ['b'], prototype: true, symbols: true });
-
-expect.type<string>(Hoek.clone('string'));
-expect.type<object>(Hoek.clone({}));
-expect.type<Bar>(Hoek.clone({} as Bar));
-expect.type<Foo>(Hoek.clone({ a: 1 } as Foo, { shallow: ['b'] }));
-
-expect.error(Hoek.clone({}, { unknown: true }));
-expect.error(Hoek.clone({}, { shallow: [1] }));
-expect.error(Hoek.clone({}, { shallow: 1 }));
-
-
-// merge()
-
-Hoek.merge({ a: 1 } as Foo, { b: 'x' } as Bar);
-Hoek.merge({ a: 1 }, { a: null });
-Hoek.merge({ a: 1 }, { a: null }, { mergeArrays: true, nullOverride: true, symbols: false });
-
-expect.type<object>(Hoek.merge({}, {}));
-expect.type<Foo & Bar>(Hoek.merge({ a: 1 } as Foo, { b: 'x' } as Bar));
-
-expect.error(Hoek.merge(1, 2));
-expect.error(Hoek.merge({ a: 1 }, { a: null }, true));
-expect.error(Hoek.merge({ a: 1 }, { a: null }, { unknown: true }));
-
-
-// applyToDefaults()
-
-Hoek.applyToDefaults({}, {});
-Hoek.applyToDefaults({}, true);
-Hoek.applyToDefaults({}, false);
-Hoek.applyToDefaults({}, null);
-Hoek.applyToDefaults({ a: 1 } as Foo, { b: 'x' });
-Hoek.applyToDefaults({ a: 1 } as object, { b: 'x' });
-Hoek.applyToDefaults({ a: 1 } as Foo, { b: 'x' }, { shallow: ['b'] });
-Hoek.applyToDefaults({ a: 1 } as object, { b: 'x' }, { shallow: ['c'] });
-
-expect.type<object>(Hoek.applyToDefaults({}, {}));
-expect.type<Foo>(Hoek.applyToDefaults({ a: 1 } as Foo, { b: 'x' }));
-expect.type<object>(Hoek.applyToDefaults({}, {}, { shallow: [] }));
-
-expect.error(Hoek.applyToDefaults({} as Foo, 0));
-expect.error(Hoek.applyToDefaults({} as Foo, 0, { shallow: [] }));
-
-
-// intersect()
-
-Hoek.intersect([1], [1, 2]);
-Hoek.intersect(['a'], ['b', 'b']);
-Hoek.intersect([1], [1, 2], { first: true });
-Hoek.intersect([1], [1, 2], { first: false });
-Hoek.intersect([1], null);
-Hoek.intersect(null, [1, 2]);
-Hoek.intersect([1], null, { first: true });
-Hoek.intersect(null, [1, 2], { first: true });
-Hoek.intersect(new Set([1]), new Set([1, 2]));
-Hoek.intersect([1], new Set([1, 2]));
-Hoek.intersect(new Set([1]), [1, 2]);
-
-expect.type<any[]>(Hoek.intersect([1], [1, 2]));
-expect.type<any[]>(Hoek.intersect([1], [1, 2], { first: false }));
-expect.type<any>(Hoek.intersect([1], [1, 2], { first: true }));
-
-expect.error(Hoek.intersect());
-expect.error(Hoek.intersect(1, 2));
-expect.error(Hoek.intersect([1], 2));
-expect.error(Hoek.intersect([1], [2], 'x'));
-expect.error(Hoek.intersect(new Map(), [2]));
-
-
-// contain()
-
-Hoek.contain('abc', 'a');
-Hoek.contain('abc', ['a', 'x']);
-Hoek.contain('abc', ['a', 'd'], { once: true, part: true, deep: true, symbols: true, only: true });
-Hoek.contain({ a: 1 }, 'a');
-Hoek.contain({ a: 1 }, { a: 1 });
-Hoek.contain({ a: 1, b: 2 }, ['a', 'x'], { part: true, deep: true, symbols: true, only: true });
-Hoek.contain([1], 1);
-Hoek.contain([1], [1]);
-Hoek.contain([1], [1], { once: true, part: true, deep: true, symbols: true, only: true });
-
-expect.type<boolean>(Hoek.contain('abc', 'a'));
-expect.type<boolean>(Hoek.contain({ a: 1 }, 'a'));
-expect.type<boolean>(Hoek.contain([1], 1));
-
-expect.error(Hoek.contain('abc', 'a', { unknown: true }));
-expect.error(Hoek.contain(['a'], 'a', { unknown: true }));
-expect.error(Hoek.contain({ a: 1 }, 'a', { unknown: true }));
-expect.error(Hoek.contain('abc', 1));
-expect.error(Hoek.contain('abc', [1]));
-expect.error(Hoek.contain('abc', [{}]));
-expect.error(Hoek.contain('abc', {}));
-expect.error(Hoek.contain({}, 1));
-expect.error(Hoek.contain({ a: 1, b: 2 }, ['a', 'x'], { once: true }));
-
-// flatten()
-
-Hoek.flatten([1, [2, 3]]);
-Hoek.flatten([1, [2, 3]], [4, 5]);
-
-expect.type<any[]>(Hoek.flatten([1, [2, 3]]));
-expect.type<any[]>(Hoek.flatten([1, [2, 3]], []));
-
-expect.error(Hoek.flatten());
-expect.error(Hoek.flatten(1));
-expect.error(Hoek.flatten([], 1));
-
-
-// reach()
-
-Hoek.reach(null, false);
-Hoek.reach(null, '0');
-Hoek.reach(null, ['0']);
-Hoek.reach(['abc'], false);
-Hoek.reach(['abc'], null);
-Hoek.reach(['abc'], undefined);
-Hoek.reach(['abc'], [0]);
-Hoek.reach(['abc'], ['0']);
-Hoek.reach(['abc'], '0');
-Hoek.reach({ a: { b: { c: 3 } } }, 'a.b.c');
-Hoek.reach({ a: { b: { c: 3 } } }, ['a', 'b', 'c']);
-Hoek.reach({ a: { b: { c: 3 } } }, 'a/b/c', { separator: '/', default: 4, strict: true, functions: true, iterables: true });
-
-expect.type<any>(Hoek.reach(['abc'], [0]));
-expect.type<any>(Hoek.reach({ a: { b: { c: 3 } } }, 'a.b.c'));
-
-expect.error(Hoek.reach());
-expect.error(Hoek.reach([]));
-expect.error(Hoek.reach(1, '0'));
-expect.error(Hoek.reach('abc', '0'));
-expect.error(Hoek.reach([0], 0));
-expect.error(Hoek.reach(['abc'], '0', { unknown: false }));
-expect.error(Hoek.reach(['abc'], '0', { separator: false }));
-
-
-// reachTemplate()
-
-Hoek.reachTemplate(null, 'a{b}c');
-Hoek.reachTemplate([1, 2], 'a{1}c');
-Hoek.reachTemplate({ b: 2 }, 'a{b}c');
-Hoek.reachTemplate({ a: { b: { c: 3 } } }, '{a/b/c}', { separator: '/', default: 4, strict: true, functions: true });
-
-expect.type<string>(Hoek.reachTemplate([1, 2], 'a{1}c'));
-
-expect.error(Hoek.reachTemplate());
-expect.error(Hoek.reachTemplate([]));
-expect.error(Hoek.reachTemplate(1, '0'));
-expect.error(Hoek.reachTemplate('abc', '0'));
-expect.error(Hoek.reachTemplate([0], 0));
-expect.error(Hoek.reachTemplate(['abc'], '{0}', { unknown: false }));
-expect.error(Hoek.reachTemplate(['abc'], '{0}', { separator: false }));
-
-
-// assert()
-
-Hoek.assert(true);
-Hoek.assert(true, 'some', 'message', 10);
-Hoek.assert(1, 'error');
-Hoek.assert(true, new Error('message'));
-
-expect.type<void>(Hoek.assert(true));
-
-
-// Bench
-
-const bench = new Hoek.Bench();
-expect.type<number>(bench.ts);
-expect.type<void>(bench.reset());
-expect.type<number>(bench.elapsed());
-expect.type<number>(Hoek.Bench.now());
-
-expect.error(new Hoek.Bench({}));
-expect.error(bench.reset(true));
-expect.error(bench.elapsed(true));
-expect.error(Hoek.Bench.now(true));
-
-
-// escapeRegex()
-
-Hoek.escapeRegex('something?');
-
-expect.type<string>(Hoek.escapeRegex('^?'));
-
-expect.error(Hoek.escapeRegex());
-expect.error(Hoek.escapeRegex(true));
-expect.error(Hoek.escapeRegex({}));
-
-
-// escapeHeaderAttribute()
-
-Hoek.escapeHeaderAttribute('something?');
-
-expect.type<string>(Hoek.escapeHeaderAttribute('^?'));
-
-expect.error(Hoek.escapeHeaderAttribute());
-expect.error(Hoek.escapeHeaderAttribute(true));
-expect.error(Hoek.escapeHeaderAttribute({}));
-
-
-// escapeHtml()
-
-Hoek.escapeHtml('something?');
-
-expect.type<string>(Hoek.escapeHtml('^?'));
-
-expect.error(Hoek.escapeHtml());
-expect.error(Hoek.escapeHtml(true));
-expect.error(Hoek.escapeHtml({}));
-
-
-// escapeJson()
-
-Hoek.escapeJson('something?');
-
-expect.type<string>(Hoek.escapeJson('^?'));
-
-expect.error(Hoek.escapeJson());
-expect.error(Hoek.escapeJson(true));
-expect.error(Hoek.escapeJson({}));
-
-
-// once()
-
-Hoek.once(() => 4);
-Hoek.once(() => undefined);
-
-expect.type<() => void>(Hoek.once(() => 'x'));
-
-expect.error(Hoek.once());
-expect.error(Hoek.once('x'));
-expect.error(Hoek.once({}));
-
-
-// ignore()
-
-Hoek.ignore();
-Hoek.ignore(1, 2, 'x');
-
-expect.type<() => void>(Hoek.ignore);
-expect.type<void>(Hoek.ignore());
-
-
-// stringify()
-
-Hoek.stringify(123);
-Hoek.stringify({}, null, 4);
-
-expect.type<string>(Hoek.stringify(123));
-
-expect.error(Hoek.stringify());
-
-
-// wait()
-
-// $lab:types:off$
-await Hoek.wait();
-await Hoek.wait(123);
-
-expect.type<Promise<void>>(Hoek.wait());
-expect.type<void>(await Hoek.wait(100));
-expect.type<Promise<string>>(Hoek.wait(100, 'ok'));
-
-expect.error(Hoek.wait({}));
-// $lab:types:on$
-
-
-// block()
-
-// $lab:types:off$
-Hoek.wait();
-
-expect.type<Promise<void>>(Hoek.block());
-expect.type<void>(await Hoek.block());
-
-expect.error(Hoek.block(123));
-// $lab:types:on$
-
-
-// isPromise()
-
-Hoek.isPromise(1);
-Hoek.isPromise({});
-Hoek.isPromise(null);
-
-expect.type<boolean>(Hoek.isPromise(1));
-
-expect.error(Hoek.isPromise());
-expect.error(Hoek.isPromise(1, 2));
-
-
-// ts
-
-interface X { a: number; };
-interface Y { b: number; };
-
-function xor(input: Hoek.ts.XOR<X, Y>): number {
-
-    return input.a || input.b || 10;
-}
-
-xor({ a: 1 });
-xor({ b: 2 });
-expect.error(xor({ a: 1, b: 2 }));
-
-// AssertError
-
-expect.type<Hoek.AssertError>(new Hoek.AssertError());
-expect.type<Hoek.AssertError>(new Hoek.AssertError('fail'));
-expect.type<'AssertError'>(new Hoek.AssertError().name);
-expect.type<string>(new Hoek.AssertError().message);
-
-expect.error(new Hoek.AssertError(new Error()));
-expect.error(new Hoek.AssertError('fail', 'again'));
+describe('merge()', () => {
+    it('deep copies source items', () => {
+        const sym1 = Symbol('1');
+        const sym2 = Symbol('2');
+        const sym3 = Symbol('3');
+
+        const target = {
+            b: 3,
+            d: [],
+            [sym1]: true,
+            [sym3]: true,
+        } as any;
+
+        const source = {
+            c: {
+                d: 1,
+            },
+            d: [{ e: 1 }],
+            [sym2]: true,
+            [sym3]: false,
+        };
+
+        Hoek.merge(target, source);
+        expect(target.c).not.toBe(source.c);
+        expect(target.c).toHoequal(source.c);
+        expect(target.d).not.toBe(source.d);
+        expect(target.d[0]).not.toBe(source.d[0]);
+        expect(target.d).toHoequal(source.d);
+
+        expect(target[sym1]).toBe(true);
+        expect(target[sym2]).toBe(true);
+        expect(target[sym3]).toBe(false);
+    });
+
+    it('deep copies source items without symbols', () => {
+        const sym1 = Symbol('1');
+        const sym2 = Symbol('2');
+        const sym3 = Symbol('3');
+
+        const target = {
+            b: 3,
+            d: [],
+            [sym1]: true,
+            [sym3]: true,
+        } as any;
+
+        const source = {
+            c: {
+                d: 1,
+            },
+            d: [{ e: 1 }],
+            [sym2]: true,
+            [sym3]: false,
+        };
+
+        Hoek.merge(target, source, { symbols: false });
+        expect(target.c).not.toBe(source.c);
+        expect(target.c).toHoequal(source.c);
+        expect(target.d).not.toBe(source.d);
+        expect(target.d[0]).not.toBe(source.d[0]);
+        expect(target.d).toHoequal(source.d);
+
+        expect(target[sym1]).toBe(true);
+        expect(target[sym2]).toBeUndefined();
+        expect(target[sym3]).toBe(true);
+    });
+
+    it('merges array over an object', () => {
+        const a = {
+            x: ['n', 'm'],
+        } as any;
+
+        const b = {
+            x: {
+                n: '1',
+                m: '2',
+            },
+        };
+
+        Hoek.merge(b, a);
+        expect(a.x[0]).toEqual('n');
+        expect(a.x.n).toBeUndefined();
+    });
+
+    it('merges object over an array', () => {
+        const a = {
+            x: ['n', 'm'],
+        } as any;
+
+        const b = {
+            x: {
+                n: '1',
+                m: '2',
+            },
+        };
+
+        Hoek.merge(a, b);
+        expect(a.x.n).toEqual('1');
+        expect(a.x[0]).toBeUndefined();
+    });
+
+    it('merges from null prototype objects', () => {
+        const a = {} as any;
+
+        const b = Object.create(null);
+        b.x = true;
+
+        Hoek.merge(a, b);
+        expect(a.x).toBe(true);
+    });
+
+    it('skips non-enumerable properties', () => {
+        const a = { x: 0 } as any;
+
+        const b = {};
+        Object.defineProperty(b, 'x', {
+            enumerable: false,
+            value: 1,
+        });
+
+        Hoek.merge(a, b);
+        expect(a.x).toEqual(0);
+    });
+
+    it('does not throw if source is null', () => {
+        const a = {} as any;
+        const b = null;
+        let c = null;
+
+        expect(() => {
+            c = Hoek.merge(a, b);
+        }).not.toThrow();
+
+        expect(c).toHoequal(a);
+    });
+
+    it('does not throw if source is undefined', () => {
+        const a = {} as any;
+        const b = undefined;
+        let c = null;
+
+        expect(() => {
+            c = Hoek.merge(a, b);
+        }).not.toThrow();
+
+        expect(c).toHoequal(a);
+    });
+
+    it('throws if source is not an object', () => {
+        expect(() => {
+            const a = {} as any;
+            const b = 0;
+
+            // @ts-expect-error - intentionally invalid
+            Hoek.merge(a, b);
+        }).toThrow('Invalid source value: must be null, undefined, or an object');
+    });
+
+    it('throws if target is not an object', () => {
+        expect(() => {
+            const a = 0;
+            const b = {};
+
+            // @ts-expect-error - intentionally invalid
+            Hoek.merge(a, b);
+        }).toThrow('Invalid target value: must be an object');
+    });
+
+    it('throws if target is not an array and source is', () => {
+        expect(() => {
+            const a = {} as any;
+            const b = [1, 2];
+
+            Hoek.merge(a, b);
+        }).toThrow('Cannot merge array onto an object');
+    });
+
+    it('returns the same object when merging arrays', () => {
+        const a = [] as any[];
+        const b = [1, 2];
+
+        expect(Hoek.merge(a, b)).toHoequal(a);
+    });
+
+    it('combines an empty object with a non-empty object', () => {
+        const a = {} as any;
+        const b = nestedObj;
+
+        const c = Hoek.merge(a, b);
+        expect(a).toHoequal(b);
+        expect(c).toHoequal(b);
+    });
+
+    it('overrides values in target', () => {
+        const a = { x: 1, y: 2, z: 3, v: 5, t: 'test', s: 1, m: 'abc' };
+        const b = { x: null, z: 4, v: 0, t: { u: 6 }, s: undefined, m: '123' };
+
+        const c = Hoek.merge(a, b);
+        expect(c.x).toHoequal(null as never);
+        expect(c.y).toEqual(2);
+        expect(c.z).toEqual(4);
+        expect(c.v).toEqual(0);
+        expect(c.m).toEqual('123');
+        expect(c.t).toHoequal({ u: 6 });
+        expect(c.s).toBeUndefined();
+    });
+
+    it('overrides values in target (flip)', () => {
+        const a = { x: 1, y: 2, z: 3, v: 5, t: 'test', s: 1, m: 'abc' };
+        const b = { x: null, z: 4, v: 0, t: { u: 6 }, s: undefined, m: '123' };
+
+        const d = Hoek.merge(b, a);
+        expect(d.x).toEqual(1);
+        expect(d.y).toEqual(2);
+        expect(d.z).toEqual(3);
+        expect(d.v).toEqual(5);
+        expect(d.m).toEqual('abc');
+        expect(d.t).toEqual('test');
+        expect(d.s).toEqual(1);
+    });
+
+    it('retains Date properties', () => {
+        const a = { x: new Date(1378776452757) };
+
+        const b = Hoek.merge({}, a);
+        expect(a.x.getTime()).toHoequal(b.x.getTime());
+    });
+
+    it('retains Date properties when merging keys', () => {
+        const a = { x: new Date(1378776452757) };
+
+        const b = Hoek.merge({ x: {} }, a);
+        expect(a.x.getTime()).toHoequal((b.x as Date).getTime());
+    });
+
+    it('overrides Buffer', () => {
+        const a = { x: Buffer.from('abc') };
+
+        Hoek.merge({ x: {} }, a);
+        expect(a.x.toString()).toEqual('abc');
+    });
+
+    it('overrides RegExp', () => {
+        const a = { x: /test/ };
+
+        Hoek.merge({ x: {} }, a);
+        expect(a.x).toHoequal(/test/);
+    });
+
+    it('overrides Symbol properties', () => {
+        const sym = Symbol();
+        const a = { [sym]: 1 };
+
+        Hoek.merge({ [sym]: {} }, a);
+        expect(a[sym]).toEqual(1);
+    });
+
+    it('skips __proto__', () => {
+        const a = '{ "ok": "value", "__proto__": { "test": "value" } }';
+
+        const b = Hoek.merge({}, JSON.parse(a));
+        expect(b).toHoequal({ ok: 'value' });
+        expect(b.test).toBeUndefined();
+    });
+});
+
+describe('applyToDefaults()', () => {
+    it('throws when target is null', () => {
+        expect(() => {
+            Hoek.applyToDefaults(null as never, {});
+        }).toThrow('Invalid defaults value: must be an object');
+    });
+
+    it('throws when options are invalid', () => {
+        expect(() => {
+            Hoek.applyToDefaults({}, {}, false as never);
+        }).toThrow('Invalid options: must be an object');
+
+        expect(() => {
+            Hoek.applyToDefaults({}, {}, 123 as never);
+        }).toThrow('Invalid options: must be an object');
+    });
+
+    it('returns null if source is false', () => {
+        const defaults = {
+            a: 1,
+            b: 2,
+            c: {
+                d: 3,
+                e: [5, 6],
+            },
+            f: 6,
+            g: 'test',
+        };
+
+        const result = Hoek.applyToDefaults(defaults, false);
+        expect(result).toBeNull();
+    });
+
+    it('returns null if source is null', () => {
+        const defaults = {
+            a: 1,
+            b: 2,
+            c: {
+                d: 3,
+                e: [5, 6],
+            },
+            f: 6,
+            g: 'test',
+        };
+
+        const result = Hoek.applyToDefaults(defaults, null as never);
+        expect(result).toBeNull();
+    });
+
+    it('returns null if source is undefined', () => {
+        const defaults = {
+            a: 1,
+            b: 2,
+            c: {
+                d: 3,
+                e: [5, 6],
+            },
+            f: 6,
+            g: 'test',
+        };
+
+        const result = Hoek.applyToDefaults(defaults, undefined);
+        expect(result).toBeNull();
+    });
+
+    it('returns a copy of defaults if source is true', () => {
+        const defaults = {
+            a: 1,
+            b: 2,
+            c: {
+                d: 3,
+                e: [5, 6],
+            },
+            f: 6,
+            g: 'test',
+        };
+
+        const result = Hoek.applyToDefaults(defaults, true);
+        expect(result).toHoequal(defaults);
+    });
+
+    it('applies object to defaults', () => {
+        const defaults = {
+            a: 1,
+            b: 2,
+            c: {
+                d: 3,
+                e: [5, 6],
+            },
+            f: 6,
+            g: 'test',
+        };
+
+        const obj = {
+            a: null,
+            c: {
+                e: [4],
+            },
+            f: 0,
+            g: {
+                h: 5,
+            },
+        };
+
+        type D = MergeTypes<typeof defaults, typeof obj>;
+
+        const result = Hoek.applyToDefaults<D>(defaults, obj)!;
+        expect(result.c!.e).toHoequal([4]);
+        expect(result.a).toEqual(1);
+        expect(result.b).toEqual(2);
+        expect(result.f).toEqual(0);
+        expect(result.g).toHoequal({ h: 5 });
+    });
+
+    it('applies object to defaults with null', () => {
+        const defaults = {
+            a: 1,
+            b: 2,
+            c: {
+                d: 3,
+                e: [5, 6],
+            },
+            f: 6,
+            g: 'test',
+        };
+
+        const obj = {
+            a: null,
+            c: {
+                e: [4],
+            },
+            f: 0,
+            g: {
+                h: 5,
+            },
+        };
+
+        type D = MergeTypes<typeof defaults, typeof obj>;
+
+        const result = Hoek.applyToDefaults<D>(defaults, obj, { nullOverride: true })!;
+        expect(result.c!.e).toHoequal([4]);
+        expect(result.a).toBeNull();
+        expect(result.b).toEqual(2);
+        expect(result.f).toEqual(0);
+        expect(result.g).toHoequal({ h: 5 });
+    });
+
+    it('shallow copies the listed keys from source without merging', () => {
+        const defaults = {
+            a: {
+                b: 5,
+                e: 3,
+            },
+            c: {
+                d: 7,
+                g: 1,
+            },
+        };
+
+        const source = {
+            a: {
+                b: 4,
+            },
+            c: {
+                d: 6,
+                f: 7,
+            },
+        };
+
+        type D = MergeTypes<typeof defaults, typeof source>;
+
+        const merged = Hoek.applyToDefaults<D>(defaults, source, { shallow: ['a'] })!;
+        expect(merged).toHoequal({ a: { b: 4 }, c: { d: 6, g: 1, f: 7 } });
+        expect(merged.a).toBe(source.a);
+        expect(merged.a).not.toHoequal(defaults.a);
+        expect(merged.c).not.toHoequal(source.c);
+        expect(merged.c).not.toHoequal(defaults.c);
+    });
+
+    it('shallow copies the nested keys (override)', () => {
+        const defaults = {
+            a: {
+                b: 5,
+            },
+            c: {
+                d: 7,
+                g: 1,
+            },
+        };
+
+        const source = {
+            a: {
+                b: 4,
+            },
+            c: {
+                d: 6,
+                g: {
+                    h: 8,
+                },
+            },
+        };
+
+        type D = MergeTypes<typeof defaults, typeof source>;
+
+        const merged = Hoek.applyToDefaults<D>(defaults, source, { shallow: ['c.g'] })!;
+        expect(merged).toHoequal({ a: { b: 4 }, c: { d: 6, g: { h: 8 } } });
+        expect(merged.c!.g).toBe(source.c.g);
+    });
+
+    it('shallow copies the nested keys (missing)', () => {
+        const defaults = {
+            a: {
+                b: 5,
+            },
+        };
+
+        const source = {
+            a: {
+                b: 4,
+            },
+            c: {
+                g: {
+                    h: 8,
+                },
+            },
+        };
+
+        type D = MergeTypes<typeof defaults, typeof source>;
+
+        const merged = Hoek.applyToDefaults<D>(defaults, source, { shallow: ['c.g'] })!;
+        expect(merged).toHoequal({ a: { b: 4 }, c: { g: { h: 8 } } });
+        expect(merged.c!.g).toBe(source.c.g);
+    });
+
+    it('shallow copies the nested keys (override)', () => {
+        const defaults = {
+            a: {
+                b: 5,
+            },
+            c: {
+                g: {
+                    d: 7,
+                },
+            },
+        };
+
+        const source = {
+            a: {
+                b: 4,
+            },
+            c: {
+                g: {
+                    h: 8,
+                },
+            },
+        };
+
+        type D = MergeTypes<typeof defaults, typeof source>;
+
+        const merged = Hoek.applyToDefaults<D>(defaults, source, { shallow: ['c.g'] })!;
+        expect(merged).toHoequal({ a: { b: 4 }, c: { g: { h: 8 } } });
+        expect(merged.c!.g).toBe(source.c.g);
+    });
+
+    it('shallow copies the nested keys (deeper)', () => {
+        const defaults = {
+            a: {
+                b: 5,
+            },
+        };
+
+        const source = {
+            a: {
+                b: 4,
+            },
+            c: {
+                g: {
+                    r: {
+                        h: 8,
+                    },
+                },
+            },
+        };
+
+        type D = MergeTypes<typeof defaults, typeof source>;
+
+        const merged = Hoek.applyToDefaults<D>(defaults, source, { shallow: ['c.g.r'] })!;
+        expect(merged).toHoequal({ a: { b: 4 }, c: { g: { r: { h: 8 } } } });
+        expect(merged.c!.g.r).toBe(source.c.g.r);
+    });
+
+    it('shallow copies the nested keys (not present)', () => {
+        const defaults = {
+            a: {
+                b: 5,
+            },
+        };
+
+        const source = {
+            a: {
+                b: 4,
+            },
+            c: {
+                g: {
+                    r: {
+                        h: 8,
+                    },
+                },
+            },
+        };
+
+        type D = MergeTypes<typeof defaults, typeof source>;
+
+        const merged = Hoek.applyToDefaults<D>(defaults, source, { shallow: ['x.y'] });
+        expect(merged).toHoequal({ a: { b: 4 }, c: { g: { r: { h: 8 } } } });
+    });
+
+    it('shallow copies the nested keys (non-object)', () => {
+        const defaults = {
+            // All falsy values:
+            _undefined: {
+                a: 1,
+            },
+            _null: {
+                a: 2,
+            },
+            _false: {
+                a: 3,
+            },
+            _emptyString: {
+                a: 4,
+            },
+            _zero: {
+                a: 5,
+            },
+            _NaN: {
+                a: 6,
+            },
+            // Other non-object values:
+            _string: {
+                a: 7,
+            },
+            _number: {
+                a: 8,
+            },
+            _true: {
+                a: 9,
+            },
+            _function: {
+                a: 10,
+            },
+        };
+
+        const source = {
+            _undefined: undefined,
+            _null: null,
+            _false: false,
+            _emptyString: '',
+            _zero: 0,
+            _NaN: NaN,
+            _string: 'foo',
+            _number: 42,
+            _true: true,
+            _function: () => {},
+        };
+
+        type D = MergeTypes<typeof defaults, typeof source>;
+
+        const merged = Hoek.applyToDefaults<D>(defaults, source, {
+            shallow: [
+                '_undefined.a',
+                '_null.a',
+                '_false.a',
+                '_emptyString.a',
+                '_zero.a',
+                '_NaN.a',
+                '_string.a',
+                '_number.a',
+                '_true.a',
+                '_function.a',
+            ],
+        });
+        expect(merged).toHoequal({
+            _undefined: { a: 1 },
+            _null: { a: 2 },
+            _false: false,
+            _emptyString: '',
+            _zero: 0,
+            _NaN: NaN,
+            _string: 'foo',
+            _number: 42,
+            _true: true,
+            _function: source._function,
+        });
+    });
+
+    it('shallow copies the listed keys in the defaults', () => {
+        const defaults = {
+            a: {
+                b: 1,
+            },
+        };
+
+        const merged = Hoek.applyToDefaults(defaults, {}, { shallow: ['a'] })!;
+        expect(merged.a).toBe(defaults.a);
+    });
+
+    it('shallow copies the listed keys in the defaults (true)', () => {
+        const defaults = {
+            a: {
+                b: 1,
+            },
+        };
+
+        const merged = Hoek.applyToDefaults(defaults, true, { shallow: ['a'] })!;
+        expect(merged.a).toBe(defaults.a);
+    });
+
+    it('returns null on false', () => {
+        const defaults = {
+            a: {
+                b: 1,
+            },
+        };
+
+        const merged = Hoek.applyToDefaults(defaults, false, { shallow: ['a'] });
+        expect(merged).toBeNull();
+    });
+
+    it('handles missing shallow key in defaults', () => {
+        const defaults = {
+            a: {
+                b: 1,
+            },
+        };
+
+        const options = {
+            a: {
+                b: 4,
+            },
+            c: {
+                d: 2,
+            },
+        };
+
+        type D = MergeTypes<typeof defaults, typeof options>;
+
+        const merged = Hoek.applyToDefaults<D>(defaults, options, { shallow: ['c'] })!;
+        expect(merged).toHoequal({ a: { b: 4 }, c: { d: 2 } });
+        expect(merged.c).toBe(options.c);
+
+        expect(Hoek.applyToDefaults(defaults, true, { shallow: ['c'] })).toHoequal({ a: { b: 1 } });
+    });
+
+    it('throws on missing defaults', () => {
+        expect(() => Hoek.applyToDefaults(null as never, {}, { shallow: ['a'] })).toThrow(
+            'Invalid defaults value: must be an object',
+        );
+    });
+
+    it('throws on invalid defaults', () => {
+        expect(() => Hoek.applyToDefaults('abc', {}, { shallow: ['a'] })).toThrow(
+            'Invalid defaults value: must be an object',
+        );
+    });
+
+    it('throws on invalid source', () => {
+        expect(() => Hoek.applyToDefaults({}, 'abc', { shallow: ['a'] })).toThrow(
+            'Invalid source value: must be true, falsy or an object',
+        );
+    });
+
+    it('throws on missing keys', () => {
+        expect(() => Hoek.applyToDefaults({}, true, { shallow: 123 } as never)).toThrow('Invalid keys');
+    });
+
+    it('handles array keys', () => {
+        const sym = Symbol();
+
+        const defaults = {
+            a: {
+                b: 5,
+                e: 3,
+            },
+            c: {
+                d: 7,
+                [sym]: {
+                    f: 9,
+                },
+            },
+        };
+
+        const options = {
+            a: {
+                b: 4,
+            },
+            c: {
+                d: 6,
+                [sym]: {
+                    g: 1,
+                },
+            },
+        };
+
+        type D = MergeTypes<typeof defaults, typeof options>;
+
+        const merged = Hoek.applyToDefaults<D>(defaults, options, { shallow: [['c', sym]] })!;
+        expect(merged).toHoequal({ a: { b: 4, e: 3 }, c: { d: 6, [sym]: { g: 1 } } });
+        expect(merged.c![sym]).toBe(options.c[sym]);
+    });
+
+    it('does not modify shallow entries in source', () => {
+        const defaults = {
+            a: {
+                b: 5,
+            },
+        };
+
+        const source = {} as { a?: { b: number } };
+
+        Object.defineProperty(source, 'a', { value: { b: 4 } });
+
+        type D = MergeTypes<typeof defaults, typeof source>;
+
+        const merged = Hoek.applyToDefaults<D>(defaults, source, { shallow: ['a'] })!;
+        expect(merged).toHoequal({ a: { b: 4 } });
+        expect(merged.a).toBe(source.a);
+        expect(merged.a).not.toHoequal(defaults.a);
+    });
+
+    it('should respect nullOverride when shallow is used', () => {
+        const defaults = { host: 'localhost', port: 8000 };
+        const source = { host: null, port: 8080 };
+
+        type D = MergeTypes<typeof defaults, typeof source>;
+
+        const result = Hoek.applyToDefaults<D>(defaults, source, { nullOverride: true, shallow: [] })!;
+        expect(result.host).toBeNull();
+        expect(result.port).toEqual(8080);
+    });
+});
+
+describe('deepEqual()', () => {
+    it('compares identical references', () => {
+        const x = {};
+
+        expect(Hoek.deepEqual(x, x)).toBe(true);
+    });
+
+    it('compares simple values', () => {
+        expect(Hoek.deepEqual('x', 'x')).toBe(true);
+        expect(Hoek.deepEqual('x', 'y')).toBe(false);
+        expect(Hoek.deepEqual('x1', 'x')).toBe(false);
+        expect(Hoek.deepEqual(-0, +0)).toBe(false);
+        expect(Hoek.deepEqual(-0, -0)).toBe(true);
+        expect(Hoek.deepEqual(+0, +0)).toBe(true);
+        expect(Hoek.deepEqual(+0, -0)).toBe(false);
+        expect(Hoek.deepEqual(1, 1)).toBe(true);
+        expect(Hoek.deepEqual(0, 0)).toBe(true);
+        expect(Hoek.deepEqual(-1, 1)).toBe(false);
+        expect(Hoek.deepEqual(NaN, 0)).toBe(false);
+        expect(Hoek.deepEqual(NaN, NaN)).toBe(true);
+    });
+
+    it('compares different types', () => {
+        expect(Hoek.deepEqual([], 5, { prototype: false })).toBe(false);
+        expect(Hoek.deepEqual(5, [], { prototype: false })).toBe(false);
+        expect(Hoek.deepEqual({}, null, { prototype: false })).toBe(false);
+        expect(Hoek.deepEqual(null, {}, { prototype: false })).toBe(false);
+        expect(Hoek.deepEqual('abc', {}, { prototype: false })).toBe(false);
+        expect(Hoek.deepEqual({}, 'abc', { prototype: false })).toBe(false);
+    });
+
+    it('compares empty structures', () => {
+        expect(Hoek.deepEqual([], [])).toBe(true);
+        expect(Hoek.deepEqual({}, {})).toBe(true);
+        expect(Hoek.deepEqual([], {})).toBe(false);
+        expect(Hoek.deepEqual([], {}, { prototype: false })).toBe(false);
+        expect(Hoek.deepEqual({}, [], { prototype: false })).toBe(false);
+    });
+
+    it('compares empty arguments object', () => {
+        const compare = function () {
+            expect(Hoek.deepEqual([], arguments)).toBe(false); // eslint-disable-line prefer-rest-params
+        };
+
+        compare();
+    });
+
+    it('compares empty arguments objects', () => {
+        const compare = function () {
+            const arg1 = arguments; // eslint-disable-line prefer-rest-params
+
+            const inner = function () {
+                // callee is not supported in strict mode, was previously false becuse callee was different
+                expect(Hoek.deepEqual(arg1, arguments)).toBe(true); // eslint-disable-line prefer-rest-params
+            };
+
+            inner();
+        };
+
+        compare();
+    });
+
+    it('compares symbol object properties', () => {
+        const sym = Symbol();
+
+        const ne = {};
+        Object.defineProperty(ne, sym, { value: true });
+
+        expect(Hoek.deepEqual({ [sym]: { c: true } }, { [sym]: { c: true } })).toBe(true);
+        expect(Hoek.deepEqual({ [sym]: { c: true } }, { [sym]: { c: false } })).toBe(false);
+        expect(Hoek.deepEqual({ [sym]: { c: true } }, { [sym]: true })).toBe(false);
+        expect(Hoek.deepEqual({ [sym]: undefined }, { [sym]: undefined })).toBe(true);
+        expect(Hoek.deepEqual({ [sym]: undefined }, {})).toBe(false);
+        expect(Hoek.deepEqual({}, { [sym]: undefined })).toBe(false);
+
+        expect(Hoek.deepEqual({}, ne)).toBe(true);
+        expect(Hoek.deepEqual(ne, {})).toBe(true);
+        expect(Hoek.deepEqual({ [sym]: true }, ne)).toBe(false);
+        expect(Hoek.deepEqual(ne, { [sym]: true })).toBe(false);
+        expect(Hoek.deepEqual(ne, { [Symbol()]: undefined })).toBe(false);
+
+        expect(Hoek.deepEqual({ [sym]: true }, { [sym]: true })).toBe(true);
+        expect(Hoek.deepEqual({ [sym]: true }, {})).toBe(false);
+        expect(Hoek.deepEqual({ [sym]: true }, {}, { symbols: false })).toBe(true);
+    });
+
+    it('compares dates', () => {
+        expect(Hoek.deepEqual(new Date(2015, 1, 1), new Date('2015/02/01'))).toBe(true);
+        expect(Hoek.deepEqual(new Date(100), new Date(101))).toBe(false);
+        expect(Hoek.deepEqual(new Date(), {})).toBe(false);
+        expect(Hoek.deepEqual(new Date(2015, 1, 1), new Date('2015/02/01'), { prototype: false })).toBe(true);
+        expect(Hoek.deepEqual(new Date(), {}, { prototype: false })).toBe(false);
+        expect(Hoek.deepEqual({}, new Date(), { prototype: false })).toBe(false);
+    });
+
+    it('compares regular expressions', () => {
+        expect(Hoek.deepEqual(/\s/, new RegExp('\\\s'))).toBe(true);
+        expect(Hoek.deepEqual(/\s/g, /\s/g)).toBe(true);
+        expect(Hoek.deepEqual(/a/, {}, { prototype: false })).toBe(false);
+        expect(Hoek.deepEqual(/\s/g, /\s/i)).toBe(false);
+        expect(Hoek.deepEqual(/a/g, /b/g)).toBe(false);
+    });
+
+    it('compares errors', () => {
+        expect(Hoek.deepEqual(new Error('a'), new Error('a'))).toBe(true);
+        expect(Hoek.deepEqual(new Error('a'), new Error('b'))).toBe(false);
+
+        expect(Hoek.deepEqual(new Error('a'), new TypeError('a'))).toBe(false);
+        expect(Hoek.deepEqual(new Error('a'), new TypeError('a'), { prototype: false })).toBe(false);
+
+        expect(Hoek.deepEqual(new Error(), {})).toBe(false);
+        expect(Hoek.deepEqual(new Error(), {}, { prototype: false })).toBe(false);
+
+        expect(Hoek.deepEqual({}, new Error())).toBe(false);
+        expect(Hoek.deepEqual({}, new Error(), { prototype: false })).toBe(false);
+
+        const error = new Error('a');
+        expect(Hoek.deepEqual(Hoek.clone(error), error)).toBe(true);
+        expect(Hoek.deepEqual(Hoek.clone(error), error, { prototype: false })).toBe(true);
+    });
+
+    it('compares arrays', () => {
+        expect(Hoek.deepEqual([[1]], [[1]])).toBe(true);
+        expect(Hoek.deepEqual([1, 2, 3], [1, 2, 3])).toBe(true);
+        expect(Hoek.deepEqual([1, 2, 3], [1, 3, 2])).toBe(false);
+        expect(Hoek.deepEqual([1, 2, 3], [1, 2])).toBe(false);
+        expect(Hoek.deepEqual([1], [1])).toBe(true);
+        const item1 = { key: 'value1' };
+        const item2 = { key: 'value2' };
+        expect(Hoek.deepEqual([item1, item1], [item1, item2])).toBe(false);
+    });
+
+    it('compares sets', () => {
+        expect(Hoek.deepEqual(new Set(), new Set())).toBe(true);
+        expect(Hoek.deepEqual(new Set([1]), new Set([1]))).toBe(true);
+        expect(Hoek.deepEqual(new Set([]), new Set([]))).toBe(true);
+        expect(Hoek.deepEqual(new Set([1, 2, 3]), new Set([1, 2, 3]))).toBe(true);
+        expect(Hoek.deepEqual(new Set([1, 2, 3]), new Set([3, 2, 1]))).toBe(true);
+        expect(Hoek.deepEqual(new Set([1, 2, 3]), new Set([1, 2, 4]))).toBe(false);
+        expect(Hoek.deepEqual(new Set([1, 2, 3]), new Set([1, 2]))).toBe(false);
+        expect(Hoek.deepEqual(new Set([1, 2, 1]), new Set([1, 2]))).toBe(true);
+        expect(Hoek.deepEqual(new Set([+0]), new Set([-0]))).toBe(true);
+        expect(Hoek.deepEqual(new Set([NaN]), new Set([NaN]))).toBe(true);
+        expect(Hoek.deepEqual(new Set([1, {}]), new Set([1, {}]))).toBe(true);
+        expect(Hoek.deepEqual(new Set([1, {}]), new Set([{}, 1]))).toBe(true);
+        expect(Hoek.deepEqual(new Set([1, {}, {}]), new Set([{}, 1, {}]))).toBe(true);
+        expect(Hoek.deepEqual(new Set([1, { a: 1 }]), new Set([{ a: 0 }, 1]))).toBe(false);
+        expect(Hoek.deepEqual(new WeakSet(), new WeakSet())).toBe(true);
+        const obj = {};
+        expect(Hoek.deepEqual(new WeakSet([obj]), new WeakSet())).toBe(true);
+        expect(Hoek.deepEqual(new WeakSet(), new Set(), { prototype: false })).toBe(false);
+
+        const sets = [new Set(), new Set()].map((set) => {
+            (set as any).modified = true;
+            return set;
+        });
+        expect(Hoek.deepEqual(sets[0], sets[1])).toBe(true);
+        expect(Hoek.deepEqual(sets[0], new Set())).toBe(false);
+    });
+
+    it('compares extended sets', () => {
+        class PrivateSet extends Set {
+            has(): boolean {
+                throw new Error('not allowed');
+            }
+        }
+
+        const entries = ['a', undefined];
+        expect(Hoek.deepEqual(new PrivateSet(), new PrivateSet())).toBe(true);
+        expect(Hoek.deepEqual(new PrivateSet(entries), new PrivateSet(entries))).toBe(true);
+        expect(Hoek.deepEqual(new PrivateSet(entries), new Set(entries), { prototype: false })).toBe(true);
+        expect(Hoek.deepEqual(new PrivateSet(entries), new Set(entries), { prototype: true })).toBe(false);
+        expect(Hoek.deepEqual(new PrivateSet(), new PrivateSet(entries))).toBe(false);
+        expect(Hoek.deepEqual(new PrivateSet(entries), new PrivateSet())).toBe(false);
+
+        class LockableSet extends Set {
+            locked: boolean;
+
+            constructor(values?: any[], locked = true) {
+                super(values);
+                this.locked = locked;
+            }
+
+            has(key: any) {
+                if (this.locked) {
+                    throw new Error('not allowed');
+                }
+
+                return super.has(key);
+            }
+        }
+
+        expect(Hoek.deepEqual(new LockableSet(), new LockableSet())).toBe(true);
+        expect(Hoek.deepEqual(new LockableSet(entries), new LockableSet(entries))).toBe(true);
+        expect(Hoek.deepEqual(new LockableSet(entries, false), new LockableSet(entries, false))).toBe(true);
+        expect(Hoek.deepEqual(new LockableSet(entries, true), new LockableSet(entries, false))).toBe(false);
+        expect(Hoek.deepEqual(new LockableSet(entries, false), new LockableSet(entries, true))).toBe(false);
+        expect(Hoek.deepEqual(new LockableSet(entries), new Set(entries), { prototype: false })).toBe(false);
+        expect(Hoek.deepEqual(new LockableSet(entries), new PrivateSet(entries), { prototype: false })).toBe(false);
+    });
+
+    it('compares maps', () => {
+        const item1 = { key: 'value1' };
+        const item2 = { key: 'value2' };
+        expect(Hoek.deepEqual(new Map(), new Map())).toBe(true);
+        expect(Hoek.deepEqual(new Map([[1, {}]]), new Map([[1, {}]]))).toBe(true);
+        expect(Hoek.deepEqual(new Map([[1, item1]]), new Map([[1, item1]]))).toBe(true);
+        expect(Hoek.deepEqual(new Map([[1, item1]]), new Map([[1, item2]]))).toBe(false);
+        expect(Hoek.deepEqual(new Map([[1, undefined]]), new Map([[1, undefined]]))).toBe(true);
+        expect(Hoek.deepEqual(new Map([[1, undefined]]), new Map([[2, undefined]]))).toBe(false);
+        expect(
+            Hoek.deepEqual(
+                new Map([[1, {}]]),
+                new Map([
+                    [1, {}],
+                    [2, {}],
+                ]),
+            ),
+        ).toBe(false);
+        expect(Hoek.deepEqual(new Map([[item1, 1]]), new Map([[item1, 1]]))).toBe(true);
+        expect(Hoek.deepEqual(new Map([[{}, 1]]), new Map([[{}, 1]]))).toBe(false);
+        expect(Hoek.deepEqual(new WeakMap(), new WeakMap())).toBe(true);
+        expect(Hoek.deepEqual(new WeakMap([[item1, 1]]), new WeakMap())).toBe(true);
+        expect(Hoek.deepEqual(new WeakMap(), new Map(), { prototype: false })).toBe(false);
+
+        const maps = [new Map(), new Map()].map((map) => {
+            (map as any).modified = true;
+            return map;
+        });
+        expect(Hoek.deepEqual(maps[0], maps[1])).toBe(true);
+        expect(Hoek.deepEqual(maps[0], new Map())).toBe(false);
+    });
+
+    it('compares extended maps', () => {
+        class PrivateMap extends Map {
+            constructor(args?: any) {
+                // @ts-expect-error - Map typing is a MapConstructor, but for whatever reason, it thinks it doesn't accept arguments
+                super(args);
+            }
+
+            get() {
+                throw new Error('not allowed');
+            }
+        }
+
+        const entries = [
+            ['a', 1],
+            ['b', undefined],
+        ] as const;
+
+        expect(Hoek.deepEqual(new PrivateMap(), new PrivateMap())).toBe(true);
+        expect(Hoek.deepEqual(new PrivateMap(entries), new PrivateMap(entries))).toBe(true);
+        expect(Hoek.deepEqual(new PrivateMap(entries), new Map(entries), { prototype: false })).toBe(true);
+        expect(Hoek.deepEqual(new PrivateMap(entries), new Map(entries), { prototype: true })).toBe(false);
+        expect(Hoek.deepEqual(new PrivateMap(), new PrivateMap(entries))).toBe(false);
+        expect(Hoek.deepEqual(new PrivateMap(entries), new PrivateMap())).toBe(false);
+
+        class LockableMap extends Map {
+            locked: boolean;
+
+            constructor(kvs?: any, locked = true) {
+                // https://stackoverflow.com/questions/70677360/in-typescript-when-i-use-mymap-to-extends-map-but-it-s-show-expected-0-argument
+                // https://stackoverflow.com/questions/67631458/no-overload-matches-this-call-while-constructing-map-from-array
+                // @ts-expect-error - See above
+                super(kvs);
+
+                this.locked = locked;
+            }
+
+            get() {
+                if (this.locked) {
+                    throw new Error('not allowed');
+                }
+            }
+        }
+
+        expect(Hoek.deepEqual(new LockableMap(), new LockableMap())).toBe(true);
+        expect(Hoek.deepEqual(new LockableMap(entries), new LockableMap(entries))).toBe(true);
+        expect(Hoek.deepEqual(new LockableMap(entries, false), new LockableMap(entries, false))).toBe(true);
+        expect(Hoek.deepEqual(new LockableMap(entries, true), new LockableMap(entries, false))).toBe(false);
+        expect(Hoek.deepEqual(new LockableMap(entries, false), new LockableMap(entries, true))).toBe(false);
+        expect(Hoek.deepEqual(new LockableMap(entries), new Map(entries), { prototype: false })).toBe(false);
+        expect(Hoek.deepEqual(new LockableMap(entries), new PrivateMap(entries), { prototype: false })).toBe(false);
+    });
+
+    it('compares promises', () => {
+        const a = new Promise(() => {});
+
+        expect(Hoek.deepEqual(a, a)).toBe(true);
+        expect(Hoek.deepEqual(a, new Promise(() => {}))).toBe(false);
+    });
+
+    it('compares urls', () => {
+        const a = new URL('https://hapi.dev/');
+
+        expect(Hoek.deepEqual(a, a)).toBe(true);
+        expect(Hoek.deepEqual(a, new URL('https://hapi.dev/?new'))).toBe(false);
+        expect(Hoek.deepEqual(a, {}, { prototype: false })).toBe(false);
+    });
+
+    it('compares buffers', () => {
+        expect(Hoek.deepEqual(Buffer.from([1, 2, 3]), Buffer.from([1, 2, 3]))).toBe(true);
+        expect(Hoek.deepEqual(Buffer.from([1, 2, 3]), Buffer.from([1, 3, 2]))).toBe(false);
+        expect(Hoek.deepEqual(Buffer.from([1, 2, 3]), Buffer.from([1, 2]))).toBe(false);
+        expect(Hoek.deepEqual(Buffer.from([1, 2, 3]), {})).toBe(false);
+        expect(Hoek.deepEqual(Buffer.from([1, 2, 3]), [1, 2, 3])).toBe(false);
+    });
+
+    it('compares string objects', () => {
+        /* eslint-disable no-new-wrappers */
+        expect(Hoek.deepEqual(new String('a'), new String('a'))).toBe(true);
+        expect(Hoek.deepEqual(new String('a'), new String('b'))).toBe(false);
+        expect(Hoek.deepEqual(new String(''), {}, { prototype: false })).toBe(false);
+        expect(Hoek.deepEqual({}, new String(''), { prototype: false })).toBe(false);
+        expect(Hoek.deepEqual(new String('a'), 'a', { prototype: false })).toBe(false);
+        expect(Hoek.deepEqual('a', new String('a'), { prototype: false })).toBe(false);
+        /* eslint-enable no-new-wrappers */
+    });
+
+    it('compares number objects', () => {
+        /* eslint-disable no-new-wrappers */
+        expect(Hoek.deepEqual(new Number(1), new Number(1))).toBe(true);
+        expect(Hoek.deepEqual(new Number(1), new Number(2))).toBe(false);
+        expect(Hoek.deepEqual(new Number(+0), new Number(-0))).toBe(false);
+        expect(Hoek.deepEqual(new Number(NaN), new Number(NaN))).toBe(true);
+        expect(Hoek.deepEqual(new Number(0), {}, { prototype: false })).toBe(false);
+        expect(Hoek.deepEqual({}, new Number(0), { prototype: false })).toBe(false);
+        expect(Hoek.deepEqual(new Number(1), 1, { prototype: false })).toBe(false);
+        expect(Hoek.deepEqual(1, new Number(1), { prototype: false })).toBe(false);
+        /* eslint-enable no-new-wrappers */
+    });
+
+    it('compares boolean objects', () => {
+        /* eslint-disable no-new-wrappers */
+        expect(Hoek.deepEqual(new Boolean(true), new Boolean(true))).toBe(true);
+        expect(Hoek.deepEqual(new Boolean(true), new Boolean(false))).toBe(false);
+        expect(Hoek.deepEqual(new Boolean(false), {}, { prototype: false })).toBe(false);
+        expect(Hoek.deepEqual({}, new Boolean(false), { prototype: false })).toBe(false);
+        expect(Hoek.deepEqual(new Boolean(true), true, { prototype: false })).toBe(false);
+        expect(Hoek.deepEqual(true, new Boolean(true), { prototype: false })).toBe(false);
+        /* eslint-enable no-new-wrappers */
+    });
+
+    it('compares objects', () => {
+        expect(Hoek.deepEqual({ a: 1, b: 2, c: 3 }, { a: 1, b: 2, c: 3 })).toBe(true);
+        expect(Hoek.deepEqual({ foo: 'bar' }, { foo: 'baz' })).toBe(false);
+        expect(Hoek.deepEqual({ foo: { bar: 'foo' } }, { foo: { bar: 'baz' } })).toBe(false);
+        expect(Hoek.deepEqual({ foo: undefined }, {})).toBe(false);
+        expect(Hoek.deepEqual({}, { foo: undefined })).toBe(false);
+        expect(Hoek.deepEqual({ foo: undefined }, { bar: undefined })).toBe(false);
+    });
+
+    it('compares functions', () => {
+        const f1 = () => 1;
+        const f2 = () => 2;
+        const f2a = () => 2;
+
+        expect(Hoek.deepEqual({ f1 }, { f1 })).toBe(true);
+        expect(Hoek.deepEqual({ f1 }, { f1: f2 })).toBe(false);
+        expect(Hoek.deepEqual({ f2 }, { f2: f2a })).toBe(false);
+        expect(Hoek.deepEqual({ f2 }, { f2: f2a }, { deepFunction: true })).toBe(true);
+        expect(Hoek.deepEqual({ f2 }, { f2: f1 }, { deepFunction: true })).toBe(false);
+
+        const f3 = () => 3;
+        f3.x = 1;
+
+        const f3a = () => 3;
+        f3a.x = 1;
+
+        const f3b = () => 3;
+        f3b.x = 2;
+
+        expect(Hoek.deepEqual({ f3 }, { f3: f3a }, { deepFunction: true })).toBe(true);
+        expect(Hoek.deepEqual({ f3 }, { f3: f3b }, { deepFunction: true })).toBe(false);
+    });
+
+    it('skips keys', () => {
+        expect(Hoek.deepEqual({ a: 1, b: 2, c: 3 }, { a: 1, b: 2, c: 4 })).toBe(false);
+        expect(Hoek.deepEqual({ a: 1, b: 2, c: 3 }, { a: 1, b: 2, c: 4 }, { skip: ['c'] })).toBe(true);
+
+        expect(Hoek.deepEqual({ a: 1, b: 2, c: 3 }, { a: 1, b: 2 })).toBe(false);
+        expect(Hoek.deepEqual({ a: 1, b: 2, c: 3 }, { a: 1, b: 2 }, { skip: ['c'] })).toBe(true);
+
+        const sym = Symbol('test');
+        expect(Hoek.deepEqual({ a: 1, b: 2, [sym]: 3 }, { a: 1, b: 2, [sym]: 4 })).toBe(false);
+        expect(Hoek.deepEqual({ a: 1, b: 2, [sym]: 3 }, { a: 1, b: 2, [sym]: 4 }, { skip: [sym] })).toBe(true);
+
+        expect(Hoek.deepEqual({ a: 1, b: 2, [sym]: 3 }, { a: 1, b: 2 })).toBe(false);
+        expect(Hoek.deepEqual({ a: 1, b: 2, [sym]: 3 }, { a: 1, b: 2 }, { skip: [sym] })).toBe(true);
+        expect(Hoek.deepEqual({ a: 1, b: 2, [sym]: 3, [Symbol('other')]: true }, { a: 1, b: 2 }, { skip: [sym] })).toBe(
+            false,
+        );
+
+        expect(Hoek.deepEqual({ a: 1, b: 2 }, { a: 1 }, { skip: ['a'] })).toBe(false);
+        expect(Hoek.deepEqual({ a: 1 }, { a: 1, b: 2 }, { skip: ['a'] })).toBe(false);
+    });
+
+    it('handles circular dependency', () => {
+        const a = {} as any;
+        a.x = a;
+
+        const b = Hoek.clone(a);
+        expect(Hoek.deepEqual(a, b)).toBe(true);
+    });
+
+    it('handles obj only circular dependency', () => {
+        const a = {} as any;
+        a.x = a;
+
+        const b = { x: {} };
+        expect(Hoek.deepEqual(a, b)).toBe(false);
+        expect(Hoek.deepEqual(b, a)).toBe(false);
+    });
+
+    it('handles irregular circular dependency', () => {
+        const a = {} as any;
+        a.x = a;
+
+        const b = { x: {} } as any;
+
+        b.x.x = b;
+
+        const c = { x: { x: {} } } as any;
+        c.x.x.x = c;
+
+        expect(Hoek.deepEqual(a, b)).toBe(true);
+        expect(Hoek.deepEqual(b, a)).toBe(true);
+        expect(Hoek.deepEqual(a, c)).toBe(true);
+        expect(Hoek.deepEqual(b, c)).toBe(true);
+        expect(Hoek.deepEqual(c, a)).toBe(true);
+        expect(Hoek.deepEqual(c, b)).toBe(true);
+
+        b.x.y = 1;
+
+        expect(Hoek.deepEqual(a, b)).toBe(false);
+        expect(Hoek.deepEqual(b, a)).toBe(false);
+    });
+
+    it('handles cross circular dependency', () => {
+        const a = {} as any;
+        const b = { x: {}, y: a } as any;
+
+        b.x.x = b;
+        b.x.y = b.x;
+        a.x = b;
+        a.y = a;
+
+        expect(Hoek.deepEqual(b, a)).toBe(true);
+        expect(Hoek.deepEqual(a, b)).toBe(true);
+
+        b.x.y = 1;
+
+        expect(Hoek.deepEqual(b, a)).toBe(false);
+        expect(Hoek.deepEqual(a, b)).toBe(false);
+    });
+
+    it('handles reuse of objects', () => {
+        const date1 = { year: 2018, month: 1, day: 1 };
+        const date2 = { year: 2000, month: 1, day: 1 };
+
+        expect(Hoek.deepEqual({ start: date1, end: date1 }, { start: date1, end: date2 })).toBe(false);
+    });
+
+    it('handles valueOf() that throws', () => {
+        const throwing = class {
+            value: string;
+
+            constructor(value: string) {
+                this.value = value;
+            }
+
+            valueOf() {
+                throw new Error('failed');
+            }
+        };
+
+        expect(Hoek.deepEqual(new throwing('a'), new throwing('a'))).toBe(true);
+        expect(Hoek.deepEqual(new throwing('a'), new throwing('b'))).toBe(false);
+        expect(Hoek.deepEqual(new throwing('a'), { value: 'a' }, { prototype: false })).toBe(false);
+        expect(Hoek.deepEqual({ value: 'a' }, new throwing('a'), { prototype: false })).toBe(false);
+    });
+
+    it('handles valueOf() that returns similar value', () => {
+        const identity = class {
+            value: string;
+
+            constructor(value: string) {
+                this.value = value;
+            }
+
+            valueOf() {
+                return { value: this.value };
+            }
+        };
+
+        expect(Hoek.deepEqual(new identity('a'), new identity('a'))).toBe(true);
+        expect(Hoek.deepEqual(new identity('a'), new identity('b'))).toBe(false);
+        expect(Hoek.deepEqual(new identity('a'), { value: 'a' }, { prototype: true })).toBe(false);
+        expect(Hoek.deepEqual(new identity('a'), { value: 'a' }, { prototype: false })).toBe(true);
+        expect(Hoek.deepEqual({ value: 'a' }, new identity('a'), { prototype: true })).toBe(false);
+        expect(Hoek.deepEqual({ value: 'a' }, new identity('a'), { prototype: false })).toBe(true);
+    });
+
+    interface BaseItf {
+        value: string;
+        surprice?: number;
+    }
+
+    it('skips enumerable properties on prototype chain', () => {
+        const base: any = function (this: BaseItf, value: string, surprice?: number) {
+            this.value = value;
+
+            if (surprice) {
+                this.surprice = surprice;
+            }
+        } as any;
+
+        Object.defineProperty(base.prototype, 'enum', {
+            enumerable: true,
+            configurable: true,
+            value: true,
+        });
+
+        expect('enum' in new base('a')).toBe(true);
+        expect(Hoek.deepEqual(new base('a'), new base('a'))).toBe(true);
+        expect(Hoek.deepEqual(new base('a'), new base('b'))).toBe(false);
+        expect(Hoek.deepEqual(new base('a'), { value: 'a' }, { prototype: false })).toBe(true);
+        expect(Hoek.deepEqual({ value: 'a' }, new base('a'), { prototype: false })).toBe(true);
+        expect(Hoek.deepEqual(new base('a', 1), { value: 'a', enum: true }, { prototype: false })).toBe(false);
+        expect(Hoek.deepEqual({ value: 'a', enum: true }, new base('a', 1), { prototype: false })).toBe(false);
+    });
+
+    it('skips non-enumerable properties', () => {
+        const base: any = function Base(this: BaseItf, value: string, surprice: number) {
+            this.value = value;
+
+            if (surprice) {
+                this.surprice = surprice;
+            }
+        };
+
+        const createObj = (...args: any[]) => {
+            const obj = new base(...args);
+
+            Object.defineProperty(obj, 'hidden', {
+                enumerable: false,
+                configurable: true,
+                value: true,
+            });
+
+            return obj;
+        };
+
+        expect(Hoek.deepEqual(createObj('a'), createObj('a'))).toBe(true);
+        expect(Hoek.deepEqual(createObj('a'), createObj('b'))).toBe(false);
+        expect(Hoek.deepEqual(createObj('a'), { value: 'a' }, { prototype: false })).toBe(true);
+        expect(Hoek.deepEqual({ value: 'a' }, createObj('a'), { prototype: false })).toBe(true);
+        expect(Hoek.deepEqual(createObj('a', 1), { value: 'a', hidden: true }, { prototype: false })).toBe(false);
+        expect(Hoek.deepEqual({ value: 'a', hidden: true }, createObj('a', 1), { prototype: false })).toBe(false);
+    });
+
+    it('compares an object with property getter while executing it', () => {
+        const obj = {} as any;
+        const value = 1;
+        let execCount = 0;
+
+        Object.defineProperty(obj, 'test', {
+            enumerable: true,
+            configurable: true,
+            get: function () {
+                ++execCount;
+                return value;
+            },
+        });
+
+        const copy = Hoek.clone(obj);
+
+        expect(Hoek.deepEqual(obj, copy)).toBe(true);
+        expect(execCount).toEqual(2);
+        expect(copy.test).toEqual(1);
+        expect(execCount).toEqual(3);
+    });
+
+    it('compares objects with property getters', () => {
+        const obj = {};
+        const ref = {};
+
+        Object.defineProperty(obj, 'test', {
+            enumerable: true,
+            configurable: true,
+            get: function () {
+                return 1;
+            },
+        });
+
+        Object.defineProperty(ref, 'test', {
+            enumerable: true,
+            configurable: true,
+            get: function () {
+                return 2;
+            },
+        });
+
+        expect(Hoek.deepEqual(obj, ref)).toBe(false);
+    });
+
+    it('compares object prototypes', () => {
+        interface Itf {
+            a: number;
+        }
+
+        const Obj: any = function (this: Itf) {
+            this.a = 5;
+        };
+
+        Obj.prototype.b = function () {
+            return this.a;
+        };
+
+        const Ref: any = function (this: Itf) {
+            this.a = 5;
+        };
+
+        Ref.prototype.b = function () {
+            return this.a;
+        };
+
+        expect(Hoek.deepEqual(new Obj(), new Ref())).toBe(false);
+        expect(Hoek.deepEqual(new Obj(), new Obj())).toBe(true);
+        expect(Hoek.deepEqual(new Ref(), new Ref())).toBe(true);
+    });
+
+    it('compares plain objects', () => {
+        const a = Object.create(null);
+        const b = Object.create(null);
+
+        a.b = 'c';
+        b.b = 'c';
+
+        expect(Hoek.deepEqual(a, b)).toBe(true);
+        expect(Hoek.deepEqual(a, { b: 'c' })).toBe(false);
+    });
+
+    it('compares an object with an empty object', () => {
+        const a = { a: 1, b: 2 };
+
+        expect(Hoek.deepEqual({}, a)).toBe(false);
+        expect(Hoek.deepEqual(a, {})).toBe(false);
+    });
+
+    it('compares an object ignoring the prototype', () => {
+        const a = Object.create(null);
+        const b = {};
+
+        expect(Hoek.deepEqual(a, b, { prototype: false })).toBe(true);
+    });
+
+    it('compares an object ignoring the prototype recursively', () => {
+        const a = [Object.create(null)];
+        const b = [{}];
+
+        expect(Hoek.deepEqual(a, b, { prototype: false })).toBe(true);
+    });
+});
+
+describe('intersect()', () => {
+    it('returns the common objects of two arrays', () => {
+        const array1 = [1, 2, 3, 4, 4, 5, 5];
+        const array2 = [5, 4, 5, 6, 7];
+        const common = Hoek.intersect(array1, array2);
+        expect(common).toHoequal([5, 4]);
+    });
+
+    it('returns the common objects of array and set', () => {
+        const array1 = new Set([1, 2, 3, 4, 4, 5, 5]);
+        const array2 = [5, 4, 5, 6, 7];
+        const common = Hoek.intersect(array1, array2);
+        expect(common).toHoequal([5, 4]);
+    });
+
+    it('returns the common objects of set and array', () => {
+        const array1 = [1, 2, 3, 4, 4, 5, 5];
+        const array2 = new Set([5, 4, 5, 6, 7]);
+        const common = Hoek.intersect(array1, array2);
+        expect(common).toHoequal([5, 4]);
+    });
+
+    it('returns the common objects of two sets', () => {
+        const array1 = new Set([1, 2, 3, 4, 4, 5, 5]);
+        const array2 = new Set([5, 4, 5, 6, 7]);
+        const common = Hoek.intersect(array1, array2);
+        expect(common).toHoequal([5, 4]);
+    });
+
+    it('returns just the first common object of two arrays', () => {
+        const array1 = [1, 2, 3, 4, 4, 5, 5];
+        const array2 = [5, 4, 5, 6, 7];
+        const common = Hoek.intersect(array1, array2, { first: true });
+        expect(common).toEqual(5);
+    });
+
+    it('returns null when no common and returning just the first common object of two arrays', () => {
+        const array1 = [1, 2, 3, 4, 4, 5, 5];
+        const array2 = [6, 7];
+        const common = Hoek.intersect(array1, array2, { first: true });
+        expect(common).toBeNull();
+    });
+
+    it('returns an empty array if either input is null', () => {
+        expect(Hoek.intersect([1], null)).toHaveLength(0);
+        expect(Hoek.intersect(null, [1])).toHaveLength(0);
+        expect(Hoek.intersect(null, [1], { first: true })).toBeNull();
+    });
+
+    it('returns the common objects of object and array', () => {
+        const array1 = { 1: true, 2: true, 3: true, 4: true, 5: true };
+        const array2 = [5, 4, 5, 6, 7];
+        const common = Hoek.intersect(array1, array2) as number[];
+        expect(common).toHaveLength(2);
+    });
+});
+
+describe('contain()', () => {
+    it('tests strings', () => {
+        expect(Hoek.contain('abc', 'ab')).toBe(true);
+        expect(Hoek.contain('abc', 'abc', { only: true })).toBe(true);
+        expect(Hoek.contain('aaa', 'a', { only: true })).toBe(true);
+        expect(Hoek.contain('aaa', 'a', { only: true, once: true })).toBe(false);
+        expect(Hoek.contain('abc', 'b', { once: true })).toBe(true);
+        expect(Hoek.contain('abc', ['a', 'c'])).toBe(true);
+        expect(Hoek.contain('abc', ['a', 'd'], { part: true })).toBe(true);
+        expect(Hoek.contain('aaa', ['a', 'a'], { only: true, once: true })).toBe(false);
+        expect(Hoek.contain('aaa', ['a', 'a'], { only: true })).toBe(true);
+        expect(Hoek.contain('aaa', ['a', 'a', 'a'], { only: true, once: true })).toBe(true);
+
+        expect(Hoek.contain('abc', 'ac')).toBe(false);
+        expect(Hoek.contain('abcd', 'abc', { only: true })).toBe(false);
+        expect(Hoek.contain('aab', 'a', { only: true })).toBe(false);
+        expect(Hoek.contain('abb', 'b', { once: true })).toBe(false);
+        expect(Hoek.contain('abc', ['a', 'd'])).toBe(false);
+        expect(Hoek.contain('abc', ['ab', 'bc'])).toBe(false); // Overlapping values not supported
+
+        expect(Hoek.contain('', 'a')).toBe(false);
+        expect(Hoek.contain('', 'a', { only: true })).toBe(false);
+
+        expect(Hoek.contain('', '')).toBe(true);
+        expect(Hoek.contain('', '', { only: true })).toBe(true);
+        expect(Hoek.contain('', '', { once: true })).toBe(true);
+        expect(Hoek.contain('', ['', ''])).toBe(true);
+        expect(Hoek.contain('', ['', ''], { only: true })).toBe(true);
+        expect(Hoek.contain('', ['', ''], { once: true })).toBe(false);
+
+        expect(Hoek.contain('a', '')).toBe(true);
+        expect(Hoek.contain('a', '', { only: true })).toBe(false);
+        expect(Hoek.contain('a', '', { once: true })).toBe(false);
+        expect(Hoek.contain('a', ['', ''])).toBe(true);
+        expect(Hoek.contain('a', ['', ''], { only: true })).toBe(false);
+        expect(Hoek.contain('a', ['', ''], { once: true })).toBe(false);
+
+        expect(Hoek.contain('ab', ['a', 'b', 'c'])).toBe(false);
+        expect(Hoek.contain('ab', ['a', 'b', 'c'], { only: true })).toBe(false);
+        expect(Hoek.contain('ab', ['a', 'b', 'c'], { only: true, once: true })).toBe(false);
+
+        expect(Hoek.contain('ab', ['c'], { part: true })).toBe(false);
+        expect(Hoek.contain('ab', ['b'], { part: true })).toBe(true);
+    });
+
+    it('tests arrays', () => {
+        expect(Hoek.contain([1, 2, 3], 1)).toBe(true);
+        expect(Hoek.contain([{ a: 1 }], { a: 1 }, { deep: true })).toBe(true);
+        expect(Hoek.contain([1, 2, 3], [1, 2])).toBe(true);
+        expect(Hoek.contain([{ a: 1 }], [{ a: 1 }], { deep: true })).toBe(true);
+        expect(Hoek.contain([1, 1, 2], [1, 2], { only: true })).toBe(true);
+        expect(Hoek.contain([1, 2], [1, 2], { once: true })).toBe(true);
+        expect(Hoek.contain([1, 2, 3], [1, 4], { part: true })).toBe(true);
+        expect(Hoek.contain([null, 2, 3], [null, 4], { part: true })).toBe(true);
+        expect(Hoek.contain([null], null, { deep: true })).toBe(true);
+        expect(Hoek.contain([[1], [2]], [[1]], { deep: true })).toBe(true);
+        expect(Hoek.contain([[1], [2], 3], [[1]], { deep: true })).toBe(true);
+        expect(Hoek.contain([[1, 2]], [[1]], { deep: true, part: true })).toBe(true);
+        expect(Hoek.contain<(number[] | number)[]>([[1, 2]], [[1], 2], { deep: true, part: true })).toBe(true);
+        expect(Hoek.contain([1, 2, 1], [1, 1, 2], { only: true })).toBe(true);
+        expect(Hoek.contain([1, 2, 1], [1, 1, 2], { only: true, once: true })).toBe(true);
+        expect(Hoek.contain([1, 2, 1], [1, 2, 2], { only: true })).toBe(false);
+        expect(Hoek.contain([1, 2, 1], [1, 2, 2], { only: true, part: true })).toBe(true);
+        expect(Hoek.contain([1, 1, 1], [1, 1, 1, 1])).toBe(false);
+        expect(Hoek.contain([1, 1, 1], [1, 1, 1, 1], { part: true })).toBe(true);
+
+        expect(Hoek.contain([1, 2, 3], 4)).toBe(false);
+        expect(Hoek.contain([{ a: 1 }], { a: 2 }, { deep: true })).toBe(false);
+        expect(Hoek.contain([{ a: 1 }, { a: 1 }], [{ a: 1 }, { a: 1 }], { deep: true, once: true, only: true })).toBe(
+            true,
+        );
+        expect(Hoek.contain([{ a: 1 }, { a: 1 }], [{ a: 1 }, { a: 2 }], { deep: true, once: true, only: true })).toBe(
+            false,
+        );
+        expect(Hoek.contain([{ a: 1 }], { a: 1 })).toBe(false);
+        expect(Hoek.contain([1, 2, 3], [4, 5])).toBe(false);
+        expect(Hoek.contain([[3], [2]], [[1]])).toBe(false);
+        expect(Hoek.contain([[1], [2]], [[1]])).toBe(false);
+        expect(Hoek.contain([[1, 2]], [[1]], { deep: true })).toBe(false);
+        expect(Hoek.contain([{ a: 1 }], [{ a: 2 }], { deep: true })).toBe(false);
+        expect(Hoek.contain([1, 3, 2], [1, 2], { only: true })).toBe(false);
+        expect(Hoek.contain([1, 2, 2], [1, 2], { once: true })).toBe(false);
+        expect(Hoek.contain([0, 2, 3], [1, 4], { part: true })).toBe(false);
+        expect(Hoek.contain([1, 2, 1], [1, 2, 2], { only: true, once: true })).toBe(false);
+        expect(Hoek.contain([1, 2, 1], [1, 2], { only: true, once: true })).toBe(false);
+
+        expect(Hoek.contain([], 1)).toBe(false);
+        expect(Hoek.contain([], 1, { only: true })).toBe(false);
+
+        expect(Hoek.contain(['a', 'b'], ['a', 'b', 'c'])).toBe(false);
+        expect(Hoek.contain(['a', 'b'], ['a', 'b', 'c'], { only: true })).toBe(false);
+        expect(Hoek.contain(['a', 'b'], ['a', 'b', 'c'], { only: true, once: true })).toBe(false);
+
+        expect(Hoek.contain(['a', 'b'], ['c'], { part: true })).toBe(false);
+        expect(Hoek.contain(['a', 'b'], ['b'], { part: true })).toBe(true);
+
+        expect(Hoek.contain([{ a: 1 }], [1], { deep: true })).toBe(false);
+    });
+
+    it('tests objects', () => {
+        type TTnum = Record<string, number>;
+        type TTstr = Record<string, string>;
+        type TTo = Record<string, TTnum>;
+        type TTn = Record<string, TTo>;
+        type TTa = Record<string, TTnum[]>;
+
+        expect(Hoek.contain({ a: 1, b: 2, c: 3 }, 'a')).toBe(true);
+        expect(Hoek.contain({ a: 1, b: 2, c: 3 }, ['a', 'c'])).toBe(true);
+        expect(Hoek.contain({ a: 1, b: 2, c: 3 }, ['a', 'b', 'c'], { only: true })).toBe(true);
+        expect(Hoek.contain({ a: 1, b: 2, c: 3 }, { a: 1 })).toBe(true);
+        expect(Hoek.contain({ a: 1, b: 2, c: 3 }, { a: 1, c: 3 })).toBe(true);
+        expect(Hoek.contain<TTnum>({ a: 1, b: 2, c: 3 }, { a: 1, d: 4 }, { part: true })).toBe(true);
+        expect(Hoek.contain({ a: 1, b: 2, c: 3 }, { a: 1, b: 2, c: 3 }, { only: true })).toBe(true);
+        expect(Hoek.contain({ a: [1], b: [2], c: [3] }, { a: [1], c: [3] }, { deep: true })).toBe(true);
+        expect(
+            Hoek.contain<TTa>({ a: [{ b: 1 }, { c: 2 }, { d: 3, e: 4 }] }, { a: [{ b: 1 }, { d: 3 }] }, { deep: true }),
+        ).toBe(false);
+        expect(
+            Hoek.contain<TTa>(
+                { a: [{ b: 1 }, { c: 2 }, { d: 3, e: 4 }] },
+                { a: [{ b: 1 }, { d: 3 }] },
+                { deep: true, part: true },
+            ),
+        ).toBe(true);
+        expect(
+            Hoek.contain<TTa>(
+                { a: [{ b: 1 }, { c: 2 }, { d: 3, e: 4 }] },
+                { a: [{ b: 1 }, { d: 3 }] },
+                { deep: true, part: false },
+            ),
+        ).toBe(false);
+        expect(
+            Hoek.contain<TTa>(
+                { a: [{ b: 1 }, { c: 2 }, { d: 3, e: 4 }] },
+                { a: [{ b: 1 }, { d: 3 }] },
+                { deep: true, only: true },
+            ),
+        ).toBe(false);
+        expect(
+            Hoek.contain<TTa>(
+                { a: [{ b: 1 }, { c: 2 }, { d: 3, e: 4 }] },
+                { a: [{ b: 1 }, { d: 3 }] },
+                { deep: true, only: false },
+            ),
+        ).toBe(true);
+        expect(Hoek.contain({ a: [1, 2, 3] }, { a: [2, 4, 6] }, { deep: true, part: true })).toBe(true);
+
+        expect(Hoek.contain<TTnum>({ a: 1, b: 2, c: 3 }, 'd')).toBe(false);
+        expect(Hoek.contain<TTnum>({ a: 1, b: 2, c: 3 }, ['a', 'd'])).toBe(false);
+        expect(Hoek.contain({ a: 1, b: 2, c: 3, d: 4 }, ['a', 'b', 'c'], { only: true })).toBe(false);
+        expect(Hoek.contain({ a: 1, b: 2, c: 3 }, { a: 2 })).toBe(false);
+        expect(Hoek.contain({ a: 1, b: 2, c: 3 }, { a: 2, b: 2 }, { part: true })).toBe(false); // part does not ignore bad value
+        expect(Hoek.contain<TTnum>({ a: 1, b: 2, c: 3 }, { a: 1, d: 3 })).toBe(false);
+        expect(Hoek.contain<TTnum>({ a: 1, b: 2, c: 3 }, { a: 1, d: 4 })).toBe(false);
+        expect(Hoek.contain({ a: 1, b: 2, c: 3 }, { a: 1, b: 2 }, { only: true })).toBe(false);
+        expect(Hoek.contain({ a: [1], b: [2], c: [3] }, { a: [1], c: [3] })).toBe(false);
+        expect(Hoek.contain<TTn>({ a: { b: { c: 1, d: 2 } } }, { a: { b: { c: 1 } } })).toBe(false);
+        expect(Hoek.contain<TTn>({ a: { b: { c: 1, d: 2 } } }, { a: { b: { c: 1 } } }, { deep: true })).toBe(false);
+        expect(
+            Hoek.contain<TTn>({ a: { b: { c: 1, d: 2 } } }, { a: { b: { c: 1 } } }, { deep: true, only: true }),
+        ).toBe(false);
+        expect(
+            Hoek.contain<TTn>({ a: { b: { c: 1, d: 2 } } }, { a: { b: { c: 1 } } }, { deep: true, only: false }),
+        ).toBe(true);
+        expect(
+            Hoek.contain<TTn>({ a: { b: { c: 1, d: 2 } } }, { a: { b: { c: 1 } } }, { deep: true, part: true }),
+        ).toBe(true);
+        expect(
+            Hoek.contain<TTn>({ a: { b: { c: 1, d: 2 } } }, { a: { b: { c: 1 } } }, { deep: true, part: false }),
+        ).toBe(false);
+        expect(Hoek.contain({ a: [1, 2, 3] }, { a: [4, 5, 6] }, { deep: true, part: true })).toBe(false);
+
+        expect(Hoek.contain({}, 'a')).toBe(false);
+        expect(Hoek.contain({}, 'a', { only: true })).toBe(false);
+
+        expect(Hoek.contain<TTstr>({ a: 'foo', b: 'bar' }, ['a', 'b', 'c'])).toBe(false);
+        expect(Hoek.contain<TTstr>({ a: 'foo', b: 'bar' }, ['a', 'b', 'c'], { only: true })).toBe(false);
+        expect(Hoek.contain<TTstr>({ a: 'foo', b: 'bar' }, { a: 'foo', b: 'bar', c: 'x' })).toBe(false);
+        expect(Hoek.contain<TTstr>({ a: 'foo', b: 'bar' }, { a: 'foo', b: 'bar', c: 'x' }, { only: true })).toBe(false);
+
+        expect(Hoek.contain<TTnum>({ a: 1, b: 2 }, ['c'], { part: true })).toBe(false);
+        expect(Hoek.contain<TTnum>({ a: 1, b: 2 }, ['b'], { part: true })).toBe(true);
+
+        // Getter check
+
+        {
+            type FooType = {
+                bar?: string;
+                baz?: string;
+            };
+
+            interface FooItf extends FooType {
+                new (bar: string): FooType;
+            }
+
+            type FooRecord = Record<string, FooType>;
+
+            const Foo = function (this: FooItf, bar: string) {
+                this.bar = bar;
+            } as unknown as FooItf;
+
+            const getBar = function (this: FooItf) {
+                return this.bar;
+            };
+
+            const createFoo = (value: string) => {
+                const foo = new Foo(value);
+
+                Object.defineProperty(foo, 'baz', {
+                    enumerable: true,
+                    get: getBar,
+                });
+
+                return foo;
+            };
+
+            expect(Hoek.contain({ a: createFoo('b') }, { a: createFoo('b') }, { deep: true })).toBe(true);
+            expect(Hoek.contain({ a: createFoo('b') }, { a: createFoo('b') }, { deep: true, part: true })).toBe(true);
+            expect(Hoek.contain<FooRecord>({ a: createFoo('b') }, { a: { bar: 'b', baz: 'b' } }, { deep: true })).toBe(
+                true,
+            );
+            expect(
+                Hoek.contain<FooRecord>(
+                    { a: createFoo('b') },
+                    { a: { bar: 'b', baz: 'b' } },
+                    { deep: true, only: true },
+                ),
+            ).toBe(false);
+            expect(
+                Hoek.contain<FooRecord>({ a: createFoo('b') }, { a: { baz: 'b' } }, { deep: true, part: false }),
+            ).toBe(false);
+            expect(
+                Hoek.contain<FooRecord>({ a: createFoo('b') }, { a: { baz: 'b' } }, { deep: true, part: true }),
+            ).toBe(true);
+            expect(Hoek.contain({ a: createFoo('b') }, { a: createFoo('b') }, { deep: true })).toBe(true);
+        }
+
+        // Properties on prototype not visible
+
+        {
+            type FooType = {
+                a: number;
+                b: number;
+                c: number;
+            };
+
+            interface FooItf extends FooType {
+                new (): FooType;
+            }
+
+            const Foo = function (this: FooItf) {
+                this.a = 1;
+            } as unknown as FooItf;
+
+            Object.defineProperty(Foo.prototype, 'b', {
+                enumerable: true,
+                value: 2,
+            });
+
+            const Bar = function (this: FooItf) {
+                Foo.call(this);
+                this.c = 3;
+            } as unknown as FooItf;
+
+            Util.inherits(Bar, Foo);
+
+            expect(new Bar().a).toEqual(1);
+            expect(new Bar().b).toEqual(2);
+            expect(new Bar().c).toEqual(3);
+            expect(Hoek.contain(new Bar(), { a: 1, c: 3 }, { only: true })).toBe(true);
+            expect(Hoek.contain(new Bar(), 'b')).toBe(false);
+        }
+
+        // Non-Enumerable properties
+
+        {
+            const foo = { a: 1, b: 2 } as {
+                a: number;
+                b: number;
+                c?: number;
+            };
+
+            Object.defineProperty(foo, 'c', {
+                enumerable: false,
+                value: 3,
+            });
+
+            expect(Hoek.contain(foo, 'c')).toBe(true);
+            expect(Hoek.contain(foo, { c: 3 })).toBe(true);
+            expect(Hoek.contain(foo, { a: 1, b: 2, c: 3 }, { only: true })).toBe(true);
+        }
+    });
+
+    it('supports symbols', () => {
+        const sym = Symbol();
+
+        expect(Hoek.contain([sym], sym)).toBe(true);
+        expect(Hoek.contain({ [sym]: 1 }, sym)).toBe(true);
+        expect(Hoek.contain({ [sym]: 1, a: 2 }, { [sym]: 1 })).toBe(true);
+
+        expect(Hoek.contain([sym], Symbol())).toBe(false);
+        expect(Hoek.contain<any>({ [sym]: 1 }, Symbol())).toBe(false);
+    });
+
+    it('compares error keys', () => {
+        const error = new Error('test') as Error & {
+            x?: number;
+            y?: number;
+        };
+
+        expect(Hoek.contain(error, { x: 1 })).toBe(false);
+        expect(Hoek.contain(error, { x: 1 }, { part: true })).toBe(false);
+
+        error.x = 1;
+
+        expect(Hoek.contain(error, { x: 1 })).toBe(true);
+        expect(Hoek.contain(error, { x: 1 }, { part: true })).toBe(true);
+
+        expect(Hoek.contain(error, { x: 1, y: 2 })).toBe(false);
+        expect(Hoek.contain(error, { x: 1, y: 2 }, { part: true })).toBe(true);
+    });
+});
+
+describe('flatten()', () => {
+    it('returns a flat array', () => {
+        const result = Hoek.flatten([1, 2, [3, 4, [5, 6], [7], 8], [9], [10, [11, 12]], 13]);
+        expect(result).toHaveLength(13);
+        expect(result).toHoequal([1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13]);
+    });
+
+    it('appends to a target array', () => {
+        const target = [4, [5]];
+        const result = Hoek.flatten([1, [2, 3]], target);
+
+        expect(result).toBe(target); // Target is modified in place
+        expect(result).toHoequal([4, [5], 1, 2, 3]); // Target items are not flattened
+    });
+
+    it('keeps array holes', () => {
+        // oxlint-disable-next-line no-sparse-arrays -- the hole is the point of the test
+        expect(Hoek.flatten([1, , 2])).toHoequal([1, undefined, 2]);
+    });
+});
+
+describe('reach()', () => {
+    const sym = Symbol();
+    const obj = {
+        a: {
+            b: {
+                c: {
+                    d: 1,
+                    e: 2,
+                },
+                f: 'hello',
+            },
+            g: {
+                h: 3,
+            },
+            '-2': true,
+            [sym]: {
+                v: true,
+            },
+        },
+        i: function () {} as (() => any) & { x: number },
+        j: null,
+        k: [4, 8, 9, 1],
+    };
+
+    obj.i.x = 5;
+
+    it('returns object itself', () => {
+        expect(Hoek.reach(obj, null)).toHoequal(obj);
+        expect(Hoek.reach(obj, false)).toHoequal(obj);
+        expect(Hoek.reach(obj)).toHoequal(obj);
+        expect(Hoek.reach(obj, [])).toHoequal(obj);
+    });
+
+    it('returns values of array', () => {
+        expect(Hoek.reach(obj, 'k.0')).toEqual(4);
+        expect(Hoek.reach(obj, 'k.1')).toEqual(8);
+    });
+
+    it('returns last value of array using negative index', () => {
+        expect(Hoek.reach(obj, 'k.-1')).toEqual(1);
+        expect(Hoek.reach(obj, 'k.-2')).toEqual(9);
+    });
+
+    it('returns object property with negative index for non-array', () => {
+        expect(Hoek.reach(obj, 'a.-2')).toHoequal(true);
+    });
+
+    it('returns a valid member', () => {
+        expect(Hoek.reach(obj, 'a.b.c.d')).toEqual(1);
+    });
+
+    it('returns a valid member with separator override', () => {
+        expect(Hoek.reach(obj, 'a/b/c/d', '/')).toEqual(1);
+    });
+
+    it('returns undefined on null object', () => {
+        expect(Hoek.reach(null, 'a.b.c.d')).toBeUndefined();
+    });
+
+    it('returns undefined on missing object member', () => {
+        expect(Hoek.reach(obj, 'a.b.c.d.x')).toBeUndefined();
+    });
+
+    it('returns undefined on missing function member', () => {
+        expect(Hoek.reach(obj, 'i.y', { functions: true })).toBeUndefined();
+    });
+
+    it('throws on missing member in strict mode', () => {
+        expect(() => {
+            Hoek.reach(obj, 'a.b.c.o.x', { strict: true });
+        }).toThrow('Missing segment o in reach path  a.b.c.o.x');
+    });
+
+    it('returns undefined on invalid member', () => {
+        expect(Hoek.reach(obj, 'a.b.c.d-.x')).toBeUndefined();
+        expect(Hoek.reach(obj, 'k.x')).toBeUndefined();
+        expect(Hoek.reach(obj, 'k.1000')).toBeUndefined();
+        expect(Hoek.reach(obj, 'k/0.5', '/')).toBeUndefined();
+    });
+
+    it('returns function member', () => {
+        expect(typeof Hoek.reach(obj, 'i')).toEqual('function');
+    });
+
+    it('returns function property', () => {
+        expect(Hoek.reach(obj, 'i.x')).toEqual(5);
+    });
+
+    it('returns null', () => {
+        expect(Hoek.reach(obj, 'j')).toBeNull();
+    });
+
+    it('throws on function property when functions not allowed', () => {
+        expect(() => {
+            Hoek.reach(obj, 'i.x', { functions: false });
+        }).toThrow('Invalid segment x in reach path  i.x');
+    });
+
+    it('will return a default value if property is not found', () => {
+        expect(Hoek.reach(obj, 'a.b.q', { default: 'defaultValue' })).toEqual('defaultValue');
+    });
+
+    it('will return a default value if path is not found', () => {
+        expect(Hoek.reach(obj, 'q', { default: 'defaultValue' })).toEqual('defaultValue');
+    });
+
+    it('allows a falsey value to be used as the default value', () => {
+        expect(Hoek.reach(obj, 'q', { default: '' })).toEqual('');
+    });
+
+    it('allows array-based lookup', () => {
+        expect(Hoek.reach(obj, ['a', 'b', 'c', 'd'])).toEqual(1);
+        expect(Hoek.reach(obj, ['k', '1'])).toEqual(8);
+        expect(Hoek.reach(obj, ['k', 1])).toEqual(8);
+        expect(Hoek.reach(obj, ['k', '-2'])).toEqual(9);
+        expect(Hoek.reach(obj, ['k', -2])).toEqual(9);
+    });
+
+    it('allows array-based lookup with symbols', () => {
+        expect(Hoek.reach(obj, ['a', sym, 'v'])).toHoequal(true);
+        expect(Hoek.reach(obj, ['a', Symbol(), 'v'])).toBeUndefined();
+    });
+
+    it('returns character in string', () => {
+        expect(Hoek.reach(['abc'], [0])).toEqual('abc');
+        expect(Hoek.reach(['abc'], ['0'])).toEqual('abc');
+    });
+
+    it('reaches sets and maps', () => {
+        const value = {
+            a: {
+                b: new Set([
+                    { x: 1 },
+                    { x: 2 },
+                    {
+                        y: new Map([
+                            ['v', 4],
+                            ['w', 5],
+                        ]),
+                    },
+                ]),
+            },
+        };
+
+        expect(Hoek.reach(value, 'a.b.2.y.w')).toBeUndefined();
+        expect(Hoek.reach(value, 'a.b.2.y.w', { iterables: true })).toEqual(5);
+    });
+
+    it('reaches set and map properties when iterables is not enabled', () => {
+        const set = new Set([1, 2]) as Set<number> & { custom: string };
+        set.custom = 'x';
+
+        expect(Hoek.reach(set, 'size')).toEqual(2);
+        expect(Hoek.reach(set, 'custom')).toEqual('x');
+        expect(Hoek.reach(new Map([['a', 1]]), 'size')).toEqual(1);
+    });
+
+    it('throws on a set or map segment when strict is enabled', () => {
+        const value = { a: new Map([['b', { c: 1 }]]) };
+
+        expect(() => Hoek.reach(value, 'a.b.c', { strict: true })).toThrow('Missing segment b in reach path  a.b.c');
+        expect(Hoek.reach(value, 'a.b.c')).toBeUndefined();
+        expect(Hoek.reach(value, 'a.b.c', { iterables: true })).toEqual(1);
+    });
+});
+
+describe('reachTemplate()', () => {
+    it('applies object to template', () => {
+        const obj = {
+            a: {
+                b: {
+                    c: {
+                        d: 1,
+                    },
+                },
+            },
+            j: null,
+            k: [4, 8, 9, 1],
+        };
+
+        const template = '{k.0}:{k.-2}:{a.b.c.d}:{x.y}:{j}';
+
+        expect(Hoek.reachTemplate(obj, template)).toEqual('4:9:1::');
+    });
+
+    it('applies object to template (options)', () => {
+        const obj = {
+            a: {
+                b: {
+                    c: {
+                        d: 1,
+                    },
+                },
+            },
+            j: null,
+            k: [4, 8, 9, 1],
+        };
+
+        const template = '{k/0}:{k/-2}:{a/b/c/d}:{x/y}:{j}';
+
+        expect(Hoek.reachTemplate(obj, template, '/')).toEqual('4:9:1::');
+    });
+
+    it("isn't prone to ReDoS given an adversarial template", () => {
+        const sizes = [0, 1, 2, 3, 4]; // Should be evenly-spaced
+        const times = [];
+        const diffs = [];
+
+        for (const size of sizes) {
+            const start = Date.now();
+            Hoek.reachTemplate({}, '{'.repeat(size * 10000));
+            times.push(Date.now() - start);
+        }
+
+        for (let i = 1; i < times.length; ++i) {
+            diffs.push(times[i]! - times[i - 1]!);
+        }
+
+        // Under ReDoS, as the size of the input increases the timing accelerates upwards,
+        // i.e. each timing diff would be greater than the last.
+
+        const diffsMonotonic = diffs[0]! < diffs[1]! && diffs[1]! < diffs[2]! && diffs[2]! < diffs[3]!;
+
+        expect(diffsMonotonic, 'Timing diffs monotonic').toBe(false);
+    });
+});
+
+describe('assert()', () => {
+    it('throws an Error when using assert in a test', () => {
+        expect(() => {
+            Hoek.assert(false, 'my error message');
+        }).toThrow(new Hoek.AssertError('my error message'));
+    });
+
+    it('throws an Error when using assert in a test with no message', () => {
+        expect(() => {
+            Hoek.assert(false);
+        }).toThrow(new Hoek.AssertError('Unknown error'));
+    });
+
+    it('throws an Error when using assert in a test with multipart message', () => {
+        expect(() => {
+            Hoek.assert(false, 'This', 'is', 'my message');
+        }).toThrow(new Hoek.AssertError('This is my message'));
+    });
+
+    it('throws an Error when using assert in a test with multipart message (empty)', () => {
+        expect(() => {
+            Hoek.assert(false, 'This', 'is', '', 'my message');
+        }).toThrow(new Hoek.AssertError('This is my message'));
+    });
+
+    it('throws an Error when using assert in a test with object message', () => {
+        expect(() => {
+            Hoek.assert(false, 'This', 'is', { spinal: 'tap' } as never);
+        }).toThrow(new Hoek.AssertError('This is {"spinal":"tap"}'));
+    });
+
+    it('throws an Error when using assert in a test with multipart string and error messages', () => {
+        expect(() => {
+            Hoek.assert(false, new Error('This'), 'is', 'spinal', new Error('tap'));
+        }).toThrow(new Hoek.AssertError('This is spinal tap'));
+    });
+
+    it('throws an Error when using assert in a test with error object message', () => {
+        const err = new TypeError('This is spinal tap');
+        let got;
+        expect(() => {
+            try {
+                Hoek.assert(false, err);
+            } catch (e) {
+                got = e;
+                throw e;
+            }
+        }).toThrow(new TypeError('This is spinal tap'));
+        expect(got).toBe(err);
+    });
+
+    it('throws the same Error that is passed to it if there is only one error passed', () => {
+        const error = new Error('ruh roh');
+        const error2 = new Error('ruh roh');
+
+        const fn = function () {
+            Hoek.assert(false, error);
+        };
+
+        try {
+            fn();
+        } catch (err) {
+            expect(err).toHoequal(error); // should be the same reference
+            expect(err).not.toBe(error2); // error with the same message should not match
+        }
+    });
+});
+
+describe('AssertError', () => {
+    it('takes an optional message', () => {
+        expect(new Hoek.AssertError().message).toEqual('Unknown error');
+        expect(new Hoek.AssertError(null).message).toEqual('Unknown error');
+        expect(new Hoek.AssertError('msg').message).toEqual('msg');
+    });
+
+    it('has AssertError name property', () => {
+        expect(new Hoek.AssertError().name).toEqual('AssertError');
+        expect(new Hoek.AssertError('msg').name).toEqual('AssertError');
+    });
+
+    it('uses ctor argument to hide stack', { skip: typeof Error.captureStackTrace !== 'function' }, () => {
+        const parentFn = () => {
+            throw new Hoek.AssertError('msg', parentFn);
+        };
+
+        let err;
+        expect(() => {
+            try {
+                parentFn();
+            } catch (e) {
+                err = e;
+                throw e;
+            }
+        }).toThrow(Hoek.AssertError);
+
+        expect(err!.stack).not.toContain('parentFn');
+    });
+});
+
+describe('Bench', () => {
+    it('returns time elapsed', async () => {
+        const timer = new Hoek.Bench();
+        await Hoek.wait(12);
+        expect(timer.elapsed()).toBeGreaterThan(9);
+    });
+});
+
+describe('escapeRegex()', () => {
+    it('escapes all special regular expression characters', () => {
+        const a = Hoek.escapeRegex('4^f$s.4*5+-_?%=#!:@|~\\/`"(>)[<]d{}s,');
+        expect(a).toEqual('4\\^f\\$s\\.4\\*5\\+\\-_\\?%\\=#\\!\\:@\\|~\\\\\\/`"\\(>\\)\\[<\\]d\\{\\}s\\,');
+    });
+});
+
+describe('escapeHeaderAttribute()', () => {
+    it('should not alter ascii values', () => {
+        const a = Hoek.escapeHeaderAttribute('My Value');
+        expect(a).toEqual('My Value');
+    });
+
+    it('escapes all special HTTP header attribute characters', () => {
+        const a = Hoek.escapeHeaderAttribute('I said go!!!#"' + String.fromCharCode(92));
+        expect(a).toEqual('I said go!!!#\\"\\\\');
+    });
+
+    it('throws on large unicode characters', () => {
+        expect(() => {
+            Hoek.escapeHeaderAttribute('this is a test' + String.fromCharCode(500) + String.fromCharCode(300));
+        }).toThrow(Error);
+    });
+
+    it('throws on CRLF to prevent response splitting', () => {
+        expect(() => {
+            Hoek.escapeHeaderAttribute('this is a test\r\n');
+        }).toThrow(Error);
+    });
+});
+
+describe('escapeHtml()', () => {
+    it('escapes all special HTML characters', () => {
+        const a = Hoek.escapeHtml('&<>"\'`');
+        expect(a).toEqual('&amp;&lt;&gt;&quot;&#x27;&#x60;');
+    });
+
+    it('returns empty string on falsy input', () => {
+        const a = Hoek.escapeHtml('');
+        expect(a).toEqual('');
+    });
+
+    it('returns unchanged string on no reserved input', () => {
+        const a = Hoek.escapeHtml('abc');
+        expect(a).toEqual('abc');
+    });
+});
+
+describe('once()', () => {
+    it('allows function to only execute once', () => {
+        let gen = 0;
+        let add = function (x: number) {
+            gen += x;
+        };
+
+        add(5);
+        expect(gen).toEqual(5);
+        add = Hoek.once(add);
+        add(5);
+        expect(gen).toEqual(10);
+        add(5);
+        expect(gen).toEqual(10);
+    });
+
+    it('double once wraps one time', () => {
+        let method = function () {} as (() => void) & { x?: number };
+        method = Hoek.once(method);
+        method.x = 1;
+        method = Hoek.once(method);
+        expect(method.x).toEqual(1);
+    });
+});
+
+describe('ignore()', () => {
+    it('exists', () => {
+        expect(Hoek.ignore).toBeDefined();
+        expect(typeof Hoek.ignore).toEqual('function');
+    });
+});
+
+describe('stringify()', () => {
+    it('converts object to string', () => {
+        const obj = { a: 1 };
+        expect(Hoek.stringify(obj)).toEqual('{"a":1}');
+    });
+
+    it('returns error in result string', () => {
+        const obj = { a: 1 } as any;
+        obj.b = obj;
+        expect(Hoek.stringify(obj)).toContain('Cannot display object');
+    });
+});
+
+describe('isPromise()', () => {
+    it('determines if an object is a promise', async () => {
+        expect(Hoek.isPromise({})).toBe(false);
+        expect(Hoek.isPromise(null)).toBe(false);
+        expect(Hoek.isPromise(false)).toBe(false);
+        expect(Hoek.isPromise(0)).toBe(false);
+        expect(Hoek.isPromise('')).toBe(false);
+        expect(Hoek.isPromise({ then: 1 })).toBe(false);
+        expect(Hoek.isPromise([])).toBe(false);
+
+        const items = [Promise.resolve(), Promise.reject()];
+
+        expect(Hoek.isPromise(items[0])).toBe(true);
+        expect(Hoek.isPromise(items[1])).toBe(true);
+        expect(Hoek.isPromise(new Promise(Hoek.ignore))).toBe(true);
+        expect(Hoek.isPromise({ then: Hoek.ignore })).toBe(true);
+
+        try {
+            await Promise.all(items);
+        } catch {}
+    });
+});
+
+describe('wait()', () => {
+    it('delays for timeout ms', async () => {
+        const timeout = {} as { before?: boolean; after?: boolean };
+        setTimeout(() => (timeout.before = true), 10);
+        const wait = Hoek.wait(10);
+        setTimeout(() => (timeout.after = true), 10);
+
+        await wait;
+
+        expect(timeout.before).toBe(true);
+        expect(timeout.after).toBeUndefined();
+    });
+
+    it('delays for timeout ms as bigint', async () => {
+        const timeout = {} as { before?: boolean; after?: boolean };
+        setTimeout(() => (timeout.before = true), 10);
+        const wait = Hoek.wait(10n);
+        setTimeout(() => (timeout.after = true), 10);
+
+        await wait;
+
+        expect(timeout.before).toBe(true);
+        expect(timeout.after).toBeUndefined();
+    });
+
+    it('handles timeouts >= 2^31', async () => {
+        const flow = [];
+        let no = 0;
+
+        const fakeTimeout = function (cb: Function, time: number) {
+            const timer = ++no;
+
+            flow.push(`CALL(${timer}): ${time}`);
+            setImmediate(() => {
+                flow.push(`PRE(${timer})`);
+                cb();
+                flow.push(`POST(${timer})`);
+            });
+        };
+
+        await Hoek.wait(2 ** 31, null, { setTimeout: fakeTimeout });
+        flow.push('DONE1');
+        await Hoek.wait(2 ** 32 + 2 ** 30, null, { setTimeout: fakeTimeout });
+        flow.push('DONE2');
+
+        expect(flow).toHoequal([
+            'CALL(1): 2147483647',
+            'PRE(1)',
+            'CALL(2): 1',
+            'POST(1)',
+            'PRE(2)',
+            'POST(2)',
+            'DONE1',
+            'CALL(3): 2147483647',
+            'PRE(3)',
+            'CALL(4): 2147483647',
+            'POST(3)',
+            'PRE(4)',
+            'CALL(5): 1073741826',
+            'POST(4)',
+            'PRE(5)',
+            'POST(5)',
+            'DONE2',
+        ]);
+    });
+
+    it('returns never resolving promise when timeout >= Number.MAX_SAFE_INTEGER', async () => {
+        let calls = 0;
+        const fakeTimeout = function (cb: Function) {
+            ++calls;
+            process.nextTick(cb);
+        };
+
+        await Hoek.wait(2 ** 31 - 1, null, { setTimeout: fakeTimeout });
+        expect(calls).toEqual(1);
+
+        const waited = Symbol('waited');
+
+        const result = await Promise.race([
+            Hoek.wait(1, waited),
+            Hoek.wait(Number.MAX_SAFE_INTEGER, null, { setTimeout: fakeTimeout }),
+            Hoek.wait(Infinity, null, { setTimeout: fakeTimeout }),
+        ]);
+
+        expect(result).toHoequal(waited);
+        expect(calls).toEqual(1);
+    });
+
+    it('handles a return value', async () => {
+        const uniqueValue = {};
+        const timeout = {} as { before?: boolean; after?: boolean };
+        setTimeout(() => (timeout.before = true), 10);
+        const wait = Hoek.wait(10, uniqueValue);
+        setTimeout(() => (timeout.after = true), 10);
+
+        expect(await wait).toBe(uniqueValue);
+        expect(timeout.before).toBe(true);
+        expect(timeout.after).toBeUndefined();
+    });
+
+    it('undefined timeout resolves immediately', async () => {
+        const waited = Symbol('waited');
+        const result = await Promise.race([Hoek.wait(undefined, waited), Hoek.wait(0)]);
+
+        expect(result).toHoequal(waited);
+    });
+
+    it('NaN timeout resolves immediately', async () => {
+        const waited = Symbol('waited');
+        const result = await Promise.race([Hoek.wait(Number.NaN, waited), Hoek.wait(0)]);
+
+        expect(result).toHoequal(waited);
+    });
+
+    it('rejects on weird timeout values', async () => {
+        await expect(() => Hoek.wait({} as never)).toThrow();
+        await expect(() => Hoek.wait(Symbol('hi') as never)).toThrow();
+    });
+});
+
+describe('block()', () => {
+    it('returns a promise', () => {
+        expect(Hoek.block()).toBeInstanceOf(Promise);
+    });
+
+    it('does not immediately reject or resolve', async () => {
+        const promise = Hoek.block();
+        const waited = Symbol('waited');
+
+        const result = await Promise.race([Hoek.wait(1, waited), promise]);
+
+        expect(result).toHoequal(waited);
+    });
+});
diff --git a/test/typings.ts b/test/typings.ts
new file mode 100755
index 00000000..fb9f22a4
--- /dev/null
+++ b/test/typings.ts
@@ -0,0 +1,515 @@
+import { describe, expectTypeOf, it } from 'vitest';
+
+import * as Hoek from '../src/index.js';
+
+interface Foo {
+    a?: number;
+    b?: string;
+}
+
+interface Bar {
+    b?: string;
+    c?: boolean;
+}
+
+describe('typings', () => {
+    it('exposes functions directly', () => {
+        expectTypeOf(Hoek.deepEqual).toBeFunction();
+        expectTypeOf(Hoek.deepEqual(1, 2)).toBeBoolean();
+    });
+
+    describe('deepEqual()', () => {
+        it('accepts valid calls', () => {
+            Hoek.deepEqual('some', 'some');
+            Hoek.deepEqual('some', 3);
+            Hoek.deepEqual({}, {});
+            Hoek.deepEqual({}, {}, { prototype: false, symbols: true, part: false, deepFunction: true });
+            Hoek.deepEqual({}, {}, { skip: ['a', 'b', Symbol('test')] });
+
+            expectTypeOf(Hoek.deepEqual(1, 2)).toBeBoolean();
+        });
+
+        it('rejects invalid calls', () => {
+            try {
+                // @ts-expect-error requires two arguments
+                Hoek.deepEqual();
+                // @ts-expect-error too many arguments
+                Hoek.deepEqual(1, 2, {}, 'x');
+                // @ts-expect-error unknown option
+                Hoek.deepEqual({}, {}, { unknown: true });
+                // @ts-expect-error skip must be string/symbol keys
+                Hoek.deepEqual({}, {}, { skip: [1] });
+            } catch {}
+        });
+    });
+
+    describe('clone()', () => {
+        it('accepts valid calls', () => {
+            Hoek.clone('string');
+            Hoek.clone(123);
+            Hoek.clone({ a: 1 });
+            Hoek.clone({ a: 1 }, { prototype: true, symbols: true });
+            Hoek.clone({}, { shallow: [] });
+            Hoek.clone(1, { shallow: [] });
+            Hoek.clone(null, { shallow: [] });
+            Hoek.clone({ a: 1, b: { c: [2] } }, { shallow: true });
+            Hoek.clone({ a: 1, b: { c: [2] } }, { shallow: ['b'] });
+            Hoek.clone({ a: 1, b: { c: [2] } }, { shallow: [['b']] });
+            Hoek.clone({ a: 1, b: { c: [2] } }, { shallow: ['b'], prototype: true, symbols: true });
+
+            expectTypeOf(Hoek.clone('string')).toBeString();
+            expectTypeOf(Hoek.clone({})).toBeObject();
+            expectTypeOf(Hoek.clone({} as Bar)).toEqualTypeOf<Bar>();
+            expectTypeOf(Hoek.clone({ a: 1 } as Foo, { shallow: ['b'] })).toEqualTypeOf<Foo>();
+        });
+
+        it('rejects invalid calls', () => {
+            try {
+                // @ts-expect-error unknown option
+                Hoek.clone({}, { unknown: true });
+                // @ts-expect-error shallow entries must be paths
+                Hoek.clone({}, { shallow: [null] });
+                // @ts-expect-error shallow must be an array or boolean
+                Hoek.clone({}, { shallow: 1 });
+            } catch {}
+        });
+    });
+
+    describe('merge()', () => {
+        it('accepts valid calls', () => {
+            Hoek.merge({ a: 1 } as Foo, { b: 'x' } as Bar);
+            Hoek.merge({ a: 1 }, { a: null });
+            Hoek.merge({ a: 1 }, { a: null }, { mergeArrays: true, nullOverride: true, symbols: false });
+
+            expectTypeOf(Hoek.merge({}, {})).toBeObject();
+            expectTypeOf(Hoek.merge({ a: 1 } as Foo, { b: 'x' } as Bar)).toEqualTypeOf<Foo & Bar>();
+        });
+
+        it('rejects invalid calls', () => {
+            try {
+                // @ts-expect-error cannot merge non-object
+                Hoek.merge(1, 2);
+                // @ts-expect-error options must be an object
+                Hoek.merge({ a: 1 }, { a: null }, true);
+                // @ts-expect-error unknown option
+                Hoek.merge({ a: 1 }, { a: null }, { unknown: true });
+            } catch {}
+        });
+    });
+
+    describe('applyToDefaults()', () => {
+        it('accepts valid calls', () => {
+            Hoek.applyToDefaults({}, {});
+            Hoek.applyToDefaults({}, true);
+            Hoek.applyToDefaults({}, false);
+            Hoek.applyToDefaults({}, null);
+            Hoek.applyToDefaults({ a: 1 } as Foo, { b: 'x' });
+            Hoek.applyToDefaults({ a: 1 } as object, { b: 'x' });
+            Hoek.applyToDefaults({ a: 1 } as Foo, { b: 'x' }, { shallow: ['b'] });
+            Hoek.applyToDefaults({ a: 1 } as object, { b: 'x' }, { shallow: ['c'] });
+
+            expectTypeOf(Hoek.applyToDefaults({}, {})!).toBeObject();
+            expectTypeOf(Hoek.applyToDefaults({ a: 1 } as Foo, { b: 'x' })!).toBeObject();
+            expectTypeOf(Hoek.applyToDefaults({}, {}, { shallow: [] })!).toBeObject();
+        });
+
+        it('rejects invalid calls', () => {
+            try {
+                // @ts-expect-error source must be an object, falsy, or true
+                Hoek.applyToDefaults({} as Foo, 'zzz');
+                // @ts-expect-error unknown option
+                Hoek.applyToDefaults({}, {}, { unknown: true });
+            } catch {}
+        });
+    });
+
+    describe('intersect()', () => {
+        it('accepts valid calls', () => {
+            Hoek.intersect([1], [1, 2]);
+            Hoek.intersect(['a'], ['b', 'b']);
+            Hoek.intersect([1], [1, 2], { first: true });
+            Hoek.intersect([1], [1, 2], { first: false });
+            Hoek.intersect([1], null);
+            Hoek.intersect(null, [1, 2]);
+            Hoek.intersect([1], null, { first: true });
+            Hoek.intersect(null, [1, 2], { first: true });
+            Hoek.intersect(new Set([1]), new Set([1, 2]));
+            Hoek.intersect([1], new Set([1, 2]));
+            Hoek.intersect(new Set([1]), [1, 2]);
+
+            expectTypeOf(Hoek.intersect([1], [1, 2])).toEqualTypeOf<number[] | null>();
+            expectTypeOf(Hoek.intersect([1], [1, 2], { first: false })).toEqualTypeOf<number[] | null>();
+            expectTypeOf(Hoek.intersect([1], [1, 2], { first: true })).toEqualTypeOf<number | null>();
+        });
+
+        it('rejects invalid calls', () => {
+            try {
+                // @ts-expect-error requires two arguments
+                Hoek.intersect();
+                // @ts-expect-error arguments must be arrays or sets
+                Hoek.intersect(1, 2);
+                // @ts-expect-error second argument must be an array or set
+                Hoek.intersect([1], 2);
+                // @ts-expect-error options must be an object
+                Hoek.intersect([1], [2], 'x');
+                // @ts-expect-error maps are not supported
+                Hoek.intersect(new Map(), [2]);
+            } catch {}
+        });
+    });
+
+    describe('contain()', () => {
+        it('accepts valid calls', () => {
+            Hoek.contain('abc', 'a');
+            Hoek.contain('abc', ['a', 'x']);
+            Hoek.contain('abc', ['a', 'd'], { once: true, part: true, deep: true, symbols: true, only: true });
+            Hoek.contain({ a: 1 }, 'a');
+            Hoek.contain({ a: 1 }, { a: 1 });
+            Hoek.contain({ a: 1, b: 2 }, ['a', 'b'], { part: true, deep: true, symbols: true, only: true });
+            Hoek.contain([1], 1);
+            Hoek.contain([1], [1]);
+            Hoek.contain([1], [1], { once: true, part: true, deep: true, symbols: true, only: true });
+
+            expectTypeOf(Hoek.contain('abc', 'a')).toBeBoolean();
+            expectTypeOf(Hoek.contain({ a: 1 }, 'a')).toBeBoolean();
+            expectTypeOf(Hoek.contain([1], 1)).toBeBoolean();
+        });
+
+        it('rejects invalid calls', () => {
+            try {
+                // @ts-expect-error unknown option
+                Hoek.contain('abc', 'a', { unknown: true });
+                // @ts-expect-error unknown option
+                Hoek.contain(['a'], 'a', { unknown: true });
+                // @ts-expect-error unknown option
+                Hoek.contain({ a: 1 }, 'a', { unknown: true });
+                // @ts-expect-error string haystack needs string values
+                Hoek.contain('abc', [{}]);
+                // @ts-expect-error string haystack needs string values
+                Hoek.contain('abc', {});
+                // @ts-expect-error value must be a known key of the object
+                Hoek.contain({ a: 1, b: 2 }, ['a', 'x']);
+            } catch {}
+        });
+    });
+
+    describe('flatten()', () => {
+        it('accepts valid calls', () => {
+            Hoek.flatten([1, [2, 3]]);
+            Hoek.flatten([1, [2, 3]], [4, [5]]);
+
+            expectTypeOf(Hoek.flatten([1, [2, 3]])).toBeArray();
+            expectTypeOf(Hoek.flatten([1, [2, [3, [4]]]])).toEqualTypeOf<number[]>();
+            expectTypeOf(Hoek.flatten([1, ['a']])).toEqualTypeOf<(number | string)[]>();
+            expectTypeOf(Hoek.flatten([1, [2]], [3, [4]])).toEqualTypeOf<(number | number[])[]>();
+        });
+
+        it('rejects invalid calls', () => {
+            try {
+                // @ts-expect-error requires an array
+                Hoek.flatten();
+                // @ts-expect-error argument must be an array
+                Hoek.flatten(1);
+                // @ts-expect-error target must be an array
+                Hoek.flatten([], 1);
+            } catch {}
+        });
+    });
+
+    describe('reach()', () => {
+        it('accepts valid calls', () => {
+            Hoek.reach([]);
+            Hoek.reach(null, false);
+            Hoek.reach(null, '0');
+            Hoek.reach(null, ['0']);
+            Hoek.reach(['abc'], false);
+            Hoek.reach(['abc'], null);
+            Hoek.reach(['abc'], undefined);
+            Hoek.reach(['abc'], [0]);
+            Hoek.reach(['abc'], ['0']);
+            Hoek.reach(['abc'], '0');
+            Hoek.reach({ a: { b: { c: 3 } } }, 'a.b.c');
+            Hoek.reach({ a: { b: { c: 3 } } }, ['a', 'b', 'c']);
+            Hoek.reach({ a: { b: { c: 3 } } }, 'a/b/c', {
+                separator: '/',
+                default: 4,
+                strict: true,
+                functions: true,
+                iterables: true,
+            });
+
+            expectTypeOf(Hoek.reach(['abc'], [0])).toBeUnknown();
+            expectTypeOf(Hoek.reach({ a: { b: { c: 3 } } }, 'a.b.c')).toBeUnknown();
+        });
+
+        it('rejects invalid calls', () => {
+            try {
+                // @ts-expect-error requires an object or null
+                Hoek.reach();
+                // @ts-expect-error obj must be an object or null
+                Hoek.reach(1, '0');
+                // @ts-expect-error obj must be an object or null
+                Hoek.reach('abc', '0');
+                // @ts-expect-error chain must be a string/array/null/false
+                Hoek.reach([0], 0);
+                // @ts-expect-error unknown option
+                Hoek.reach(['abc'], '0', { unknown: false });
+                // @ts-expect-error separator must be a string
+                Hoek.reach(['abc'], '0', { separator: false });
+            } catch {}
+        });
+    });
+
+    describe('reachTemplate()', () => {
+        it('accepts valid calls', () => {
+            Hoek.reachTemplate(null, 'a{b}c');
+            Hoek.reachTemplate([1, 2], 'a{1}c');
+            Hoek.reachTemplate({ b: 2 }, 'a{b}c');
+            Hoek.reachTemplate({ a: { b: { c: 3 } } }, '{a/b/c}', {
+                separator: '/',
+                default: 4,
+                strict: true,
+                functions: true,
+            });
+
+            expectTypeOf(Hoek.reachTemplate([1, 2], 'a{1}c')).toBeString();
+        });
+
+        it('rejects invalid calls', () => {
+            try {
+                // @ts-expect-error requires a template
+                Hoek.reachTemplate();
+                // @ts-expect-error requires a template
+                Hoek.reachTemplate([]);
+                // @ts-expect-error obj must be an object or null
+                Hoek.reachTemplate(1, '0');
+                // @ts-expect-error obj must be an object or null
+                Hoek.reachTemplate('abc', '0');
+                // @ts-expect-error template must be a string
+                Hoek.reachTemplate([0], 0);
+                // @ts-expect-error unknown option
+                Hoek.reachTemplate(['abc'], '{0}', { unknown: false });
+                // @ts-expect-error separator must be a string
+                Hoek.reachTemplate(['abc'], '{0}', { separator: false });
+            } catch {}
+        });
+    });
+
+    describe('assert()', () => {
+        it('accepts valid calls', () => {
+            Hoek.assert(true);
+            Hoek.assert(true, 'some', 'message', 10);
+            Hoek.assert(1, 'error');
+            Hoek.assert(true, new Error('message'));
+
+            expectTypeOf(Hoek.assert(true)).toBeVoid();
+        });
+    });
+
+    describe('Bench', () => {
+        const bench = new Hoek.Bench();
+
+        it('exposes instance and static members', () => {
+            expectTypeOf(bench.ts).toBeNumber();
+            expectTypeOf(bench.reset()).toBeVoid();
+            expectTypeOf(bench.elapsed()).toBeNumber();
+            expectTypeOf(Hoek.Bench.now()).toBeNumber();
+        });
+
+        it('rejects invalid calls', () => {
+            try {
+                // @ts-expect-error constructor takes no arguments
+                new Hoek.Bench({});
+                // @ts-expect-error reset takes no arguments
+                bench.reset(true);
+                // @ts-expect-error elapsed takes no arguments
+                bench.elapsed(true);
+                // @ts-expect-error now takes no arguments
+                Hoek.Bench.now(true);
+            } catch {}
+        });
+    });
+
+    describe('escapeRegex()', () => {
+        it('accepts valid calls', () => {
+            Hoek.escapeRegex('something?');
+
+            expectTypeOf(Hoek.escapeRegex('^?')).toBeString();
+        });
+
+        it('rejects invalid calls', () => {
+            try {
+                // @ts-expect-error requires a string
+                Hoek.escapeRegex();
+                // @ts-expect-error argument must be a string
+                Hoek.escapeRegex(true);
+                // @ts-expect-error argument must be a string
+                Hoek.escapeRegex({});
+            } catch {}
+        });
+    });
+
+    describe('escapeHeaderAttribute()', () => {
+        it('accepts valid calls', () => {
+            Hoek.escapeHeaderAttribute('something?');
+
+            expectTypeOf(Hoek.escapeHeaderAttribute('^?')).toBeString();
+        });
+
+        it('rejects invalid calls', () => {
+            try {
+                // @ts-expect-error requires a string
+                Hoek.escapeHeaderAttribute();
+                // @ts-expect-error argument must be a string
+                Hoek.escapeHeaderAttribute(true);
+                // @ts-expect-error argument must be a string
+                Hoek.escapeHeaderAttribute({});
+            } catch {}
+        });
+    });
+
+    describe('escapeHtml()', () => {
+        it('accepts valid calls', () => {
+            Hoek.escapeHtml('something?');
+
+            expectTypeOf(Hoek.escapeHtml('^?')).toBeString();
+        });
+
+        it('rejects invalid calls', () => {
+            try {
+                // @ts-expect-error argument must be a string
+                Hoek.escapeHtml(true);
+                // @ts-expect-error argument must be a string
+                Hoek.escapeHtml({});
+            } catch {}
+        });
+    });
+
+    describe('escapeJson()', () => {
+        it('accepts valid calls', () => {
+            Hoek.escapeJson('something?');
+
+            expectTypeOf(Hoek.escapeJson('^?')).toBeString();
+        });
+
+        it('rejects invalid calls', () => {
+            try {
+                // @ts-expect-error argument must be a string
+                Hoek.escapeJson(true);
+                // @ts-expect-error argument must be a string
+                Hoek.escapeJson({});
+            } catch {}
+        });
+    });
+
+    describe('once()', () => {
+        it('accepts valid calls', () => {
+            Hoek.once(() => 4);
+            Hoek.once(() => undefined);
+
+            expectTypeOf(Hoek.once(() => 'x')).toEqualTypeOf<() => string>();
+        });
+
+        it('rejects invalid calls', () => {
+            try {
+                // @ts-expect-error requires a function
+                Hoek.once();
+                // @ts-expect-error argument must be a function
+                Hoek.once('x');
+                // @ts-expect-error argument must be a function
+                Hoek.once({});
+            } catch {}
+        });
+    });
+
+    describe('ignore()', () => {
+        it('accepts any arguments', () => {
+            Hoek.ignore();
+            Hoek.ignore(1, 2, 'x');
+
+            expectTypeOf(Hoek.ignore).toEqualTypeOf<(...args: unknown[]) => void>();
+            expectTypeOf(Hoek.ignore()).toBeVoid();
+        });
+    });
+
+    describe('stringify()', () => {
+        it('accepts valid calls', () => {
+            Hoek.stringify(123);
+            Hoek.stringify({}, null, 4);
+
+            expectTypeOf(Hoek.stringify(123)).toBeString();
+        });
+
+        it('rejects invalid calls', () => {
+            try {
+                // @ts-expect-error requires a value
+                Hoek.stringify();
+            } catch {}
+        });
+    });
+
+    describe('wait()', () => {
+        it('accepts valid calls', () => {
+            expectTypeOf(Hoek.wait(0)).toEqualTypeOf<Promise<void>>();
+            expectTypeOf(Hoek.wait(100, 'ok')).toEqualTypeOf<Promise<string>>();
+        });
+
+        it('rejects invalid calls', () => {
+            try {
+                // @ts-expect-error timeout must be a number/bigint
+                Hoek.wait({});
+            } catch {}
+        });
+    });
+
+    describe('block()', () => {
+        it('accepts valid calls', () => {
+            expectTypeOf(Hoek.block()).toEqualTypeOf<Promise<void>>();
+            expectTypeOf<Awaited<ReturnType<typeof Hoek.block>>>().toBeVoid();
+        });
+
+        it('rejects invalid calls', () => {
+            try {
+                // @ts-expect-error takes no arguments
+                Hoek.block(123);
+            } catch {}
+        });
+    });
+
+    describe('isPromise()', () => {
+        it('accepts valid calls', () => {
+            Hoek.isPromise(1);
+            Hoek.isPromise({});
+            Hoek.isPromise(null);
+
+            expectTypeOf(Hoek.isPromise(1)).toBeBoolean();
+        });
+
+        it('rejects invalid calls', () => {
+            try {
+                // @ts-expect-error requires an argument
+                Hoek.isPromise();
+                // @ts-expect-error too many arguments
+                Hoek.isPromise(1, 2);
+            } catch {}
+        });
+    });
+
+    describe('AssertError', () => {
+        it('exposes the expected shape', () => {
+            expectTypeOf(new Hoek.AssertError()).toEqualTypeOf<Hoek.AssertError>();
+            expectTypeOf(new Hoek.AssertError('fail')).toEqualTypeOf<Hoek.AssertError>();
+            expectTypeOf(new Hoek.AssertError().name).toEqualTypeOf<'AssertError'>();
+            expectTypeOf(new Hoek.AssertError().message).toBeString();
+        });
+
+        it('rejects invalid calls', () => {
+            try {
+                // @ts-expect-error message must be a string
+                new Hoek.AssertError(new Error());
+                // @ts-expect-error takes a single argument
+                new Hoek.AssertError('fail', 'again');
+            } catch {}
+        });
+    });
+});
diff --git a/tsconfig.json b/tsconfig.json
new file mode 100755
index 00000000..a833a6bc
--- /dev/null
+++ b/tsconfig.json
@@ -0,0 +1,28 @@
+{
+    "compilerOptions": {
+        "allowImportingTsExtensions": true,
+        "allowSyntheticDefaultImports": true,
+        "declaration": true,
+        "declarationMap": true,
+        "emitDeclarationOnly": false,
+        "erasableSyntaxOnly": true,
+        "exactOptionalPropertyTypes": true,
+        "forceConsistentCasingInFileNames": true,
+        "inlineSources": true,
+        "module": "NodeNext",
+        "moduleResolution": "NodeNext",
+        "noEmit": true,
+        "noFallthroughCasesInSwitch": true,
+        "noImplicitAny": true,
+        "noImplicitReturns": true,
+        "noUncheckedIndexedAccess": true,
+        "noUnusedLocals": true,
+        "noUnusedParameters": true,
+        "rewriteRelativeImportExtensions": true,
+        "sourceMap": true,
+        "strict": true,
+        "target": "ESNext",
+        "types": ["node", "./vitest.d.ts"]
+    },
+    "include": ["src", "test"]
+}
diff --git a/tsdown.config.ts b/tsdown.config.ts
new file mode 100644
index 00000000..89a72e70
--- /dev/null
+++ b/tsdown.config.ts
@@ -0,0 +1,11 @@
+import { defineConfig } from 'tsdown';
+
+export default defineConfig({
+    entry: ['./src/index.ts'],
+    outDir: './dist',
+    clean: true,
+    exports: true,
+    hash: false,
+    format: 'esm',
+    target: 'node22',
+});
diff --git a/vitest.config.ts b/vitest.config.ts
new file mode 100644
index 00000000..41181547
--- /dev/null
+++ b/vitest.config.ts
@@ -0,0 +1,24 @@
+import Oxc from '@hapi/oxc-plugin/vitest';
+import { defineConfig } from 'vitest/config';
+
+import type { ViteUserConfig } from 'vitest/config';
+
+export default defineConfig({
+    plugins: [Oxc()],
+    test: {
+        environment: 'node',
+        include: ['test/**/*.ts'],
+        setupFiles: ['vitest.setup.ts'],
+        typecheck: {
+            enabled: true,
+            include: ['test/**/*.{js,ts}'],
+        },
+        coverage: {
+            provider: 'v8',
+            include: ['src/**'],
+            thresholds: {
+                100: true,
+            },
+        },
+    },
+}) as ViteUserConfig;
diff --git a/vitest.d.ts b/vitest.d.ts
new file mode 100644
index 00000000..9863298d
--- /dev/null
+++ b/vitest.d.ts
@@ -0,0 +1,9 @@
+import 'vitest';
+
+import type { DeepEqualOptions } from './src/deepEqual.js';
+
+declare module 'vitest' {
+    interface Assertion<T = any> {
+        toHoequal(expected: T, options?: DeepEqualOptions): T;
+    }
+}
diff --git a/vitest.setup.ts b/vitest.setup.ts
new file mode 100644
index 00000000..4d451c20
--- /dev/null
+++ b/vitest.setup.ts
@@ -0,0 +1,19 @@
+import { expect } from 'vitest';
+
+import { deepEqual, type DeepEqualOptions } from './src/deepEqual.js';
+
+// Custom matcher backed by hoek's own deepEqual — the same engine @hapi/code.equal()
+// wrapped, minus the dependency. Defaults mirror code.equal(): prototype comparison off,
+// deep function comparison on. Tests opt into prototype/symbol checks via the options arg.
+expect.extend({
+    toHoequal(received: unknown, expected: unknown, options?: DeepEqualOptions) {
+        const pass = deepEqual(received, expected, { prototype: false, deepFunction: true, ...options });
+
+        return {
+            pass,
+            message: () => `Expected values ${pass ? 'not ' : ''}to be deeply equal`,
+            actual: received,
+            expected,
+        };
+    },
+});