diff --git a/jakefile.js b/jakefile.cjs
similarity index 100%
rename from jakefile.js
rename to jakefile.cjs
diff --git a/lib/esm/package.json b/lib/esm/package.json
deleted file mode 100644
index 3dbc1ca5..00000000
--- a/lib/esm/package.json
+++ /dev/null
@@ -1,3 +0,0 @@
-{
-  "type": "module"
-}
diff --git a/package.json b/package.json
index a4ea5c6b..d82074b9 100644
--- a/package.json
+++ b/package.json
@@ -10,6 +10,7 @@
   "version": "4.0.0",
   "author": "Matthew Eernisse <matthew.eernisse@gmail.com>",
   "license": "Apache-2.0",
+  "type": "module",
   "bin": {
     "ejs": "./bin/cli.js"
   },
@@ -47,7 +48,7 @@
     "npm": ">=10"
   },
   "scripts": {
-    "build": "jake build",
-    "test": "jake test"
+    "build": "jake --jakefile=jakefile.cjs build",
+    "test": "jake --jakefile=jakefile.cjs test"
   }
 }
diff --git a/test/cli.js b/test/cli.js
index 31c33dc1..2fda4bc1 100644
--- a/test/cli.js
+++ b/test/cli.js
@@ -1,7 +1,7 @@
-let exec = require('child_process').execSync;
-let fs = require('fs');
-let path = require('path');
-let assert = require('assert');
+import { execSync as exec } from 'child_process';
+import { readFileSync } from 'fs';
+import { join } from 'path';
+import { equal } from 'assert';
 let os = process.platform !== 'win32' ? '' : 'node ';
 let lf = process.platform !== 'win32' ? '\n' : '\r\n';
 
