diff --git a/.gitignore b/.gitignore
index a89572fa..3dbcaab0 100644
--- a/.gitignore
+++ b/.gitignore
@@ -5,7 +5,6 @@
 
 # Build
 /.scannerwork/
-/.tap/
 /classes/
 /lib/rapidcontext-*.jar
 /plugin/
diff --git a/Makefile b/Makefile
index 2a6e03f9..891996b4 100644
--- a/Makefile
+++ b/Makefile
@@ -125,8 +125,7 @@ test-js:
 		--ignore-pattern 'src/plugin/legacy/**/*.js' \
 		--ignore-pattern '**/*.min.js' \
 		--ignore-pattern '**/MochiKit.js'
-	npx tap --allow-incomplete-coverage '**/*.test.@(js|mjs)'
-	npx tap report --coverage-report=text-lcov > .tap/coverage.lcov
+	node --import ./test/src/js/loader.mjs --test test/src/js/
 
 test-java:
 	mkdir -p test/classes/ tmp/test/
@@ -159,7 +158,6 @@ test-sonar-scan:
 		-Dsonar.java.libraries=lib/*.jar \
 		-Dsonar.java.test.binaries=test/classes \
 		-Dsonar.java.test.libraries=test/lib/*.jar \
-		-Dsonar.javascript.lcov.reportPaths=.tap/coverage.lcov \
 		-Dsonar.coverage.jacoco.xmlReportPaths=tmp/test/jacoco.xml \
 		-Dsonar.host.url=https://sonarcloud.io
 
diff --git a/package.json b/package.json
index 235d79e4..d168953f 100644
--- a/package.json
+++ b/package.json
@@ -18,7 +18,6 @@
     "html-validate": "^8.0.5",
     "jsdoc": "^4.0.2",
     "stylelint": "^15.10.0",
-    "stylelint-config-standard": "^34.0.0",
-    "tap": "^18.5.7"
+    "stylelint-config-standard": "^34.0.0"
   }
 }
diff --git a/src/plugin/test/files/js/rapidcontext/data.test.mjs b/src/plugin/test/files/js/rapidcontext/data.test.mjs
deleted file mode 100644
index 7ac4381c..00000000
--- a/src/plugin/test/files/js/rapidcontext/data.test.mjs
+++ /dev/null
@@ -1,234 +0,0 @@
-import tap from 'tap';
-import data from '../../../../system/files/js/rapidcontext/data.mjs';
-
-function arrayLike() {
-    return arguments;
-}
-
-function throwError() {
-    throw new Error('test');
-}
-
-tap.test('data.bool()', (t) => {
-    t.equal(data.bool(), false);
-    t.equal(data.bool(null), false);
-    t.equal(data.bool(true), true);
-    t.equal(data.bool(false), false);
-    t.equal(data.bool(NaN), false);
-    t.equal(data.bool(0), false);
-    t.equal(data.bool(1), true);
-    t.equal(data.bool(''), false);
-    t.equal(data.bool('on'), true);
-    t.equal(data.bool('OFF'), false);
-    t.equal(data.bool('FaLsE'), false);
-    t.equal(data.bool('null'), false);
-    t.equal(data.bool('falsy'), true);
-    t.equal(data.bool({}), true);
-    t.end();
-});
-
-tap.test('data.array()', (t) => {
-    t.same(data.array(), []);
-    t.same(data.array(null), []);
-    t.same(data.array(undefined), []);
-    t.same(data.array(null, undefined), [null, undefined]);
-    t.same(data.array(false), [false]);
-    t.same(data.array(0), [0]);
-    t.same(data.array(1, 'two', false), [1, 'two', false]);
-    t.same(data.array([]), []);
-    t.same(data.array([], []), [[], []]);
-    t.same(data.array([1, 'two', false]), [1, 'two', false]);
-    t.same(data.array({}), []);
-    t.same(data.array({}, {}), [{}, {}]);
-    t.same(data.array({ a: 1, b: 'two', c: false }), [1, 'two', false]);
-    t.same(data.array(new Set([1, 2, 3])), [1, 2, 3]);
-    const arr = [1, 2, 3];
-    t.not(data.array(arr), arr, 'input array is copied');
-    t.end();
-});
-
-tap.test('data.object()', (t) => {
-    const dt = new Date();
-    t.same(data.object(), {});
-    t.same(data.object(null, 1), {});
-    t.same(data.object(undefined, 1), {});
-    t.same(data.object('a'), {});
-    t.same(data.object((o) => o.id), {});
-    t.same(data.object([]), {});
-    t.same(data.object([['a', 1], ['b', 2], ['c']]), { a: 1, b: 2, c: undefined });
-    t.same(data.object(['a', null, ['b']]), { 'a': undefined, 'b': undefined });
-    t.same(data.object(['a', 'a', 'a']), { a: undefined });
-    t.same(data.object(['a', 'b'], true), { a: true, b: true });
-    t.same(data.object(['a', 'b'], dt), { a: dt, b: dt });
-    t.same(data.object(['a', 'b'], [1, 2]), { a: 1, b: 2 });
-    t.same(data.object([1, null, 3, 1], [1, 2, 3, 4]), { '1': 1, '3': 3 });
-    t.same(data.object(['a', 'b', 'c'], [1, 2]), { a: 1, b: 2, c: undefined });
-    t.same(data.object(['a', 'a', 'a'], [1, 2, 3]), { a: 1 });
-    t.same(data.object(['a', 'b'], { a: 1, b: 2, c: 3, d: 4 }), { a: 1, b: 2 });
-    t.same(data.object(['a', 'b'], (k) => k), { a: 'a', b: 'b' });
-    t.same(data.object(['a', 'b'], throwError), { a: undefined, b: undefined });
-    t.same(data.object({}), {});
-    t.same(data.object({ a: 1, b: 2 }), { a: 1, b: 2 });
-    t.same(data.object({ a: 1, b: 2 }, true), { a: true, b: true });
-    t.same(data.object({ a: 1, b: 2 }, dt), { a: dt, b: dt });
-    t.same(data.object({ a: 1, b: 2 }, [0]), { a: 0, b: undefined });
-    t.same(data.object({ a: 1, b: 2 }, [4, 5, 6]), { a: 4, b: 5 });
-    t.same(data.object({ a: 1, b: 2 }, { a: 31, b: 32, c: 33, d: 34 }), { a: 31, b: 32 });
-    t.same(data.object({ a: 1, b: 2 }, (k) => k), { a: 'a', b: 'b' });
-    const o1 = { k: 1, a: 1 };
-    const o2 = { k: 'a', a: 2 };
-    const o3 = { k: 'a', b: 3 };
-    const o4 = { a: 4, b: 4 };
-    t.not(data.object(o1), o1, 'input object is copied');
-    t.same(data.object('k', [o1, o2, o3, o4]), { '1': o1, 'a': o2 });
-    t.same(data.object((o) => o.k, [o1, o2, o3, o4]), { '1': o1, 'a': o2 });
-    t.end();
-});
-
-tap.test('data.clone()', (t) => {
-    t.same(data.clone(), undefined);
-    t.same(data.clone(null), null);
-    t.same(data.clone(1), 1);
-    t.same(data.clone(false), false);
-    t.same(data.clone('str'), 'str');
-    const o = { a: 1, b: ['z', 'x', 'y'], c: { sub: false } };
-    const res = data.clone(o);
-    t.same(res, o);
-    t.not(res, o);
-    t.not(res.b, o.b);
-    t.not(res.c, o.c);
-    const dt = new Date();
-    t.equal(data.clone(dt), dt);
-    const re = /test/;
-    t.equal(data.clone(re), re);
-    t.end();
-});
-
-tap.test('data.get()', (t) => {
-    t.equal(data.get('', null), undefined);
-    t.equal(data.get('a', null), undefined);
-    t.equal(data.get('a', {}), undefined);
-    t.equal(data.get('a', []), undefined);
-    t.equal(data.get('a', { a: 13 }), 13);
-    t.equal(data.get('a', { a: null }), null);
-    t.equal(data.get(1, { '0': 'a', '1': 'b' }), 'b');
-    t.equal(data.get(1, ['a', 'b']), 'b');
-    t.equal(data.get('[1]', ['a', 'b']), 'b');
-    t.equal(data.get('[1]', ['a']), undefined);
-    t.equal(data.get('a.b', { a: {} }), undefined);
-    t.equal(data.get('a.b', { a: { b: 42 } }), 42);
-    t.equal(data.get('a.1', { a: [13, 4711] }), 4711);
-    t.equal(data.get('a[1]', { a: [13, 4711] }), 4711);
-    t.same(data.get(['a', 'b'], { a: 13, c: 17 }), undefined);
-    t.same(data.get(['a', 'b'], { a: { b: 17 } }), 17);
-    t.same(data.get('a', []), undefined);
-    t.same(data.get('a', [[{ a: 13 }]]), undefined);
-    t.same(data.get('[].a', [null, { a: 13 }, { b: 42 }, { a: undefined }]), [13, undefined]);
-    t.same(data.get('a[].b', { a: [{ b: 42 }, { b: 19 }] }), [42, 19]);
-    t.same(data.get(['[]', 'b'], [null, { a: 13 }, { b: 42 }]), [42]);
-    t.same(data.get('*', { a: 1, b: null, c: undefined }), [1, null, undefined]);
-    t.same(data.get('*.a', { a: { b: 17 }, c: { a: 33 } }), [33]);
-    t.same(data.get('a.*', { a: { b: 17, c: 33 } }), [17, 33]);
-    let getFolderId = data.get('folder.id');
-    t.equal(typeof(getFolderId), 'function');
-    t.equal(getFolderId(null), undefined);
-    t.equal(getFolderId({ folder: 42 }), undefined);
-    t.equal(getFolderId({ folder: { id: 42 } }), 42);
-    t.end();
-});
-
-tap.test('data.filter()', (t) => {
-    t.same(data.filter(Boolean, null), []);
-    t.same(data.filter(Boolean, []), []);
-    t.same(data.filter(Boolean, {}), {});
-    t.same(data.filter(Boolean, [null, undefined, true, 1, 0, '', {}, []]), [true, 1, {}, []]);
-    t.same(data.filter(Boolean, { a: null, b: true, c: 0 }), { b: true });
-    t.same(data.filter(Boolean, arrayLike(0, 1, true, 'test')), [1, true, 'test']);
-    t.same(data.filter(throwError, [1, 2, 3]), []);
-    let isValid = data.filter('folder.id');
-    t.equal(typeof(isValid), 'function');
-    t.same(isValid(null), []);
-    t.same(isValid([{ folder: 42 }, {}, null]), []);
-    t.same(isValid([{}, { folder: { id: 42 } }]), [{ folder: { id: 42 } }]);
-    t.end();
-});
-
-tap.test('data.flatten()', (t) => {
-    t.same(data.flatten(), []);
-    t.same(data.flatten(null), [null]);
-    t.same(data.flatten(undefined), [undefined]);
-    t.same(data.flatten(1), [1]);
-    t.same(data.flatten(1, [2, 3]), [1, 2, 3]);
-    t.same(data.flatten([]), []);
-    t.same(data.flatten([1, [2, 3], [1, 2, [3]]]), [1, 2, 3, 1, 2, [3]]);
-    t.end();
-});
-
-tap.test('data.map()', (t) => {
-    t.same(data.map(Boolean, null), []);
-    t.same(data.map(Boolean, []), []);
-    t.same(data.map(Boolean, {}), {});
-    t.same(data.map(Boolean, [null, true, 1, 0, '']), [false, true, true, false, false]);
-    t.same(data.map(Boolean, { a: null, b: true, c: 0 }), { a: false, b: true, c: false });
-    t.same(data.map(Boolean, arrayLike(null, 'test')), [false, true]);
-    t.same(data.map(throwError, [1, 2, 3]), [undefined, undefined, undefined]);
-    let getFolderIds = data.map('folder.id');
-    t.equal(typeof(getFolderIds), 'function');
-    t.same(getFolderIds(null), []);
-    t.same(getFolderIds([{ folder: { id: 42 } }, {}, null]), [42, undefined, undefined]);
-    t.same(getFolderIds({ a: { folder: { id: 42 } }, b: {}, c: null }), { a: 42, b: undefined, c: undefined });
-    t.end();
-});
-
-tap.test('data.uniq()', (t) => {
-    t.same(data.uniq(), []);
-    t.same(data.uniq(null), []);
-    t.same(data.uniq([1, 2, 3, 3, 2, 1]), [1, 2, 3]);
-    t.same(data.uniq([{}, {}, null, null, undefined, 'test', 'test']), [{}, null, undefined, 'test']);
-    t.same(data.uniq([{ a: 1, b: 2 }, { a: 1, b: 2 }, { b: 2, a: 1 }]), [{ a: 1, b: 2 }, { b: 2, a: 1 }]);
-    t.same(data.uniq({ a: 1, b: 2, c: 1 }), [1, 2]);
-    t.same(data.uniq(String, [{}, { a: 1, b: 2 }, { a: 1, b: 2 }]), [{}]);
-    t.same(data.uniq((o) => o.a, [{ a: 1, b: 2 }, { a: 1, b: 2 }, { b: 2, a: 1 }]), [{ a: 1, b: 2 }]);
-    t.same(data.uniq(Boolean, [null, undefined, 0, 'test']), [null, 'test']);
-    const uniq = data.uniq(Boolean);
-    t.equal(typeof(uniq), 'function');
-    t.same(uniq([null, undefined, 0, 'test']), [null, 'test']);
-    t.end();
-});
-
-tap.test('data.compare()', (t) => {
-    t.equal(data.compare(null, undefined), 0);
-    t.equal(data.compare(undefined, null), 0);
-    t.equal(data.compare(1, 1), 0);
-    t.equal(data.compare(1, 42), -1);
-    t.equal(data.compare(1, NaN), 0);
-    t.equal(data.compare('abc', 'abc'), 0);
-    t.equal(data.compare('abc', 'cde'), -1);
-    t.equal(data.compare('cde', 'abc'), 1);
-    let toLower = (o) => String.prototype.toLowerCase.call('' + o);
-    let cmpIgnoreCase = data.compare(toLower);
-    t.equal(typeof(cmpIgnoreCase), 'function');
-    t.equal(cmpIgnoreCase('AbC', 'abc'), 0);
-    t.equal(cmpIgnoreCase('DEF', 'abc'), 1);
-    t.equal(cmpIgnoreCase(null, 'abc'), 1);
-    t.equal(cmpIgnoreCase(13, 'abc'), -1);
-    t.equal(cmpIgnoreCase(123, 123), 0);
-    let getId = (o) => o.id;
-    t.throws(data.compare.bind(null, getId, { id: 13 }, undefined));
-    t.end();
-});
-
-tap.test('data.sort()', (t) => {
-    t.same(data.sort(), []);
-    t.same(data.sort([]), []);
-    t.same(data.sort([3, 2, 1, 11]), [1, 2, 3, 11]);
-    t.same(data.sort(['b', 'B', 'a', 'aa', 'A']), ['A', 'B', 'a', 'aa', 'b']);
-    t.same(data.sort({}), []);
-    t.same(data.sort({ a: 3, b: 2, c: 1, d: 11 }), [1, 2, 3, 11]);
-    const toLower = (s) => s.toLowerCase();
-    t.same(data.sort(toLower, ['b', 'B', 'a', 'aa', 'A']), ['a', 'A', 'aa', 'b', 'B']);
-    const sort = data.sort(toLower);
-    t.equal(typeof(sort), 'function');
-    t.same(sort(['C', 'B', 'a']), ['a', 'B', 'C']);
-    t.end();
-});
diff --git a/src/plugin/test/files/js/rapidcontext/fn.test.mjs b/src/plugin/test/files/js/rapidcontext/fn.test.mjs
deleted file mode 100644
index f7a1ae5a..00000000
--- a/src/plugin/test/files/js/rapidcontext/fn.test.mjs
+++ /dev/null
@@ -1,256 +0,0 @@
-import tap from 'tap';
-import fn from '../../../../system/files/js/rapidcontext/fn.mjs';
-
-tap.test('fn.isNil()', (t) => {
-    t.equal(fn.isNil(undefined), true);
-    t.equal(fn.isNil(null), true);
-    t.equal(fn.isNil(true), false);
-    t.equal(fn.isNil(''), false);
-    t.equal(fn.isNil('undefined'), false);
-    t.end();
-});
-
-tap.test('fn.isNull()', (t) => {
-    t.equal(fn.isNull(undefined), false);
-    t.equal(fn.isNull(null), true);
-    t.equal(fn.isNull(true), false);
-    t.end();
-});
-
-tap.test('fn.isUndefined()', (t) => {
-    t.equal(fn.isUndefined(undefined), true);
-    t.equal(fn.isUndefined(null), false);
-    t.equal(fn.isUndefined(''), false);
-    t.end();
-});
-
-tap.test('fn.isBoolean()', (t) => {
-    t.equal(fn.isBoolean(undefined), false);
-    t.equal(fn.isBoolean(null), false);
-    t.equal(fn.isBoolean(0), false);
-    t.equal(fn.isBoolean(true), true);
-    t.equal(fn.isBoolean(false), true);
-    t.equal(fn.isBoolean(Boolean(1)), true);
-    t.equal(fn.isBoolean(''), false);
-    t.equal(fn.isBoolean({}), false);
-    t.end();
-});
-
-tap.test('fn.isFunction()', (t) => {
-    t.equal(fn.isFunction(undefined), false);
-    t.equal(fn.isFunction(null), false);
-    t.equal(fn.isFunction(fn.isFunction), true);
-    t.end();
-});
-
-tap.test('fn.isNumber()', (t) => {
-    t.equal(fn.isNumber(undefined), false);
-    t.equal(fn.isNumber(null), false);
-    t.equal(fn.isNumber(0), true);
-    t.equal(fn.isNumber(1.123), true);
-    t.equal(fn.isNumber(Number('4711')), true);
-    t.equal(fn.isNumber(Infinity), true);
-    t.equal(fn.isNumber(-Infinity), true);
-    t.equal(fn.isNumber(NaN), true);
-    t.equal(fn.isNumber('1'), false);
-    t.equal(fn.isNumber({}), false);
-    t.end();
-});
-
-tap.test('fn.isBigInt()', (t) => {
-    t.equal(fn.isBigInt(undefined), false);
-    t.equal(fn.isBigInt(0), false);
-    t.equal(fn.isBigInt(123n), true);
-    t.equal(fn.isBigInt(Infinity), false);
-    t.equal(fn.isBigInt(NaN), false);
-    t.end();
-});
-
-tap.test('fn.isString()', (t) => {
-    t.equal(fn.isString(undefined), false);
-    t.equal(fn.isString(null), false);
-    t.equal(fn.isString(''), true);
-    t.equal(fn.isString({}), false);
-    t.equal(fn.isString(['test']), false);
-    t.end();
-});
-
-tap.test('fn.isObject()', (t) => {
-    function TestObject() {
-        this.value = 123;
-    }
-    t.equal(fn.isObject(undefined), false);
-    t.equal(fn.isObject(null), false);
-    t.equal(fn.isObject(''), false);
-    t.equal(fn.isObject({}), true);
-    t.equal(fn.isObject([]), false);
-    t.equal(fn.isObject(/test/), false);
-    t.equal(fn.isObject(new TestObject()), false);
-    t.end();
-});
-
-tap.test('fn.isError()', (t) => {
-    t.equal(fn.isError(undefined), false);
-    t.equal(fn.isError(null), false);
-    t.equal(fn.isError({}), false);
-    t.equal(fn.isError(new Error()), true);
-    t.equal(fn.isError(new TypeError()), true);
-    t.end();
-});
-
-tap.test('fn.isDate()', (t) => {
-    t.equal(fn.isDate(undefined), false);
-    t.equal(fn.isDate(null), false);
-    t.equal(fn.isDate({}), false);
-    t.equal(fn.isDate(0), false);
-    t.equal(fn.isDate(new Date()), true);
-    t.end();
-});
-
-tap.test('fn.isRegExp()', (t) => {
-    t.equal(fn.isRegExp(undefined), false);
-    t.equal(fn.isRegExp(null), false);
-    t.equal(fn.isRegExp({}), false);
-    t.equal(fn.isRegExp(new RegExp('.')), true);
-    t.equal(fn.isRegExp(/abc/), true);
-    t.end();
-});
-
-tap.test('fn.isPromise()', (t) => {
-    t.equal(fn.isPromise(undefined), false);
-    t.equal(fn.isPromise(null), false);
-    t.equal(fn.isPromise({}), false);
-    t.equal(fn.isPromise(new Promise(() => null)), true);
-    t.equal(fn.isPromise(Promise.all([])), true);
-    t.end();
-});
-
-tap.test('fn.isArrayLike()', (t) => {
-    t.equal(fn.isArrayLike(undefined), false);
-    t.equal(fn.isArrayLike('123'), true);
-    t.equal(fn.isArrayLike({}), false);
-    t.equal(fn.isArrayLike([]), true);
-    t.equal(fn.isArrayLike(new Int8Array([1, 2, 3])), true);
-    t.end();
-});
-
-tap.test('fn.isSetLike()', (t) => {
-    t.equal(fn.isSetLike(undefined), false);
-    t.equal(fn.isSetLike('123'), false);
-    t.equal(fn.isSetLike([]), false);
-    t.equal(fn.isSetLike(new Set([])), true);
-    t.equal(fn.isSetLike(new Set([1, 2, 3])), true);
-    t.equal(fn.isSetLike(new Map([[1, 'one'], [2, 'two']])), true);
-    t.end();
-});
-
-tap.test('fn.isIterable()', (t) => {
-    t.equal(fn.isIterable(undefined), false);
-    t.equal(fn.isIterable('123'), true);
-    t.equal(fn.isIterable([]), true);
-    t.equal(fn.isIterable(new Set([1, 2, 3])), true);
-    t.equal(fn.isIterable(new Map([[1, 'one'], [2, 'two']])), true);
-    t.end();
-});
-
-tap.test('fn.isTypeOf()', (t) => {
-    let isFunction = fn.isTypeOf('function');
-    let isFunctionOrObject = fn.isTypeOf(['function', 'object']);
-    t.equal(typeof(isFunction), 'function');
-    t.equal(isFunction(undefined), false);
-    t.equal(isFunction(null), false);
-    t.equal(isFunction({}), false);
-    t.equal(isFunction(isFunction), true);
-    t.equal(isFunction(Array), true);
-    t.equal(isFunctionOrObject({}), true);
-    t.equal(isFunctionOrObject(isFunction), true);
-    t.end();
-});
-
-tap.test('fn.isInstanceOf()', (t) => {
-    let isArray = fn.isInstanceOf(Array);
-    t.equal(typeof(isArray), 'function');
-    t.equal(isArray(undefined), false);
-    t.equal(isArray(null), false);
-    t.equal(isArray({}), false);
-    t.equal(isArray([]), true);
-    t.equal(isArray(new Array(1)), true);
-    t.end();
-});
-
-tap.test('fn.hasProperty()', (t) => {
-    let hasLength = fn.hasProperty('length');
-    t.equal(typeof(hasLength), 'function');
-    t.equal(hasLength(undefined), false);
-    t.equal(hasLength(null), false);
-    t.equal(hasLength({}), false);
-    t.equal(hasLength([]), true);
-    t.equal(hasLength({ length: 42 }), true);
-    t.equal(fn.hasProperty(undefined, { 'undefined': 13 }), true);
-    t.equal(fn.hasProperty(undefined, { 'null': 42 }), false);
-    t.end();
-});
-
-tap.test('fn.hasValue()', (t) => {
-    t.equal(fn.hasValue(undefined), false);
-    t.equal(fn.hasValue(null), false);
-    t.equal(fn.hasValue(false), true);
-    t.equal(fn.hasValue(true), true);
-    t.equal(fn.hasValue(NaN), false);
-    t.equal(fn.hasValue(0), true);
-    t.equal(fn.hasValue(1), true);
-    t.equal(fn.hasValue(0n), true);
-    t.equal(fn.hasValue(''), false);
-    t.equal(fn.hasValue('abc'), true);
-    t.equal(fn.hasValue(/regex/), true);
-    t.equal(fn.hasValue(Symbol('foo')), true);
-    t.equal(fn.hasValue({}), false);
-    t.equal(fn.hasValue({ a: 1 }), true);
-    t.equal(fn.hasValue([]), false);
-    t.equal(fn.hasValue([0, 1, 2]), true);
-    t.equal(fn.hasValue(new Int8Array(0)), false);
-    t.equal(fn.hasValue(new Int8Array([1, 2, 3])), true);
-    t.equal(fn.hasValue(new Set([])), false);
-    t.equal(fn.hasValue(new Set([1, 2, 3])), true);
-    t.end();
-});
-
-tap.test('fn.eq()', (t) => {
-    t.equal(fn.eq(undefined, undefined), true);
-    t.equal(fn.eq(null, undefined), false);
-    t.equal(fn.eq(1, 1), true);
-    t.equal(fn.eq(1, 42), false);
-    t.equal(fn.eq(NaN, NaN), false);
-    t.equal(fn.eq(9007199254740991n, 9007199254740991n), true);
-    t.equal(fn.eq('abc', 'abc'), true);
-    t.equal(fn.eq('abc', 'abc', '123'), false);
-    t.equal(fn.eq([], []), true);
-    t.equal(fn.eq([], {}), false);
-    t.equal(fn.eq([1, 2, 3], [1, 2, 3]), true);
-    t.equal(fn.eq([1, 2, 3], [1, 2, 9]), false);
-    t.equal(fn.eq({}, {}), true);
-    t.equal(fn.eq({}, []), false);
-    t.equal(fn.eq({ a: 1 }, { a: 1 }), true);
-    t.equal(fn.eq({ a: 1 }, { b: 1 }), false);
-    t.equal(fn.eq({ a: 1, b: 13 }, { b: 13, a: 1 }), true);
-    t.equal(fn.eq({ a: [1, 2, 3], b: { c: 1337 } }, { b: { c: 1337 }, a: [1, 2, 3] }), true);
-    t.equal(fn.eq({ a: [1, 2, 3], b: { c: 1337 } }, { a: [1, 2, 3], b: { c: 1337, d: 9 } }), false);
-    let dt = new Date();
-    t.equal(fn.eq(dt, dt), true);
-    t.equal(fn.eq(new Date(), new Date()), false);
-    t.equal(fn.eq(Symbol('foo'), Symbol('foo')), false);
-    t.equal(fn.eq(Symbol.for('foo'), Symbol.for('foo')), true);
-    let is13 = fn.eq(13);
-    t.equal(typeof(is13), 'function');
-    t.equal(is13(12), false);
-    t.equal(is13(13), true);
-    t.equal(is13(13, 13, 11), false);
-    let getFolderId = (o) => o.folder.id;
-    let isValidFolderId = fn.eq(getFolderId, 13);
-    t.equal(typeof(isValidFolderId), 'function');
-    t.equal(isValidFolderId(), false);
-    t.equal(isValidFolderId({ folder: { id: 1 } }), false);
-    t.equal(isValidFolderId({ folder: { id: 13 } }), true);
-    t.equal(isValidFolderId(123), false);
-    t.end();
-});
diff --git a/test/src/js/loader-hooks.mjs b/test/src/js/loader-hooks.mjs
new file mode 100644
index 00000000..775e6130
--- /dev/null
+++ b/test/src/js/loader-hooks.mjs
@@ -0,0 +1,7 @@
+export async function resolve(specifier, context, nextResolve) {
+    if (specifier.startsWith('rapidcontext/')) {
+        let url = `../../../src/plugin/system/files/js/${specifier}`;
+        specifier = new URL(url, import.meta.url).href;
+    }
+	return await nextResolve(specifier, context);
+}
diff --git a/test/src/js/loader.mjs b/test/src/js/loader.mjs
new file mode 100644
index 00000000..033aefc5
--- /dev/null
+++ b/test/src/js/loader.mjs
@@ -0,0 +1,3 @@
+import { register } from 'node:module';
+
+register('./loader-hooks.mjs', import.meta.url);
diff --git a/test/src/js/rapidcontext/data.test.mjs b/test/src/js/rapidcontext/data.test.mjs
new file mode 100644
index 00000000..37391d1c
--- /dev/null
+++ b/test/src/js/rapidcontext/data.test.mjs
@@ -0,0 +1,226 @@
+import test from 'node:test';
+import assert from 'node:assert';
+import data from 'rapidcontext/data.mjs';
+
+function arrayLike() {
+    return arguments;
+}
+
+function throwError() {
+    throw new Error('test');
+}
+
+test('data.bool()', () => {
+    assert.strictEqual(data.bool(), false);
+    assert.strictEqual(data.bool(null), false);
+    assert.strictEqual(data.bool(true), true);
+    assert.strictEqual(data.bool(false), false);
+    assert.strictEqual(data.bool(NaN), false);
+    assert.strictEqual(data.bool(0), false);
+    assert.strictEqual(data.bool(1), true);
+    assert.strictEqual(data.bool(''), false);
+    assert.strictEqual(data.bool('on'), true);
+    assert.strictEqual(data.bool('OFF'), false);
+    assert.strictEqual(data.bool('FaLsE'), false);
+    assert.strictEqual(data.bool('null'), false);
+    assert.strictEqual(data.bool('falsy'), true);
+    assert.strictEqual(data.bool({}), true);
+});
+
+test('data.array()', () => {
+    assert.deepEqual(data.array(), []);
+    assert.deepEqual(data.array(null), []);
+    assert.deepEqual(data.array(undefined), []);
+    assert.deepEqual(data.array(null, undefined), [null, undefined]);
+    assert.deepEqual(data.array(false), [false]);
+    assert.deepEqual(data.array(0), [0]);
+    assert.deepEqual(data.array(1, 'two', false), [1, 'two', false]);
+    assert.deepEqual(data.array([]), []);
+    assert.deepEqual(data.array([], []), [[], []]);
+    assert.deepEqual(data.array([1, 'two', false]), [1, 'two', false]);
+    assert.deepEqual(data.array({}), []);
+    assert.deepEqual(data.array({}, {}), [{}, {}]);
+    assert.deepEqual(data.array({ a: 1, b: 'two', c: false }), [1, 'two', false]);
+    assert.deepEqual(data.array(new Set([1, 2, 3])), [1, 2, 3]);
+    const arr = [1, 2, 3];
+    assert.deepEqual(data.array(arr), arr, 'input array is copied');
+    assert.notStrictEqual(data.array(arr), arr, 'input array is copied');
+});
+
+test('data.object()', () => {
+    const dt = new Date();
+    assert.deepEqual(data.object(), {});
+    assert.deepEqual(data.object(null, 1), {});
+    assert.deepEqual(data.object(undefined, 1), {});
+    assert.deepEqual(data.object('a'), {});
+    assert.deepEqual(data.object((o) => o.id), {});
+    assert.deepEqual(data.object([]), {});
+    assert.deepEqual(data.object([['a', 1], ['b', 2], ['c']]), { a: 1, b: 2, c: undefined });
+    assert.deepEqual(data.object(['a', null, ['b']]), { 'a': undefined, 'b': undefined });
+    assert.deepEqual(data.object(['a', 'a', 'a']), { a: undefined });
+    assert.deepEqual(data.object(['a', 'b'], true), { a: true, b: true });
+    assert.deepEqual(data.object(['a', 'b'], dt), { a: dt, b: dt });
+    assert.deepEqual(data.object(['a', 'b'], [1, 2]), { a: 1, b: 2 });
+    assert.deepEqual(data.object([1, null, 3, 1], [1, 2, 3, 4]), { '1': 1, '3': 3 });
+    assert.deepEqual(data.object(['a', 'b', 'c'], [1, 2]), { a: 1, b: 2, c: undefined });
+    assert.deepEqual(data.object(['a', 'a', 'a'], [1, 2, 3]), { a: 1 });
+    assert.deepEqual(data.object(['a', 'b'], { a: 1, b: 2, c: 3, d: 4 }), { a: 1, b: 2 });
+    assert.deepEqual(data.object(['a', 'b'], (k) => k), { a: 'a', b: 'b' });
+    assert.deepEqual(data.object(['a', 'b'], throwError), { a: undefined, b: undefined });
+    assert.deepEqual(data.object({}), {});
+    assert.deepEqual(data.object({ a: 1, b: 2 }), { a: 1, b: 2 });
+    assert.deepEqual(data.object({ a: 1, b: 2 }, true), { a: true, b: true });
+    assert.deepEqual(data.object({ a: 1, b: 2 }, dt), { a: dt, b: dt });
+    assert.deepEqual(data.object({ a: 1, b: 2 }, [0]), { a: 0, b: undefined });
+    assert.deepEqual(data.object({ a: 1, b: 2 }, [4, 5, 6]), { a: 4, b: 5 });
+    assert.deepEqual(data.object({ a: 1, b: 2 }, { a: 31, b: 32, c: 33, d: 34 }), { a: 31, b: 32 });
+    assert.deepEqual(data.object({ a: 1, b: 2 }, (k) => k), { a: 'a', b: 'b' });
+    const o1 = { k: 1, a: 1 };
+    const o2 = { k: 'a', a: 2 };
+    const o3 = { k: 'a', b: 3 };
+    const o4 = { a: 4, b: 4 };
+    assert.deepEqual(data.object(o1), o1, 'input object is copied');
+    assert.notStrictEqual(data.object(o1), o1, 'input object is copied');
+    assert.deepEqual(data.object('k', [o1, o2, o3, o4]), { '1': o1, 'a': o2 });
+    assert.deepEqual(data.object((o) => o.k, [o1, o2, o3, o4]), { '1': o1, 'a': o2 });
+});
+
+test('data.clone()', () => {
+    assert.strictEqual(data.clone(), undefined);
+    assert.strictEqual(data.clone(null), null);
+    assert.strictEqual(data.clone(1), 1);
+    assert.strictEqual(data.clone(false), false);
+    assert.strictEqual(data.clone('str'), 'str');
+    const o = { a: 1, b: ['z', 'x', 'y'], c: { sub: false } };
+    const res = data.clone(o);
+    assert.deepEqual(res, o);
+    assert.notStrictEqual(res, o);
+    assert.notStrictEqual(res.b, o.b);
+    assert.notStrictEqual(res.c, o.c);
+    const dt = new Date();
+    assert.strictEqual(data.clone(dt), dt);
+    const re = /test/;
+    assert.strictEqual(data.clone(re), re);
+});
+
+test('data.get()', () => {
+    assert.strictEqual(data.get('', null), undefined);
+    assert.strictEqual(data.get('a', null), undefined);
+    assert.strictEqual(data.get('a', {}), undefined);
+    assert.strictEqual(data.get('a', []), undefined);
+    assert.strictEqual(data.get('a', { a: 13 }), 13);
+    assert.strictEqual(data.get('a', { a: null }), null);
+    assert.strictEqual(data.get(1, { '0': 'a', '1': 'b' }), 'b');
+    assert.strictEqual(data.get(1, ['a', 'b']), 'b');
+    assert.strictEqual(data.get('[1]', ['a', 'b']), 'b');
+    assert.strictEqual(data.get('[1]', ['a']), undefined);
+    assert.strictEqual(data.get('a.b', { a: {} }), undefined);
+    assert.strictEqual(data.get('a.b', { a: { b: 42 } }), 42);
+    assert.strictEqual(data.get('a.1', { a: [13, 4711] }), 4711);
+    assert.strictEqual(data.get('a[1]', { a: [13, 4711] }), 4711);
+    assert.strictEqual(data.get(['a', 'b'], { a: 13, c: 17 }), undefined);
+    assert.strictEqual(data.get(['a', 'b'], { a: { b: 17 } }), 17);
+    assert.strictEqual(data.get('a', []), undefined);
+    assert.strictEqual(data.get('a', [[{ a: 13 }]]), undefined);
+    assert.deepEqual(data.get('[].a', [null, { a: 13 }, { b: 42 }, { a: undefined }]), [13, undefined]);
+    assert.deepEqual(data.get('a[].b', { a: [{ b: 42 }, { b: 19 }] }), [42, 19]);
+    assert.deepEqual(data.get(['[]', 'b'], [null, { a: 13 }, { b: 42 }]), [42]);
+    assert.deepEqual(data.get('*', { a: 1, b: null, c: undefined }), [1, null, undefined]);
+    assert.deepEqual(data.get('*.a', { a: { b: 17 }, c: { a: 33 } }), [33]);
+    assert.deepEqual(data.get('a.*', { a: { b: 17, c: 33 } }), [17, 33]);
+    let getFolderId = data.get('folder.id');
+    assert.strictEqual(typeof(getFolderId), 'function');
+    assert.strictEqual(getFolderId(null), undefined);
+    assert.strictEqual(getFolderId({ folder: 42 }), undefined);
+    assert.strictEqual(getFolderId({ folder: { id: 42 } }), 42);
+});
+
+test('data.filter()', () => {
+    assert.deepEqual(data.filter(Boolean, null), []);
+    assert.deepEqual(data.filter(Boolean, []), []);
+    assert.deepEqual(data.filter(Boolean, {}), {});
+    assert.deepEqual(data.filter(Boolean, [null, undefined, true, 1, 0, '', {}, []]), [true, 1, {}, []]);
+    assert.deepEqual(data.filter(Boolean, { a: null, b: true, c: 0 }), { b: true });
+    assert.deepEqual(data.filter(Boolean, arrayLike(0, 1, true, 'test')), [1, true, 'test']);
+    assert.deepEqual(data.filter(throwError, [1, 2, 3]), []);
+    let isValid = data.filter('folder.id');
+    assert.strictEqual(typeof(isValid), 'function');
+    assert.deepEqual(isValid(null), []);
+    assert.deepEqual(isValid([{ folder: 42 }, {}, null]), []);
+    assert.deepEqual(isValid([{}, { folder: { id: 42 } }]), [{ folder: { id: 42 } }]);
+});
+
+test('data.flatten()', () => {
+    assert.deepEqual(data.flatten(), []);
+    assert.deepEqual(data.flatten(null), [null]);
+    assert.deepEqual(data.flatten(undefined), [undefined]);
+    assert.deepEqual(data.flatten(1), [1]);
+    assert.deepEqual(data.flatten(1, [2, 3]), [1, 2, 3]);
+    assert.deepEqual(data.flatten([]), []);
+    assert.deepEqual(data.flatten([1, [2, 3], [1, 2, [3]]]), [1, 2, 3, 1, 2, [3]]);
+});
+
+test('data.map()', () => {
+    assert.deepEqual(data.map(Boolean, null), []);
+    assert.deepEqual(data.map(Boolean, []), []);
+    assert.deepEqual(data.map(Boolean, {}), {});
+    assert.deepEqual(data.map(Boolean, [null, true, 1, 0, '']), [false, true, true, false, false]);
+    assert.deepEqual(data.map(Boolean, { a: null, b: true, c: 0 }), { a: false, b: true, c: false });
+    assert.deepEqual(data.map(Boolean, arrayLike(null, 'test')), [false, true]);
+    assert.deepEqual(data.map(throwError, [1, 2, 3]), [undefined, undefined, undefined]);
+    let getFolderIds = data.map('folder.id');
+    assert.strictEqual(typeof(getFolderIds), 'function');
+    assert.deepEqual(getFolderIds(null), []);
+    assert.deepEqual(getFolderIds([{ folder: { id: 42 } }, {}, null]), [42, undefined, undefined]);
+    assert.deepEqual(getFolderIds({ a: { folder: { id: 42 } }, b: {}, c: null }), { a: 42, b: undefined, c: undefined });
+});
+
+test('data.uniq()', () => {
+    assert.deepEqual(data.uniq(), []);
+    assert.deepEqual(data.uniq(null), []);
+    assert.deepEqual(data.uniq([1, 2, 3, 3, 2, 1]), [1, 2, 3]);
+    assert.deepEqual(data.uniq([{}, {}, null, null, undefined, 'test', 'test']), [{}, null, undefined, 'test']);
+    assert.deepEqual(data.uniq([{ a: 1, b: 2 }, { a: 1, b: 2 }, { b: 2, a: 1 }]), [{ a: 1, b: 2 }, { b: 2, a: 1 }]);
+    assert.deepEqual(data.uniq({ a: 1, b: 2, c: 1 }), [1, 2]);
+    assert.deepEqual(data.uniq(String, [{}, { a: 1, b: 2 }, { a: 1, b: 2 }]), [{}]);
+    assert.deepEqual(data.uniq((o) => o.a, [{ a: 1, b: 2 }, { a: 1, b: 2 }, { b: 2, a: 1 }]), [{ a: 1, b: 2 }]);
+    assert.deepEqual(data.uniq(Boolean, [null, undefined, 0, 'test']), [null, 'test']);
+    const uniq = data.uniq(Boolean);
+    assert.strictEqual(typeof(uniq), 'function');
+    assert.deepEqual(uniq([null, undefined, 0, 'test']), [null, 'test']);
+});
+
+test('data.compare()', () => {
+    assert.strictEqual(data.compare(null, undefined), 0);
+    assert.strictEqual(data.compare(undefined, null), 0);
+    assert.strictEqual(data.compare(1, 1), 0);
+    assert.strictEqual(data.compare(1, 42), -1);
+    assert.strictEqual(data.compare(1, NaN), 0);
+    assert.strictEqual(data.compare('abc', 'abc'), 0);
+    assert.strictEqual(data.compare('abc', 'cde'), -1);
+    assert.strictEqual(data.compare('cde', 'abc'), 1);
+    let toLower = (o) => String.prototype.toLowerCase.call('' + o);
+    let cmpIgnoreCase = data.compare(toLower);
+    assert.strictEqual(typeof(cmpIgnoreCase), 'function');
+    assert.strictEqual(cmpIgnoreCase('AbC', 'abc'), 0);
+    assert.strictEqual(cmpIgnoreCase('DEF', 'abc'), 1);
+    assert.strictEqual(cmpIgnoreCase(null, 'abc'), 1);
+    assert.strictEqual(cmpIgnoreCase(13, 'abc'), -1);
+    assert.strictEqual(cmpIgnoreCase(123, 123), 0);
+    let getId = (o) => o.id;
+    assert.throws(data.compare.bind(null, getId, { id: 13 }, undefined));
+});
+
+test('data.sort()', () => {
+    assert.deepEqual(data.sort(), []);
+    assert.deepEqual(data.sort([]), []);
+    assert.deepEqual(data.sort([3, 2, 1, 11]), [1, 2, 3, 11]);
+    assert.deepEqual(data.sort(['b', 'B', 'a', 'aa', 'A']), ['A', 'B', 'a', 'aa', 'b']);
+    assert.deepEqual(data.sort({}), []);
+    assert.deepEqual(data.sort({ a: 3, b: 2, c: 1, d: 11 }), [1, 2, 3, 11]);
+    const toLower = (s) => s.toLowerCase();
+    assert.deepEqual(data.sort(toLower, ['b', 'B', 'a', 'aa', 'A']), ['a', 'A', 'aa', 'b', 'B']);
+    const sort = data.sort(toLower);
+    assert.strictEqual(typeof(sort), 'function');
+    assert.deepEqual(sort(['C', 'B', 'a']), ['a', 'B', 'C']);
+});
diff --git a/test/src/js/rapidcontext/fn.test.mjs b/test/src/js/rapidcontext/fn.test.mjs
new file mode 100644
index 00000000..b0a89533
--- /dev/null
+++ b/test/src/js/rapidcontext/fn.test.mjs
@@ -0,0 +1,236 @@
+import test from 'node:test';
+import assert from 'node:assert';
+import fn from 'rapidcontext/fn.mjs';
+
+test('fn.isNil()', () => {
+    assert.strictEqual(fn.isNil(undefined), true);
+    assert.strictEqual(fn.isNil(null), true);
+    assert.strictEqual(fn.isNil(true), false);
+    assert.strictEqual(fn.isNil(''), false);
+    assert.strictEqual(fn.isNil('undefined'), false);
+});
+
+test('fn.isNull()', () => {
+    assert.strictEqual(fn.isNull(undefined), false);
+    assert.strictEqual(fn.isNull(null), true);
+    assert.strictEqual(fn.isNull(true), false);
+});
+
+test('fn.isUndefined()', () => {
+    assert.strictEqual(fn.isUndefined(undefined), true);
+    assert.strictEqual(fn.isUndefined(null), false);
+    assert.strictEqual(fn.isUndefined(''), false);
+});
+
+test('fn.isBoolean()', () => {
+    assert.strictEqual(fn.isBoolean(undefined), false);
+    assert.strictEqual(fn.isBoolean(null), false);
+    assert.strictEqual(fn.isBoolean(0), false);
+    assert.strictEqual(fn.isBoolean(true), true);
+    assert.strictEqual(fn.isBoolean(false), true);
+    assert.strictEqual(fn.isBoolean(Boolean(1)), true);
+    assert.strictEqual(fn.isBoolean(''), false);
+    assert.strictEqual(fn.isBoolean({}), false);
+});
+
+test('fn.isFunction()', () => {
+    assert.strictEqual(fn.isFunction(undefined), false);
+    assert.strictEqual(fn.isFunction(null), false);
+    assert.strictEqual(fn.isFunction(fn.isFunction), true);
+});
+
+test('fn.isNumber()', () => {
+    assert.strictEqual(fn.isNumber(undefined), false);
+    assert.strictEqual(fn.isNumber(null), false);
+    assert.strictEqual(fn.isNumber(0), true);
+    assert.strictEqual(fn.isNumber(1.123), true);
+    assert.strictEqual(fn.isNumber(Number('4711')), true);
+    assert.strictEqual(fn.isNumber(Infinity), true);
+    assert.strictEqual(fn.isNumber(-Infinity), true);
+    assert.strictEqual(fn.isNumber(NaN), true);
+    assert.strictEqual(fn.isNumber('1'), false);
+    assert.strictEqual(fn.isNumber({}), false);
+});
+
+test('fn.isBigInt()', () => {
+    assert.strictEqual(fn.isBigInt(undefined), false);
+    assert.strictEqual(fn.isBigInt(0), false);
+    assert.strictEqual(fn.isBigInt(123n), true);
+    assert.strictEqual(fn.isBigInt(Infinity), false);
+    assert.strictEqual(fn.isBigInt(NaN), false);
+});
+
+test('fn.isString()', () => {
+    assert.strictEqual(fn.isString(undefined), false);
+    assert.strictEqual(fn.isString(null), false);
+    assert.strictEqual(fn.isString(''), true);
+    assert.strictEqual(fn.isString({}), false);
+    assert.strictEqual(fn.isString(['test']), false);
+});
+
+test('fn.isObject()', () => {
+    function TestObject() {
+        this.value = 123;
+    }
+    assert.strictEqual(fn.isObject(undefined), false);
+    assert.strictEqual(fn.isObject(null), false);
+    assert.strictEqual(fn.isObject(''), false);
+    assert.strictEqual(fn.isObject({}), true);
+    assert.strictEqual(fn.isObject([]), false);
+    assert.strictEqual(fn.isObject(/test/), false);
+    assert.strictEqual(fn.isObject(new TestObject()), false);
+});
+
+test('fn.isError()', () => {
+    assert.strictEqual(fn.isError(undefined), false);
+    assert.strictEqual(fn.isError(null), false);
+    assert.strictEqual(fn.isError({}), false);
+    assert.strictEqual(fn.isError(new Error()), true);
+    assert.strictEqual(fn.isError(new TypeError()), true);
+});
+
+test('fn.isDate()', () => {
+    assert.strictEqual(fn.isDate(undefined), false);
+    assert.strictEqual(fn.isDate(null), false);
+    assert.strictEqual(fn.isDate({}), false);
+    assert.strictEqual(fn.isDate(0), false);
+    assert.strictEqual(fn.isDate(new Date()), true);
+});
+
+test('fn.isRegExp()', () => {
+    assert.strictEqual(fn.isRegExp(undefined), false);
+    assert.strictEqual(fn.isRegExp(null), false);
+    assert.strictEqual(fn.isRegExp({}), false);
+    assert.strictEqual(fn.isRegExp(new RegExp('.')), true);
+    assert.strictEqual(fn.isRegExp(/abc/), true);
+});
+
+test('fn.isPromise()', () => {
+    assert.strictEqual(fn.isPromise(undefined), false);
+    assert.strictEqual(fn.isPromise(null), false);
+    assert.strictEqual(fn.isPromise({}), false);
+    assert.strictEqual(fn.isPromise(new Promise(() => null)), true);
+    assert.strictEqual(fn.isPromise(Promise.all([])), true);
+});
+
+test('fn.isArrayLike()', () => {
+    assert.strictEqual(fn.isArrayLike(undefined), false);
+    assert.strictEqual(fn.isArrayLike('123'), true);
+    assert.strictEqual(fn.isArrayLike({}), false);
+    assert.strictEqual(fn.isArrayLike([]), true);
+    assert.strictEqual(fn.isArrayLike(new Int8Array([1, 2, 3])), true);
+});
+
+test('fn.isSetLike()', () => {
+    assert.strictEqual(fn.isSetLike(undefined), false);
+    assert.strictEqual(fn.isSetLike('123'), false);
+    assert.strictEqual(fn.isSetLike([]), false);
+    assert.strictEqual(fn.isSetLike(new Set([])), true);
+    assert.strictEqual(fn.isSetLike(new Set([1, 2, 3])), true);
+    assert.strictEqual(fn.isSetLike(new Map([[1, 'one'], [2, 'two']])), true);
+});
+
+test('fn.isIterable()', () => {
+    assert.strictEqual(fn.isIterable(undefined), false);
+    assert.strictEqual(fn.isIterable('123'), true);
+    assert.strictEqual(fn.isIterable([]), true);
+    assert.strictEqual(fn.isIterable(new Set([1, 2, 3])), true);
+    assert.strictEqual(fn.isIterable(new Map([[1, 'one'], [2, 'two']])), true);
+});
+
+test('fn.isTypeOf()', () => {
+    let isFunction = fn.isTypeOf('function');
+    let isFunctionOrObject = fn.isTypeOf(['function', 'object']);
+    assert.strictEqual(typeof(isFunction), 'function');
+    assert.strictEqual(isFunction(undefined), false);
+    assert.strictEqual(isFunction(null), false);
+    assert.strictEqual(isFunction({}), false);
+    assert.strictEqual(isFunction(isFunction), true);
+    assert.strictEqual(isFunction(Array), true);
+    assert.strictEqual(isFunctionOrObject({}), true);
+    assert.strictEqual(isFunctionOrObject(isFunction), true);
+});
+
+test('fn.isInstanceOf()', () => {
+    let isArray = fn.isInstanceOf(Array);
+    assert.strictEqual(typeof(isArray), 'function');
+    assert.strictEqual(isArray(undefined), false);
+    assert.strictEqual(isArray(null), false);
+    assert.strictEqual(isArray({}), false);
+    assert.strictEqual(isArray([]), true);
+    assert.strictEqual(isArray(new Array(1)), true);
+});
+
+test('fn.hasProperty()', () => {
+    let hasLength = fn.hasProperty('length');
+    assert.strictEqual(typeof(hasLength), 'function');
+    assert.strictEqual(hasLength(undefined), false);
+    assert.strictEqual(hasLength(null), false);
+    assert.strictEqual(hasLength({}), false);
+    assert.strictEqual(hasLength([]), true);
+    assert.strictEqual(hasLength({ length: 42 }), true);
+    assert.strictEqual(fn.hasProperty(undefined, { 'undefined': 13 }), true);
+    assert.strictEqual(fn.hasProperty(undefined, { 'null': 42 }), false);
+});
+
+test('fn.hasValue()', () => {
+    assert.strictEqual(fn.hasValue(undefined), false);
+    assert.strictEqual(fn.hasValue(null), false);
+    assert.strictEqual(fn.hasValue(false), true);
+    assert.strictEqual(fn.hasValue(true), true);
+    assert.strictEqual(fn.hasValue(NaN), false);
+    assert.strictEqual(fn.hasValue(0), true);
+    assert.strictEqual(fn.hasValue(1), true);
+    assert.strictEqual(fn.hasValue(0n), true);
+    assert.strictEqual(fn.hasValue(''), false);
+    assert.strictEqual(fn.hasValue('abc'), true);
+    assert.strictEqual(fn.hasValue(/regex/), true);
+    assert.strictEqual(fn.hasValue(Symbol('foo')), true);
+    assert.strictEqual(fn.hasValue({}), false);
+    assert.strictEqual(fn.hasValue({ a: 1 }), true);
+    assert.strictEqual(fn.hasValue([]), false);
+    assert.strictEqual(fn.hasValue([0, 1, 2]), true);
+    assert.strictEqual(fn.hasValue(new Int8Array(0)), false);
+    assert.strictEqual(fn.hasValue(new Int8Array([1, 2, 3])), true);
+    assert.strictEqual(fn.hasValue(new Set([])), false);
+    assert.strictEqual(fn.hasValue(new Set([1, 2, 3])), true);
+});
+
+test('fn.eq()', () => {
+    assert.strictEqual(fn.eq(undefined, undefined), true);
+    assert.strictEqual(fn.eq(null, undefined), false);
+    assert.strictEqual(fn.eq(1, 1), true);
+    assert.strictEqual(fn.eq(1, 42), false);
+    assert.strictEqual(fn.eq(NaN, NaN), false);
+    assert.strictEqual(fn.eq(9007199254740991n, 9007199254740991n), true);
+    assert.strictEqual(fn.eq('abc', 'abc'), true);
+    assert.strictEqual(fn.eq('abc', 'abc', '123'), false);
+    assert.strictEqual(fn.eq([], []), true);
+    assert.strictEqual(fn.eq([], {}), false);
+    assert.strictEqual(fn.eq([1, 2, 3], [1, 2, 3]), true);
+    assert.strictEqual(fn.eq([1, 2, 3], [1, 2, 9]), false);
+    assert.strictEqual(fn.eq({}, {}), true);
+    assert.strictEqual(fn.eq({}, []), false);
+    assert.strictEqual(fn.eq({ a: 1 }, { a: 1 }), true);
+    assert.strictEqual(fn.eq({ a: 1 }, { b: 1 }), false);
+    assert.strictEqual(fn.eq({ a: 1, b: 13 }, { b: 13, a: 1 }), true);
+    assert.strictEqual(fn.eq({ a: [1, 2, 3], b: { c: 1337 } }, { b: { c: 1337 }, a: [1, 2, 3] }), true);
+    assert.strictEqual(fn.eq({ a: [1, 2, 3], b: { c: 1337 } }, { a: [1, 2, 3], b: { c: 1337, d: 9 } }), false);
+    let dt = new Date();
+    assert.strictEqual(fn.eq(dt, dt), true);
+    assert.strictEqual(fn.eq(new Date(), new Date()), false);
+    assert.strictEqual(fn.eq(Symbol('foo'), Symbol('foo')), false);
+    assert.strictEqual(fn.eq(Symbol.for('foo'), Symbol.for('foo')), true);
+    let is13 = fn.eq(13);
+    assert.strictEqual(typeof(is13), 'function');
+    assert.strictEqual(is13(12), false);
+    assert.strictEqual(is13(13), true);
+    assert.strictEqual(is13(13, 13, 11), false);
+    let getFolderId = (o) => o.folder.id;
+    let isValidFolderId = fn.eq(getFolderId, 13);
+    assert.strictEqual(typeof(isValidFolderId), 'function');
+    assert.strictEqual(isValidFolderId(), false);
+    assert.strictEqual(isValidFolderId({ folder: { id: 1 } }), false);
+    assert.strictEqual(isValidFolderId({ folder: { id: 13 } }), true);
+    assert.strictEqual(isValidFolderId(123), false);
+});