@@ -11,55 +11,55 @@ function run(cmd) {
 
 suite('cli', function () {
   test('rendering, custom delimiter, passed data', function () {
-    let x = path.join('./bin/cli.js');
-    let u = path.join('./test/fixtures/user.ejs');
+    let x = join('./bin/cli.js');
+    let u = join('./test/fixtures/user.ejs');
     let o = run(os+x+' -m $ '+u+' name=foo');
-    assert.equal(o, '<h1>foo</h1>'+lf);
+    equal(o, '<h1>foo</h1>'+lf);
   });
 
   test('rendering, custom delimiter, data from file with -f', function () {
-    let x = path.join('./bin/cli.js');
-    let u = path.join('./test/fixtures/user.ejs');
+    let x = join('./bin/cli.js');
+    let u = join('./test/fixtures/user.ejs');
     let o = run(os+x+' -m $ -f ./test/fixtures/user_data.json '+u);
-    assert.equal(o, '<h1>zerb</h1>'+lf);
+    equal(o, '<h1>zerb</h1>'+lf);
   });
 
   test('rendering, custom delimiter, data from CLI arg with -i', function () {
-    let x = path.join('./bin/cli.js');
-    let u = path.join('./test/fixtures/user.ejs');
+    let x = join('./bin/cli.js');
+    let u = join('./test/fixtures/user.ejs');
     let o = run(os+x+' -m $ -i %7B%22name%22%3A%20%22foo%22%7D '+u);
-    assert.equal(o, '<h1>foo</h1>'+lf);
+    equal(o, '<h1>foo</h1>'+lf);
   });
 
   test('rendering, custom delimiter, data from stdin / pipe', function () {
     if ( process.platform !== 'win32' ) {
       let o = run('cat ./test/fixtures/user_data.json | ./bin/cli.js -m $ ./test/fixtures/user.ejs');
-      assert.equal(o, '<h1>zerb</h1>\n');
+      equal(o, '<h1>zerb</h1>\n');
     } // does not work on windows...
   });
 
   test('rendering, custom delimiter, passed data overrides file', function () {
-    let x = path.join('./bin/cli.js');
-    let f = path.join('./test/fixtures/user_data.json');
-    let g = path.join('./test/fixtures/user.ejs');
+    let x = join('./bin/cli.js');
+    let f = join('./test/fixtures/user_data.json');
+    let g = join('./test/fixtures/user.ejs');
     let o = run(os+x+' -m $ -f '+f+' '+g+' name=frang');
-    assert.equal(o, '<h1>frang</h1>'+lf);
+    equal(o, '<h1>frang</h1>'+lf);
   });
 
   test('rendering, remove whitespace option (hyphen case)', function () {
-    let x = path.join('./bin/cli.js');
-    let f = path.join('./test/fixtures/rmWhitespace.ejs');
+    let x = join('./bin/cli.js');
+    let f = join('./test/fixtures/rmWhitespace.ejs');
     let o = run(os+x+' --rm-whitespace '+f);
-    let c = fs.readFileSync('test/fixtures/rmWhitespace.html', 'utf-8');
-    assert.equal(o.replace(/\n/g, lf), c);
+    let c = readFileSync('test/fixtures/rmWhitespace.html', 'utf-8');
+    equal(o.replace(/\n/g, lf), c);
   });
 
   test('relative path in nested include', function () {
-    let x = path.join('./bin/cli.js');
-    let u = path.join('test/fixtures/include-simple.ejs');
+    let x = join('./bin/cli.js');
+    let u = join('test/fixtures/include-simple.ejs');
     let o = run(os+x+' '+u);
-    let c = fs.readFileSync('test/fixtures/include-simple.html', 'utf-8');
-    assert.equal(o, c);
+    let c = readFileSync('test/fixtures/include-simple.html', 'utf-8');
+    equal(o, c);
   });
 
 });
diff --git a/test/ejs.js b/test/ejs.js
index 62581d54..8c1527a8 100755
--- a/test/ejs.js
+++ b/test/ejs.js
@@ -4,15 +4,15 @@
  * Module dependencies.
  */
 
-var ejs = require('..');
-var fs = require('fs');
-var assert = require('assert');
-var path = require('path');
-var LRU = require('lru-cache');
+import ejs from '../lib/esm/ejs.js';
+import { mkdirSync, readFileSync, writeFileSync } from 'fs';
+import { equal, notEqual, ifError, ok, throws } from 'assert';
+import { join } from 'path';
+import LRU from 'lru-cache';
 let lf = process.platform !== 'win32' ? '\n' : '\r\n';
 
 try {
-  fs.mkdirSync(__dirname + '/tmp');
+  mkdirSync(__dirname + '/tmp');
 } catch (ex) {
   if (ex.code !== 'EEXIST') {
     throw ex;
@@ -63,12 +63,12 @@ try {
 suite('ejs.compile(str, options)', function () {
   test('compile to a function', function () {
     var fn = ejs.compile('<p>yay</p>');
-    assert.equal(fn(), '<p>yay</p>');
+    equal(fn(), '<p>yay</p>');
   });
 
   test('empty input works', function () {
     var fn = ejs.compile('');
-    assert.equal(fn(), '');
+    equal(fn(), '');
   });
 
   test('throw if there are syntax errors', function () {
@@ -76,13 +76,13 @@ suite('ejs.compile(str, options)', function () {
       ejs.compile(fixture('fail.ejs'));
     }
     catch (err) {
-      assert.ok(err.message.indexOf('compiling ejs') > -1);
+      ok(err.message.indexOf('compiling ejs') > -1);
 
       try {
         ejs.compile(fixture('fail.ejs'), {filename: 'fail.ejs'});
       }
       catch (err) {
-        assert.ok(err.message.indexOf('fail.ejs') > -1);
+        ok(err.message.indexOf('fail.ejs') > -1);
         return;
       }
     }
@@ -92,29 +92,29 @@ suite('ejs.compile(str, options)', function () {
   test('allow customizing delimiter local var', function () {
     var fn;
     fn = ejs.compile('<p><?= name ?></p>', {delimiter: '?'});
-    assert.equal(fn({name: 'geddy'}), '<p>geddy</p>');
+    equal(fn({name: 'geddy'}), '<p>geddy</p>');
 
     fn = ejs.compile('<p><:= name :></p>', {delimiter: ':'});
-    assert.equal(fn({name: 'geddy'}), '<p>geddy</p>');
+    equal(fn({name: 'geddy'}), '<p>geddy</p>');
 
     fn = ejs.compile('<p><$= name $></p>', {delimiter: '$'});
-    assert.equal(fn({name: 'geddy'}), '<p>geddy</p>');
+    equal(fn({name: 'geddy'}), '<p>geddy</p>');
   });
 
   test('allow customizing open and close delimiters', function() {
     var fn;
     fn = ejs.compile('<p>[#= name #]</p>', {delimiter: '#', openDelimiter: '[', closeDelimiter: ']'});
-    assert.equal(fn({name: 'geddy'}), '<p>geddy</p>');
+    equal(fn({name: 'geddy'}), '<p>geddy</p>');
   });
 
   test('default to using ejs.delimiter', function () {
     var fn;
     ejs.delimiter = '&';
     fn = ejs.compile('<p><&= name &></p>');
-    assert.equal(fn({name: 'geddy'}), '<p>geddy</p>');
+    equal(fn({name: 'geddy'}), '<p>geddy</p>');
 
     fn = ejs.compile('<p><|= name |></p>', {delimiter: '|'});
-    assert.equal(fn({name: 'geddy'}), '<p>geddy</p>');
+    equal(fn({name: 'geddy'}), '<p>geddy</p>');
     delete ejs.delimiter;
   });
 
@@ -125,17 +125,17 @@ suite('ejs.compile(str, options)', function () {
       return !str ? '' : str.toUpperCase();
     };
     fn = ejs.compile('HELLO <%= name %>', {escape: customEscape});
-    assert.equal(fn({name: 'world'}), 'HELLO WORLD');
+    equal(fn({name: 'world'}), 'HELLO WORLD');
   });
 
   test('strict mode works', function () {
-    assert.equal(ejs.render(fixture('strict.ejs'), {}, {strict: true}), 'true');
+    equal(ejs.render(fixture('strict.ejs'), {}, {strict: true}), 'true');
   });
 
   test('destructuring works in strict mode as an alternative to `with`', function () {
     var locals = Object.create(null);
     locals.foo = 'bar';
-    assert.equal(ejs.render(fixture('strict-destructuring.ejs'), locals, {
+    equal(ejs.render(fixture('strict-destructuring.ejs'), locals, {
       strict: true,
       destructuredLocals: Object.keys(locals),
       _with: true
@@ -150,7 +150,7 @@ suite('ejs.compile(str, options)', function () {
       async: true,
       destructuredLocals: Object.keys(locals),
     }).then(function (value) {
-      assert.equal(value, locals.foo);
+      equal(value, locals.foo);
     }).then(
       () => done(),
       e => done(e)
@@ -160,7 +160,7 @@ suite('ejs.compile(str, options)', function () {
   testAsync('can compile to an async function', function (done) {
     ejs.compile('<%= await "Hi" %>', {async: true})().then(function (value) {
       try {
-        assert.equal(value, 'Hi');
+        equal(value, 'Hi');
       } catch (e) {
         done(e);
         return;
@@ -176,7 +176,7 @@ suite('ejs.compile(str, options)', function () {
     }
     catch (err) {
       if (err instanceof SyntaxError) {
-        assert.ok(err.message.indexOf('async: true') > -1);
+        ok(err.message.indexOf('async: true') > -1);
         return done();
       } else {
         throw err;
@@ -192,14 +192,14 @@ suite('ejs.compile(str, options)', function () {
       filename: 'foo.ejs'
     });
 
-    assert.ok(func.name === 'foo');
+    ok(func.name === 'foo');
     return done();
   });
 
   testFuncName('Compiled function name defaults to "anonymous" when `filename` is unspecified', function (done) {
     var func = ejs.compile('<%= "Foo" %>');
 
-    assert.ok(func.name === 'anonymous');
+    ok(func.name === 'anonymous');
     return done();
   });
 });
@@ -214,7 +214,7 @@ suite('client mode', function () {
     str = fn.toString();
     if (!process.env.running_under_istanbul) {
       eval('var preFn = ' + str);
-      assert.equal(preFn({foo: 'bar'}), '<p>bar</p>');
+      equal(preFn({foo: 'bar'}), '<p>bar</p>');
     }
   });
 
@@ -226,7 +226,7 @@ suite('client mode', function () {
     str = fn.toString();
     if (!process.env.running_under_istanbul) {
       eval('var preFn = ' + str);
-      assert.equal(preFn(), '<p>foo</p>');
+      equal(preFn(), '<p>foo</p>');
     }
   });
 
@@ -250,12 +250,12 @@ suite('client mode', function () {
     str = fn.toString();
     if (!process.env.running_under_istanbul) {
       eval('var preFn = ' + str);
-      assert.equal(preFn({name: 'world'}), 'HELLO WORLD');
+      equal(preFn({name: 'world'}), 'HELLO WORLD');
     }
   });
 
   test('escape filename in errors in client mode', function () {
-    assert.throws(function () {
+    throws(function () {
       var fn = ejs.compile('<% throw new Error("whoops"); %>', {client: true, filename: '<script>'});
       fn();
     }, /Error: &lt;script&gt;/);
@@ -265,12 +265,12 @@ suite('client mode', function () {
 /* Old API -- remove when this shim goes away */
 suite('ejs.render(str, dataAndOpts)', function () {
   test('render the template with data/opts passed together', function () {
-    assert.equal(ejs.render('<p><?= foo ?></p>', {foo: 'yay', delimiter: '?'}),
+    equal(ejs.render('<p><?= foo ?></p>', {foo: 'yay', delimiter: '?'}),
       '<p>yay</p>');
   });
 
   test('disallow unsafe opts passed along in data', function () {
-    assert.equal(ejs.render('<p><?= locals.foo ?></p>',
+    equal(ejs.render('<p><?= locals.foo ?></p>',
       // localsName should not get reset because it's blacklisted
       {_with: false, foo: 'yay', delimiter: '?', localsName: '_'}),
     '<p>yay</p>');
@@ -279,47 +279,47 @@ suite('ejs.render(str, dataAndOpts)', function () {
 
 suite('ejs.render(str, data, opts)', function () {
   test('render the template', function () {
-    assert.equal(ejs.render('<p>yay</p>'), '<p>yay</p>');
+    equal(ejs.render('<p>yay</p>'), '<p>yay</p>');
   });
 
   test('empty input works', function () {
-    assert.equal(ejs.render(''), '');
+    equal(ejs.render(''), '');
   });
 
   test('undefined renders nothing escaped', function () {
-    assert.equal(ejs.render('<%= undefined %>'), '');
+    equal(ejs.render('<%= undefined %>'), '');
   });
 
   test('undefined renders nothing raw', function () {
-    assert.equal(ejs.render('<%- undefined %>'), '');
+    equal(ejs.render('<%- undefined %>'), '');
   });
 
   test('null renders nothing escaped', function () {
-    assert.equal(ejs.render('<%= null %>'), '');
+    equal(ejs.render('<%= null %>'), '');
   });
 
   test('null renders nothing raw', function () {
-    assert.equal(ejs.render('<%- null %>'), '');
+    equal(ejs.render('<%- null %>'), '');
   });
 
   test('zero-value data item renders something escaped', function () {
-    assert.equal(ejs.render('<%= 0 %>'), '0');
+    equal(ejs.render('<%= 0 %>'), '0');
   });
 
   test('zero-value data object renders something raw', function () {
-    assert.equal(ejs.render('<%- 0 %>'), '0');
+    equal(ejs.render('<%- 0 %>'), '0');
   });
 
   test('accept locals', function () {
-    assert.equal(ejs.render('<p><%= name %></p>', {name: 'geddy'}),
+    equal(ejs.render('<p><%= name %></p>', {name: 'geddy'}),
       '<p>geddy</p>');
   });
 
   test('accept locals without using with() {}', function () {
-    assert.equal(ejs.render('<p><%= locals.name %></p>', {name: 'geddy'},
+    equal(ejs.render('<p><%= locals.name %></p>', {name: 'geddy'},
       {_with: false}),
     '<p>geddy</p>');
-    assert.throws(function() {
+    throws(function() {
       ejs.render('<p><%= name %></p>', {name: 'geddy'},
         {_with: false});
     }, /name is not defined/);
@@ -327,10 +327,10 @@ suite('ejs.render(str, data, opts)', function () {
 
   test('accept custom name for locals', function () {
     ejs.localsName = 'it';
-    assert.equal(ejs.render('<p><%= it.name %></p>', {name: 'geddy'},
+    equal(ejs.render('<p><%= it.name %></p>', {name: 'geddy'},
       {_with: false}),
     '<p>geddy</p>');
-    assert.throws(function() {
+    throws(function() {
       ejs.render('<p><%= name %></p>', {name: 'geddy'},
         {_with: false});
     }, /name is not defined/);
@@ -342,10 +342,10 @@ suite('ejs.render(str, data, opts)', function () {
     var options = {cache: true, filename: file};
     var out = ejs.render('<p>Old</p>', {}, options);
     var expected = '<p>Old</p>';
-    assert.equal(out, expected);
+    equal(out, expected);
     // Assert no change, still in cache
     out = ejs.render('<p>New</p>', {}, options);
-    assert.equal(out, expected);
+    equal(out, expected);
   });
 
   test('support LRU caching', function () {
@@ -359,10 +359,10 @@ suite('ejs.render(str, data, opts)', function () {
     ejs.cache = LRU();
 
     out = ejs.render('<p>Old</p>', {}, options);
-    assert.equal(out, expected);
+    equal(out, expected);
     // Assert no change, still in cache
     out = ejs.render('<p>New</p>', {}, options);
-    assert.equal(out, expected);
+    equal(out, expected);
 
     // Restore system cache
     ejs.cache = oldCache;
@@ -371,7 +371,7 @@ suite('ejs.render(str, data, opts)', function () {
   test('opts.context', function () {
     var ctxt = {foo: 'FOO'};
     var out = ejs.render('<%= this.foo %>', {}, {context: ctxt});
-    assert.equal(out, ctxt.foo);
+    equal(out, ctxt.foo);
   });
 
 });
@@ -382,7 +382,7 @@ suite('ejs.renderFile(path, [data], [options], [fn])', function () {
       if (err) {
         return done(err);
       }
-      assert.equal(html, '<p>hey</p>'+lf);
+      equal(html, '<p>hey</p>'+lf);
       done();
     });
   });
@@ -391,13 +391,13 @@ suite('ejs.renderFile(path, [data], [options], [fn])', function () {
     var AsyncCtor;
     var func;
     function checkResult(html) {
-      assert.equal(html, '<p>hey</p>'+lf);
+      equal(html, '<p>hey</p>'+lf);
     }
     // Environments without Promise support -- should throw
     // when no callback provided
     function checkNoPromise() {
       delete ejs.promiseImpl;
-      assert.throws(function () {
+      throws(function () {
         ejs.renderFile('test/fixtures/para.ejs');
       });
       ejs.promiseImpl = global.Promise;
@@ -439,7 +439,7 @@ suite('ejs.renderFile(path, [data], [options], [fn])', function () {
       if (err) {
         return done(err);
       }
-      assert.equal(html, '<h1>fonebone</h1>'+lf);
+      equal(html, '<h1>fonebone</h1>'+lf);
       done();
     });
   });
@@ -456,7 +456,7 @@ suite('ejs.renderFile(path, [data], [options], [fn])', function () {
         doneCount = 2;
         return done(err);
       }
-      assert.equal(html, '<h1>fonebone</h1>'+lf);
+      equal(html, '<h1>fonebone</h1>'+lf);
       doneCount++;
       if (doneCount === 2) {
         done();
@@ -484,8 +484,8 @@ suite('ejs.renderFile(path, [data], [options], [fn])', function () {
 
     var d = require('domain').create();
     d.on('error', function (err) {
-      assert.equal(counter, 1);
-      assert.equal(err.message, 'Exception in callback');
+      equal(counter, 1);
+      equal(err.message, 'Exception in callback');
       done();
     });
     d.run(function () {
@@ -498,7 +498,7 @@ suite('ejs.renderFile(path, [data], [options], [fn])', function () {
         ejs.renderFile('test/fixtures/user.ejs', data, options, function(err) {
           counter++;
           if (err) {
-            assert.notEqual(err.message, 'Exception in callback');
+            notEqual(err.message, 'Exception in callback');
             return done(err);
           }
           throw new Error('Exception in callback');
@@ -511,21 +511,21 @@ suite('ejs.renderFile(path, [data], [options], [fn])', function () {
     var expected = '<p>Old</p>';
     var file = __dirname + '/tmp/renderFile.ejs';
     var options = {cache: true};
-    fs.writeFileSync(file, '<p>Old</p>');
+    writeFileSync(file, '<p>Old</p>');
 
     ejs.renderFile(file, {}, options, function (err, out) {
       if (err) {
         done(err);
       }
-      fs.writeFileSync(file, '<p>New</p>');
-      assert.equal(out, expected);
+      writeFileSync(file, '<p>New</p>');
+      equal(out, expected);
 
       ejs.renderFile(file, {}, options, function (err, out) {
         if (err) {
           done(err);
         }
         // Assert no change, still in cache
-        assert.equal(out, expected);
+        equal(out, expected);
         done();
       });
     });
@@ -537,7 +537,7 @@ suite('ejs.renderFile(path, [data], [options], [fn])', function () {
       if (err) {
         return done(err);
       }
-      assert.equal(html, ctxt.foo + lf);
+      equal(html, ctxt.foo + lf);
       done();
     });
 
@@ -549,14 +549,14 @@ suite('ejs.renderFile(path, [data], [options], [fn])', function () {
       includePath: 'views-include.ejs',
       settings: {
         views: [
-          path.join(__dirname, 'fixtures/nonexistent-folder'),
-          path.join(__dirname, 'fixtures')
+          join(__dirname, 'fixtures/nonexistent-folder'),
+          join(__dirname, 'fixtures')
         ]
       }
     };
-    ejs.renderFile(path.join(__dirname, 'fixtures/views.ejs'), data, function(error, data){
-      assert.ifError(error);
-      assert.equal('<div><p>global test</p>'+lf+'</div>'+lf, data);
+    ejs.renderFile(join(__dirname, 'fixtures/views.ejs'), data, function(error, data){
+      ifError(error);
+      equal('<div><p>global test</p>'+lf+'</div>'+lf, data);
       done();
     });
 
@@ -568,14 +568,14 @@ suite('ejs.renderFile(path, [data], [options], [fn])', function () {
       includePath: 'views/views-include.ejs',
       settings: {
         views: [
-          path.join(__dirname, 'fixtures/views'),
-          path.join(__dirname, 'fixtures')
+          join(__dirname, 'fixtures/views'),
+          join(__dirname, 'fixtures')
         ]
       }
     };
-    ejs.renderFile(path.join(__dirname, 'fixtures/views.ejs'), data, function(error, data){
-      assert.ifError(error);
-      assert.equal('<div><p>custom test</p>'+lf+'</div>'+lf, data);
+    ejs.renderFile(join(__dirname, 'fixtures/views.ejs'), data, function(error, data){
+      ifError(error);
+      equal('<div><p>custom test</p>'+lf+'</div>'+lf, data);
       done();
     });
 
@@ -589,13 +589,13 @@ suite('cache specific', function () {
     var file = __dirname + '/tmp/clearCache.ejs';
     var options = {cache: true, filename: file};
     var out = ejs.render('<p>Old</p>', {}, options);
-    assert.equal(out, expected);
+    equal(out, expected);
 
     ejs.clearCache();
 
     expected = '<p>New</p>';
     out = ejs.render('<p>New</p>', {}, options);
-    assert.equal(out, expected);
+    equal(out, expected);
   });
 
   test('`clearCache` work properly, LRU', function () {
@@ -608,11 +608,11 @@ suite('cache specific', function () {
     ejs.cache = LRU();
 
     out = ejs.render('<p>Old</p>', {}, options);
-    assert.equal(out, expected);
+    equal(out, expected);
     ejs.clearCache();
     expected = '<p>New</p>';
     out = ejs.render('<p>New</p>', {}, options);
-    assert.equal(out, expected);
+    equal(out, expected);
 
     ejs.cache = oldCache;
   });
@@ -630,7 +630,7 @@ suite('cache specific', function () {
     options = {cache: true, filename: file};
     out = ejs.render('<p>File1</p>', {}, options);
     expected = '<p>File1</p>';
-    assert.equal(out, expected);
+    equal(out, expected);
 
     // Same filename, different template, but output
     // should be the same because cache
@@ -638,7 +638,7 @@ suite('cache specific', function () {
     options = {cache: true, filename: file};
     out = ejs.render('<p>ChangedFile1</p>', {}, options);
     expected = '<p>File1</p>';
-    assert.equal(out, expected);
+    equal(out, expected);
 
     // Different filiename -- output should be different,
     // and previous cache-entry should be evicted
@@ -646,7 +646,7 @@ suite('cache specific', function () {
     options = {cache: true, filename: file};
     out = ejs.render('<p>File2</p>', {}, options);
     expected = '<p>File2</p>';
-    assert.equal(out, expected);
+    equal(out, expected);
 
     // Entry with first filename should now be out of cache,
     // results should be different
@@ -654,7 +654,7 @@ suite('cache specific', function () {
     options = {cache: true, filename: file};
     out = ejs.render('<p>ChangedFile1</p>', {}, options);
     expected = '<p>ChangedFile1</p>';
-    assert.equal(out, expected);
+    equal(out, expected);
 
     ejs.cache = oldCache;
   });
@@ -662,29 +662,29 @@ suite('cache specific', function () {
 
 suite('<%', function () {
   test('without semicolons', function () {
-    assert.equal(ejs.render(fixture('no.semicolons.ejs')),
+    equal(ejs.render(fixture('no.semicolons.ejs')),
       fixture('no.semicolons.html'));
   });
 });
 
 suite('<%=', function () {
   test('should not throw an error with a // comment on the final line', function () {
-    assert.equal(ejs.render('<%=\n// a comment\nname\n// another comment %>', {name: '&nbsp;<script>'}),
+    equal(ejs.render('<%=\n// a comment\nname\n// another comment %>', {name: '&nbsp;<script>'}),
       '&amp;nbsp;&lt;script&gt;');
   });
 
   test('escape &amp;<script>', function () {
-    assert.equal(ejs.render('<%= name %>', {name: '&nbsp;<script>'}),
+    equal(ejs.render('<%= name %>', {name: '&nbsp;<script>'}),
       '&amp;nbsp;&lt;script&gt;');
   });
 
   test('should escape \'', function () {
-    assert.equal(ejs.render('<%= name %>', {name: 'The Jones\'s'}),
+    equal(ejs.render('<%= name %>', {name: 'The Jones\'s'}),
       'The Jones&#39;s');
   });
 
   test('should escape &foo_bar;', function () {
-    assert.equal(ejs.render('<%= name %>', {name: '&foo_bar;'}),
+    equal(ejs.render('<%= name %>', {name: '&foo_bar;'}),
       '&amp;foo_bar;');
   });
 
@@ -694,7 +694,7 @@ suite('<%=', function () {
       return !str ? '' : str.toUpperCase();
     };
 
-    assert.equal(
+    equal(
       ejs.render('<%= name %>', {name: 'The Jones\'s'}, {escape: customEscape}),
       'THE JONES\'S'
     );
@@ -703,12 +703,12 @@ suite('<%=', function () {
 
 suite('<%-', function () {
   test('should not throw an error with a // comment on the final line', function () {
-    assert.equal(ejs.render('<%-\n// a comment\nname\n// another comment %>', {name: '&nbsp;<script>'}),
+    equal(ejs.render('<%-\n// a comment\nname\n// another comment %>', {name: '&nbsp;<script>'}),
       '&nbsp;<script>');
   });
 
   test('not escape', function () {
-    assert.equal(ejs.render('<%- name %>', {name: '<script>'}),
+    equal(ejs.render('<%- name %>', {name: '<script>'}),
       '<script>');
   });
 
@@ -718,29 +718,29 @@ suite('<%-', function () {
       throw new Error('Expected parse failure');
     }
     catch (err) {
-      assert.ok(err.message.indexOf('Could not find matching close tag for') > -1);
+      ok(err.message.indexOf('Could not find matching close tag for') > -1);
     }
   });
 });
 
 suite('%>', function () {
   test('produce newlines', function () {
-    assert.equal(ejs.render(fixture('newlines.ejs'), {users: users}),
+    equal(ejs.render(fixture('newlines.ejs'), {users: users}),
       fixture('newlines.html'));
   });
   test('works with `-%>` interspersed', function () {
-    assert.equal(ejs.render(fixture('newlines.mixed.ejs'), {users: users}),
+    equal(ejs.render(fixture('newlines.mixed.ejs'), {users: users}),
       fixture('newlines.mixed.html'));
   });
   test('consecutive tags work', function () {
-    assert.equal(ejs.render(fixture('consecutive-tags.ejs')),
+    equal(ejs.render(fixture('consecutive-tags.ejs')),
       fixture('consecutive-tags.html'));
   });
 });
 
 suite('-%>', function () {
   test('not produce newlines', function () {
-    assert.equal(ejs.render(fixture('no.newlines.ejs'), {users: users}),
+    equal(ejs.render(fixture('no.newlines.ejs'), {users: users}),
       fixture('no.newlines.html'));
   });
   test('stack traces work', function () {
@@ -766,7 +766,7 @@ suite('-%>', function () {
     var expectedResult = '<ul><li>geddy</li>\n<li>neil</li>\n<li>alex</li>\n</ul>';
     var fn;
     fn = ejs.compile(content);
-    assert.equal(fn({users: users}),
+    equal(fn({users: users}),
       expectedResult);
   });
 
@@ -780,63 +780,63 @@ suite('-%>', function () {
     var expectedResult = '<ul><li>geddy</li>\r\n<li>neil</li>\r\n<li>alex</li>\r\n</ul>';
     var fn;
     fn = ejs.compile(content);
-    assert.equal(fn({users: users}),
+    equal(fn({users: users}),
       expectedResult);
   });
 });
 
 suite('<%%', function () {
   test('produce literals', function () {
-    assert.equal(ejs.render('<%%- "foo" %>'),
+    equal(ejs.render('<%%- "foo" %>'),
       '<%- "foo" %>');
   });
   test('work without an end tag', function () {
-    assert.equal(ejs.render('<%%'), '<%');
-    assert.equal(ejs.render(fixture('literal.ejs'), {}, {delimiter: ' '}),
+    equal(ejs.render('<%%'), '<%');
+    equal(ejs.render(fixture('literal.ejs'), {}, {delimiter: ' '}),
       fixture('literal.html'));
   });
 });
 
 suite('%%>', function () {
   test('produce literal', function () {
-    assert.equal(ejs.render('%%>'),
+    equal(ejs.render('%%>'),
       '%>');
-    assert.equal(ejs.render('  >', {}, {delimiter: ' '}),
+    equal(ejs.render('  >', {}, {delimiter: ' '}),
       ' >');
   });
 });
 
 suite('<%_ and _%>', function () {
   test('slurps spaces and tabs', function () {
-    assert.equal(ejs.render(fixture('space-and-tab-slurp.ejs'), {users: users}),
+    equal(ejs.render(fixture('space-and-tab-slurp.ejs'), {users: users}),
       fixture('space-and-tab-slurp.html'));
   });
 });
 
 suite('single quotes', function () {
   test('not mess up the constructed function', function () {
-    assert.equal(ejs.render(fixture('single-quote.ejs')),
+    equal(ejs.render(fixture('single-quote.ejs')),
       fixture('single-quote.html'));
   });
 });
 
 suite('double quotes', function () {
   test('not mess up the constructed function', function () {
-    assert.equal(ejs.render(fixture('double-quote.ejs')),
+    equal(ejs.render(fixture('double-quote.ejs')),
       fixture('double-quote.html'));
   });
 });
 
 suite('backslashes', function () {
   test('escape', function () {
-    assert.equal(ejs.render(fixture('backslash.ejs')),
+    equal(ejs.render(fixture('backslash.ejs')),
       fixture('backslash.html'));
   });
 });
 
 suite('messed up whitespace', function () {
   test('work', function () {
-    assert.equal(ejs.render(fixture('messed.ejs'), {users: users}),
+    equal(ejs.render(fixture('messed.ejs'), {users: users}),
       fixture('messed.html'));
   });
 });
@@ -847,11 +847,11 @@ suite('exceptions', function () {
       ejs.render(fixture('error.ejs'), {}, {filename: 'error.ejs'});
     }
     catch (err) {
-      assert.equal(err.path, 'error.ejs');
+      equal(err.path, 'error.ejs');
       var errstck = err.stack.split('\n').slice(0, 8).join('\n');
       errstck = errstck.replace(/\n/g,lf);
       errstck = errstck.replace(/\r\r\n/g,lf);
-      assert.equal(errstck, fixture('error.out'));
+      equal(errstck, fixture('error.out'));
       return;
     }
     throw new Error('no error reported when there should be');
@@ -865,11 +865,11 @@ suite('exceptions', function () {
       });
     }
     catch (err) {
-      assert.ok(!err.path);
+      ok(!err.path);
       var errstck = err.stack.split('\n').slice(0, 8).join('\n');
       errstck = errstck.replace(/\n/g,lf);
       errstck = errstck.replace(/\r\r\n/g,lf);
-      assert.notEqual(errstck, fixture('error.out'));
+      notEqual(errstck, fixture('error.out'));
       return;
     }
     throw new Error('no error reported when there should be');
@@ -895,13 +895,13 @@ suite('exceptions', function () {
   });
 
   test('escape filename in errors', function () {
-    assert.throws(function () {
+    throws(function () {
       ejs.render('<% throw new Error("whoops"); %>', {}, {filename: '<script>'});
     }, /Error: &lt;script&gt;/);
   });
 
   test('filename in errors uses custom escape', function () {
-    assert.throws(function () {
+    throws(function () {
       ejs.render('<% throw new Error("whoops"); %>', {}, {
         filename: '<script>',
         escape: function () { return 'zooby'; }
@@ -921,20 +921,20 @@ suite('exceptions', function () {
 suite('rmWhitespace', function () {
   test('works', function () {
     var outp = ejs.render(fixture('rmWhitespace.ejs'), {}, {rmWhitespace: true});
-    assert.equal(outp.replace(/\n/g,lf), fixture('rmWhitespace.html'));
+    equal(outp.replace(/\n/g,lf), fixture('rmWhitespace.html'));
   });
 });
 
 suite('include()', function () {
   test('include ejs', function () {
     var file = 'test/fixtures/include-simple.ejs';
-    assert.equal(ejs.render(fixture('include-simple.ejs'), {}, {filename: file}),
+    equal(ejs.render(fixture('include-simple.ejs'), {}, {filename: file}),
       fixture('include-simple.html'));
   });
 
   test('include and escape ejs', function () {
     var file = 'test/fixtures/include-escaped.ejs';
-    assert.equal(ejs.render(fixture('include-escaped.ejs'), {}, {filename: file}),
+    equal(ejs.render(fixture('include-escaped.ejs'), {}, {filename: file}),
       fixture('include-escaped.html'));
   });
 
@@ -944,13 +944,13 @@ suite('include()', function () {
     };
 
     var file = 'test/fixtures/include-nested-escape.ejs';
-    assert.equal(ejs.render(fixture('include-nested-escape.ejs'), {}, {filename: file, escape: escape}),
+    equal(ejs.render(fixture('include-nested-escape.ejs'), {}, {filename: file, escape: escape}),
       fixture('include-nested-escape.html'));
   });
 
   test('include in expression ejs', function () {
     var file = 'test/fixtures/include-expression.ejs';
-    assert.equal(ejs.render(fixture('include-expression.ejs'), {}, {filename: file}),
+    equal(ejs.render(fixture('include-expression.ejs'), {}, {filename: file}),
       fixture('include-expression.html'));
   });
 
@@ -959,7 +959,7 @@ suite('include()', function () {
       ejs.render(fixture('include-simple.ejs'));
     }
     catch (err) {
-      assert.ok(err.message.indexOf('Could not find') > -1);
+      ok(err.message.indexOf('Could not find') > -1);
       return;
     }
     throw new Error('expected inclusion error');
@@ -970,37 +970,37 @@ suite('include()', function () {
       ejs.render(fixture('include-nonexistent.ejs'));
     }
     catch (err) {
-      assert.ok(err.message.indexOf('nonexistent-file') > -1);
+      ok(err.message.indexOf('nonexistent-file') > -1);
       return;
     }
     throw new Error('expected inclusion error containing file name');
   });
 
   test('strips BOM', function () {
-    assert.equal(
+    equal(
       ejs.render('<%- include("fixtures/includes/bom.ejs") %>',
-        {}, {filename: path.join(__dirname, 'f.ejs')}),
+        {}, {filename: join(__dirname, 'f.ejs')}),
       '<p>This is a file with BOM.</p>'+lf);
   });
 
   test('include ejs with locals', function () {
     var file = 'test/fixtures/include.ejs';
-    assert.equal(ejs.render(fixture('include.ejs'), {pets: users}, {filename: file, delimiter: '@'}),
+    equal(ejs.render(fixture('include.ejs'), {pets: users}, {filename: file, delimiter: '@'}),
       fixture('include.html'));
   });
 
   test('include ejs with absolute path and locals', function () {
     var file = 'test/fixtures/include-abspath.ejs';
-    assert.equal(ejs.render(fixture('include-abspath.ejs'),
-      {dir: path.join(__dirname, 'fixtures'), pets: users, path: path},
+    equal(ejs.render(fixture('include-abspath.ejs'),
+      {dir: join(__dirname, 'fixtures'), pets: users, path: path},
       {filename: file, delimiter: '@'}),
     fixture('include.html'));
   });
 
   test('include ejs with set root path', function () {
     var file = 'test/fixtures/include-root.ejs';
-    var viewsPath = path.join(__dirname, 'fixtures');
-    assert.equal(ejs.render(fixture('include-root.ejs'), {pets: users}, {filename: file, delimiter: '@',root:viewsPath}),
+    var viewsPath = join(__dirname, 'fixtures');
+    equal(ejs.render(fixture('include-root.ejs'), {pets: users}, {filename: file, delimiter: '@',root:viewsPath}),
       fixture('include.html'));
   });
 
@@ -1011,13 +1011,13 @@ suite('include()', function () {
         // original: '/include'         (windows)
         // prev:     'D:\include.ejs'   (windows)
         return {
-          filename: path.join(__dirname, 'fixtures', original+'.ejs')
+          filename: join(__dirname, 'fixtures', original+'.ejs')
         };
       } else {
         return prev;
       }
     };
-    assert.equal(ejs.render(fixture('include-root.ejs'), {pets: users}, {filename: file, delimiter: '@', includer: inc}),
+    equal(ejs.render(fixture('include-root.ejs'), {pets: users}, {filename: file, delimiter: '@', includer: inc}),
       fixture('include.html'));
   });
 
@@ -1034,26 +1034,26 @@ suite('include()', function () {
         return prev;
       }
     };
-    assert.equal(ejs.render(fixture('include-root.ejs'), {pets: users}, {filename: file, delimiter: '@', includer: inc}),
+    equal(ejs.render(fixture('include-root.ejs'), {pets: users}, {filename: file, delimiter: '@', includer: inc}),
       fixture('hello-template.html'));
   });
 
   test('work when nested', function () {
     var file = 'test/fixtures/menu.ejs';
-    assert.equal(ejs.render(fixture('menu.ejs'), {pets: users}, {filename: file}),
+    equal(ejs.render(fixture('menu.ejs'), {pets: users}, {filename: file}),
       fixture('menu.html'));
   });
 
   test('work with a variable path', function () {
     var file = 'test/fixtures/menu_var.ejs';
     var includePath = 'includes/menu-item';
-    assert.equal(ejs.render(fixture('menu.ejs'), {pets: users, varPath:  includePath}, {filename: file}),
+    equal(ejs.render(fixture('menu.ejs'), {pets: users, varPath:  includePath}, {filename: file}),
       fixture('menu.html'));
   });
 
   test('include arbitrary files as-is', function () {
     var file = 'test/fixtures/include.css.ejs';
-    assert.equal(ejs.render(fixture('include.css.ejs'), {pets: users}, {filename: file}),
+    equal(ejs.render(fixture('include.css.ejs'), {pets: users}, {filename: file}),
       fixture('include.css.html'));
   });
 
@@ -1070,45 +1070,45 @@ suite('include()', function () {
       fn({foo: 'asdf'});
     }
     catch(e) {
-      assert.equal(e.message, 'pets is not defined');
-      assert.ok(!e.path);
+      equal(e.message, 'pets is not defined');
+      ok(!e.path);
       return;
     }
     throw new Error('no error reported when there should be');
   });
 
   test('is dynamic', function () {
-    fs.writeFileSync(__dirname + '/tmp/include.ejs', '<p>Old</p>');
+    writeFileSync(__dirname + '/tmp/include.ejs', '<p>Old</p>');
     var file = 'test/fixtures/include_cache.ejs';
     var options = {filename: file};
     var out = ejs.compile(fixture('include_cache.ejs'), options);
-    assert.equal(out(), '<p>Old</p>'+lf);
+    equal(out(), '<p>Old</p>'+lf);
 
-    fs.writeFileSync(__dirname + '/tmp/include.ejs', '<p>New</p>');
-    assert.equal(out(), '<p>New</p>'+lf);
+    writeFileSync(__dirname + '/tmp/include.ejs', '<p>New</p>');
+    equal(out(), '<p>New</p>'+lf);
   });
 
   test('support caching', function () {
-    fs.writeFileSync(__dirname + '/tmp/include.ejs', '<p>Old</p>');
+    writeFileSync(__dirname + '/tmp/include.ejs', '<p>Old</p>');
     var file = 'test/fixtures/include_cache.ejs';
     var options = {cache: true, filename: file};
     var out = ejs.render(fixture('include_cache.ejs'), {}, options);
     var expected = fixture('include_cache.html');
-    assert.equal(out, expected);
+    equal(out, expected);
     out = ejs.render(fixture('include_cache.ejs'), {}, options);
     // No change, still in cache
-    assert.equal(out, expected);
-    fs.writeFileSync(__dirname + '/tmp/include.ejs', '<p>New</p>');
+    equal(out, expected);
+    writeFileSync(__dirname + '/tmp/include.ejs', '<p>New</p>');
     out = ejs.render(fixture('include_cache.ejs'), {}, options);
-    assert.equal(out, expected);
+    equal(out, expected);
   });
 
   test('handles errors in included file', function() {
     try {
-      ejs.render('<%- include("fixtures/include-with-error") %>', {}, {filename: path.join(__dirname, 'f.ejs')});
+      ejs.render('<%- include("fixtures/include-with-error") %>', {}, {filename: join(__dirname, 'f.ejs')});
     }
     catch (err) {
-      assert.ok(err.message.indexOf('foobar is not defined') > -1);
+      ok(err.message.indexOf('foobar is not defined') > -1);
       return;
     }
     throw new Error('expected inclusion error');
@@ -1118,7 +1118,7 @@ suite('include()', function () {
 
 suite('comments', function () {
   test('fully render with comments removed', function () {
-    assert.equal(ejs.render(fixture('comments.ejs')),
+    equal(ejs.render(fixture('comments.ejs')),
       fixture('comments.html'));
   });
 });
@@ -1126,7 +1126,7 @@ suite('comments', function () {
 suite('test fileloader', function () {
 
   var myFileLoad = function (filePath) {
-    return 'myFileLoad: ' + fs.readFileSync(filePath);
+    return 'myFileLoad: ' + readFileSync(filePath);
   };
 
   test('test custom fileload', function (done) {
@@ -1135,7 +1135,7 @@ suite('test fileloader', function () {
       if (err) {
         return done(err);
       }
-      assert.equal(html, 'myFileLoad: <p>hey</p>'+lf);
+      equal(html, 'myFileLoad: <p>hey</p>'+lf);
       done();
     });
 
@@ -1144,7 +1144,7 @@ suite('test fileloader', function () {
 
 suite('examples', function () {
   function noop () {}
-  fs.readdirSync('examples').forEach(function (f) {
+  readdirSync('examples').forEach(function (f) {
     if (!/\.js$/.test(f)) {
       return;
     }
@@ -1169,7 +1169,7 @@ suite('examples', function () {
 
 suite('identifier validation', function () {
   test('invalid outputFunctionName', function() {
-    assert.throws(function() {
+    throws(function() {
       ejs.compile('<p>yay</p>', {outputFunctionName: 'x;console.log(1);x'});
     }, /outputFunctionName is not a valid JS identifier/);
   });
@@ -1177,7 +1177,7 @@ suite('identifier validation', function () {
   test('invalid localsName', function() {
     var locals = Object.create(null);
     void(locals); // For linting;
-    assert.throws(function() {
+    throws(function() {
       ejs.compile('<p>yay</p>', {
         localsName: 'function(){console.log(1);return locals;}()'});
     }, /localsName is not a valid JS identifier/);
@@ -1186,7 +1186,7 @@ suite('identifier validation', function () {
   test('invalid destructuredLocals', function() {
     var locals = {};
     void(locals); // For linting;
-    assert.throws(function() {
+    throws(function() {
       ejs.compile('<p>yay</p>', {
         destructuredLocals: [
           'console.log(1); //'
diff --git a/test/utils.js b/test/utils.js
index 03d3b6db..f0aec79b 100644
--- a/test/utils.js
+++ b/test/utils.js
@@ -4,33 +4,33 @@
  * Module dependencies.
  */
 
-var assert = require('assert');
-var utils = require('../lib/cjs/utils');
+import { throws, doesNotThrow, ok } from 'assert';
+import utils from '../lib/esm/utils';
 
 /**
  *  Make sure utils exports all it is expected to export...
  */
 suite('unit testing for completeness of module \'utils.js\' exports', function () {
   test('expect \'escapeRegExpChars\' to be exported', function () {
-    assert.ok(typeof(utils.escapeRegExpChars)==='function');
+    ok(typeof(utils.escapeRegExpChars)==='function');
   });
   test('expect \'escapeXML\' to be exported', function () {
-    assert.ok(typeof(utils.escapeXML)==='function');
+    ok(typeof(utils.escapeXML)==='function');
   });
   test('expect \'escapeXML.toString\' to be exported', function () {
-    assert.ok(typeof(utils.escapeXML.toString)==='function');
+    ok(typeof(utils.escapeXML.toString)==='function');
   });
   test('expect \'shallowCopy\' to be exported', function () {
-    assert.ok(typeof(utils.shallowCopy)==='function');
+    ok(typeof(utils.shallowCopy)==='function');
   });
   test('expect \'shallowCopyFromList\' to be exported', function () {
-    assert.ok(typeof(utils.shallowCopyFromList)==='function');
+    ok(typeof(utils.shallowCopyFromList)==='function');
   });
   test('expect \'cache\' to be exported', function () {
-    assert.ok(typeof(utils.cache)==='object');
+    ok(typeof(utils.cache)==='object');
   });
   test('expect \'hyphenToCamel\' to be exported', function () {
-    assert.ok(typeof(utils.hyphenToCamel)==='function');
+    ok(typeof(utils.hyphenToCamel)==='function');
   });
 });
 
@@ -43,17 +43,17 @@ suite('unit testing exported functions of module \'utils.js\'', function () {
    */
   suite('unit testing function \'escapeRegExpChars\' of module \'utils.js\'', function () {
     test('it should be callable without parameters', function () {
-      assert.doesNotThrow(() => { utils.escapeRegExpChars(); });
-      assert.ok(utils.escapeRegExpChars()==='');
+      doesNotThrow(() => { utils.escapeRegExpChars(); });
+      ok(utils.escapeRegExpChars()==='');
     });
     test('it should be callable with parameter \'string\' {null}', function () {
-      assert.doesNotThrow(() => { utils.escapeRegExpChars(null); });
-      assert.ok(utils.escapeRegExpChars(null)==='');
+      doesNotThrow(() => { utils.escapeRegExpChars(null); });
+      ok(utils.escapeRegExpChars(null)==='');
     });
     test('it should be callable with parameter \'string\' {string}', function () {
       const str = 'fun()';
-      assert.doesNotThrow(() => { utils.escapeRegExpChars(str); });
-      assert.ok(utils.escapeRegExpChars(str)==='fun\\(\\)');
+      doesNotThrow(() => { utils.escapeRegExpChars(str); });
+      ok(utils.escapeRegExpChars(str)==='fun\\(\\)');
     });
   });
 
@@ -62,18 +62,18 @@ suite('unit testing exported functions of module \'utils.js\'', function () {
    */
   suite('unit testing function \'escapeXML\' of module \'utils.js\'', function () {
     test('it should be callable without parameters', function () {
-      assert.doesNotThrow(() => { utils.escapeXML(); });
-      assert.ok(utils.escapeXML()==='');
+      doesNotThrow(() => { utils.escapeXML(); });
+      ok(utils.escapeXML()==='');
     });
     test('it should be callable with parameter \'markup\' {null}', function () {
-      assert.doesNotThrow(() => { utils.escapeXML(null); });
-      assert.ok(utils.escapeXML(null)==='');
+      doesNotThrow(() => { utils.escapeXML(null); });
+      ok(utils.escapeXML(null)==='');
     });
     test('it should be callable with parameter \'markup\' {string}', function () {
       const markup  = '<a href="http://fun.org">fun.org</a>';
       const escaped = '&lt;a href=&#34;http://fun.org&#34;&gt;fun.org&lt;/a&gt;';
-      assert.doesNotThrow(() => { utils.escapeXML(markup); });
-      assert.ok(utils.escapeXML(markup)===escaped);
+      doesNotThrow(() => { utils.escapeXML(markup); });
+      ok(utils.escapeXML(markup)===escaped);
     });
   });
 
@@ -82,34 +82,34 @@ suite('unit testing exported functions of module \'utils.js\'', function () {
    */
   suite('unit testing function \'shallowCopy\' of module \'utils.js\'', function () {
     test('it should be callable without parameters', function () {
-      assert.doesNotThrow(() => { utils.shallowCopy(); });
-      assert.ok(utils.shallowCopy()===undefined);
+      doesNotThrow(() => { utils.shallowCopy(); });
+      ok(utils.shallowCopy()===undefined);
     });
     test('should be callable with parameters \'to\' {undefined} and \'from\' {null}', function () {
-      assert.doesNotThrow(() => { utils.shallowCopy(undefined, null); });
-      assert.ok(utils.shallowCopy(undefined, null)===undefined);
+      doesNotThrow(() => { utils.shallowCopy(undefined, null); });
+      ok(utils.shallowCopy(undefined, null)===undefined);
     });
     test('should be callable with parameters \'to\' {null} and \'from\' {null}', function () {
-      assert.doesNotThrow(() => { utils.shallowCopy(null, null); });
-      assert.ok(utils.shallowCopy(null, null)===null);
+      doesNotThrow(() => { utils.shallowCopy(null, null); });
+      ok(utils.shallowCopy(null, null)===null);
     });
     test('should be callable with parameters \'to\' {undefined} and \'from\' {...}', function () {
       const to = undefined;
       const from = { 'foo': 'bar', 'baz': [ '1', '2' ], 'bah': { 'hurz': 'gnarf' }};
-      assert.doesNotThrow(() => { utils.shallowCopy(to, from); });
-      assert.ok(utils.shallowCopy(to, from)===undefined);
+      doesNotThrow(() => { utils.shallowCopy(to, from); });
+      ok(utils.shallowCopy(to, from)===undefined);
     });
     test('should be callable with parameters \'to\' {undefined} and \'from\' {...}', function () {
       const to = null;
       const from = { 'foo': 'bar', 'baz': [ '1', '2' ], 'bah': { 'hurz': 'gnarf' }};
-      assert.doesNotThrow(() => { utils.shallowCopy(to, from); });
-      assert.ok(utils.shallowCopy(to, from)===null);
+      doesNotThrow(() => { utils.shallowCopy(to, from); });
+      ok(utils.shallowCopy(to, from)===null);
     });
     test('should be callable with parameters \'to\' { } and \'from\' {...}', function () {
       const to = {};
       const from = { 'foo': 'bar', 'baz': [ '1', '2' ], 'bah': { 'hurz': 'gnarf' }};
-      assert.doesNotThrow(() => { utils.shallowCopy(to, from); });
-      assert.ok(JSON.stringify(utils.shallowCopy(to, from))===JSON.stringify(from));
+      doesNotThrow(() => { utils.shallowCopy(to, from); });
+      ok(JSON.stringify(utils.shallowCopy(to, from))===JSON.stringify(from));
     });
   });
 
@@ -118,41 +118,41 @@ suite('unit testing exported functions of module \'utils.js\'', function () {
    */
   suite('unit testing function \'shallowCopyFromList\' of module \'utils.js\'', function () {
     test('it should be callable without parameters', function () {
-      assert.doesNotThrow(() => { utils.shallowCopyFromList(); });
-      assert.ok(utils.shallowCopyFromList()===undefined);
+      doesNotThrow(() => { utils.shallowCopyFromList(); });
+      ok(utils.shallowCopyFromList()===undefined);
     });
     test('it should be callable parameters \'to\' {undefined} and \'from\' {null}', function () {
-      assert.doesNotThrow(() => { utils.shallowCopyFromList(undefined, null); });
-      assert.ok(utils.shallowCopyFromList(undefined, null)===undefined);
+      doesNotThrow(() => { utils.shallowCopyFromList(undefined, null); });
+      ok(utils.shallowCopyFromList(undefined, null)===undefined);
     });
     test('it should be callable parameters \'to\' {undefined}, \'from\' {null} and \'list\' {null}', function () {
-      assert.doesNotThrow(() => { utils.shallowCopyFromList(undefined, null, null); });
-      assert.ok(utils.shallowCopyFromList(undefined, null, null)===undefined);
+      doesNotThrow(() => { utils.shallowCopyFromList(undefined, null, null); });
+      ok(utils.shallowCopyFromList(undefined, null, null)===undefined);
     });
     test('it should be callable parameters \'to\' {undefined}, \'from\' {null} and \'list\' {Array}', function () {
       const list = [ 'foo', 'bar' ];
-      assert.doesNotThrow(() => { utils.shallowCopyFromList(undefined, null, list); });
-      assert.ok(utils.shallowCopyFromList(undefined, null, list)===undefined);
+      doesNotThrow(() => { utils.shallowCopyFromList(undefined, null, list); });
+      ok(utils.shallowCopyFromList(undefined, null, list)===undefined);
     });
     test('it should be callable parameters \'to\' {null} and \'from\' {null}', function () {
-      assert.doesNotThrow(() => { utils.shallowCopyFromList(null, null); });
-      assert.ok(utils.shallowCopyFromList(null, null)===null);
+      doesNotThrow(() => { utils.shallowCopyFromList(null, null); });
+      ok(utils.shallowCopyFromList(null, null)===null);
     });
     test('it should be callable parameters \'to\' {undefined}, \'from\' {null} and \'list\' {null}', function () {
-      assert.doesNotThrow(() => { utils.shallowCopyFromList(null, null, null); });
-      assert.ok(utils.shallowCopyFromList(null, null, null)===null);
+      doesNotThrow(() => { utils.shallowCopyFromList(null, null, null); });
+      ok(utils.shallowCopyFromList(null, null, null)===null);
     });
     test('it should be callable parameters \'to\' {null}, \'from\' {null} and \'list\' {Array}', function () {
       const list = [ 'foo', 'bar' ];
-      assert.doesNotThrow(() => { utils.shallowCopyFromList(null, null, list); });
-      assert.ok(utils.shallowCopyFromList(null, null, list)===null);
+      doesNotThrow(() => { utils.shallowCopyFromList(null, null, list); });
+      ok(utils.shallowCopyFromList(null, null, list)===null);
     });
     test('it should be callable parameters \'to\' { }, \'from\' {...} and \'list\' {Array}', function () {
       const list = [ 'foo', 'bar' ];
       const to = {};
       const from = { 'foo': 'bar', 'baz': [ '1', '2' ], 'bah': { 'hurz': 'gnarf' }};
-      assert.doesNotThrow(() => { utils.shallowCopyFromList(to, from, list); });
-      assert.ok(JSON.stringify(utils.shallowCopyFromList(to, from, list))===JSON.stringify({ 'foo': 'bar' }));
+      doesNotThrow(() => { utils.shallowCopyFromList(to, from, list); });
+      ok(JSON.stringify(utils.shallowCopyFromList(to, from, list))===JSON.stringify({ 'foo': 'bar' }));
     });
   });
 
@@ -162,56 +162,56 @@ suite('unit testing exported functions of module \'utils.js\'', function () {
   suite('unit testing object \'cache\' of module \'utils.js\'', function () {
     suite('unit testing function \'set\' of object \'cache\'', function () {
       test('it should be callable without parameters', function () {
-        assert.doesNotThrow(() => { utils.cache.set(); });
-        assert.doesNotThrow(() => { utils.cache.set(undefined, null); });
-        assert.doesNotThrow(() => { utils.cache.set(null, undefined); });
-        assert.doesNotThrow(() => { utils.cache.set(null, null); });
+        doesNotThrow(() => { utils.cache.set(); });
+        doesNotThrow(() => { utils.cache.set(undefined, null); });
+        doesNotThrow(() => { utils.cache.set(null, undefined); });
+        doesNotThrow(() => { utils.cache.set(null, null); });
       });
       test('it should be callable without parameter \'key\' {string}', function () {
-        assert.doesNotThrow(() => { utils.cache.set('key', null); });
-        assert.doesNotThrow(() => { utils.cache.set('key', undefined); });
-        assert.doesNotThrow(() => { utils.cache.set('key', { 'foo': 'bar' }); });
+        doesNotThrow(() => { utils.cache.set('key', null); });
+        doesNotThrow(() => { utils.cache.set('key', undefined); });
+        doesNotThrow(() => { utils.cache.set('key', { 'foo': 'bar' }); });
       });
     });
     suite('unit testing function \'get\' of object \'cache\'', function () {
       test('it should be callable without parameters', function () {
-        assert.doesNotThrow(() => { utils.cache.get(); });
+        doesNotThrow(() => { utils.cache.get(); });
         // note this depends on setting key {undefined} to {null} - s.a.
-        assert.ok(utils.cache.get()===null);
+        ok(utils.cache.get()===null);
       });
       test('it should be callable parameter \'key\' {undefined}', function () {
-        assert.doesNotThrow(() => { utils.cache.get(); });
+        doesNotThrow(() => { utils.cache.get(); });
         // note this depends on setting key {undefined} to {null} - s.a.
-        assert.ok(utils.cache.get()===null);
+        ok(utils.cache.get()===null);
       });
       test('it should be callable parameter \'key\' {null}', function () {
-        assert.doesNotThrow(() => { utils.cache.get(null); });
+        doesNotThrow(() => { utils.cache.get(null); });
         // note this depends on setting key {null} to {null} - s.a.
-        assert.ok(utils.cache.get(null)===null);
+        ok(utils.cache.get(null)===null);
       });
       test('it should be callable parameter \'key\' {string}', function () {
-        assert.doesNotThrow(() => { utils.cache.get('key'); });
+        doesNotThrow(() => { utils.cache.get('key'); });
         // note this depends on setting key {string} to {...} - s.a.
-        assert.ok(JSON.stringify(utils.cache.get('key'))===JSON.stringify({ 'foo': 'bar' }));
+        ok(JSON.stringify(utils.cache.get('key'))===JSON.stringify({ 'foo': 'bar' }));
       });
     });
     suite('unit testing function \'remove\' of object \'cache\'', function () {
       test('it should be callable without parameters', function () {
-        assert.doesNotThrow(() => { utils.cache.remove(); });
-        assert.ok(utils.cache.get()===undefined);
+        doesNotThrow(() => { utils.cache.remove(); });
+        ok(utils.cache.get()===undefined);
       });
       test('it should be callable with parameter \'key\' {null}', function () {
-        assert.doesNotThrow(() => { utils.cache.remove(null); });
-        assert.ok(utils.cache.get(null)===undefined);
+        doesNotThrow(() => { utils.cache.remove(null); });
+        ok(utils.cache.get(null)===undefined);
       });
       test('it should be callable with parameter \'key\' {string}', function () {
-        assert.doesNotThrow(() => { utils.cache.remove('key'); });
-        assert.ok(utils.cache.get('key')===undefined);
+        doesNotThrow(() => { utils.cache.remove('key'); });
+        ok(utils.cache.get('key')===undefined);
       });
     });
     suite('unit testing function \'reset\' of object \'cache\'', function () {
       test('it should be callable without parameters', function () {
-        assert.doesNotThrow(() => { utils.cache.reset(); });
+        doesNotThrow(() => { utils.cache.reset(); });
       });
     });
   });
@@ -222,18 +222,18 @@ suite('unit testing exported functions of module \'utils.js\'', function () {
   suite('unit testing function \'hyphenToCamel\' of module \'utils.js\'', function () {
     test.skip('it should be callable without parameters', function () {
       const message = 'Cannot read property \'replace\' of undefined';
-      assert.throws(() => { utils.hyphenToCamel(); }, { name: 'TypeError', message });
+      throws(() => { utils.hyphenToCamel(); }, { name: 'TypeError', message });
     });
     test('it should be callable with parameter \'str\' {string}', function () {
       const str = 'some string';
       const strCamel = str;
-      assert.doesNotThrow(() => { utils.hyphenToCamel(str); });
-      assert.ok(utils.hyphenToCamel(str)===strCamel);
+      doesNotThrow(() => { utils.hyphenToCamel(str); });
+      ok(utils.hyphenToCamel(str)===strCamel);
 
       const other = 'some-string';
       const otherCamel = 'someString';
-      assert.doesNotThrow(() => { utils.hyphenToCamel(other); });
-      assert.ok(utils.hyphenToCamel(other)===otherCamel);
+      doesNotThrow(() => { utils.hyphenToCamel(other); });
+      ok(utils.hyphenToCamel(other)===otherCamel);
     });
   });