diff --git a/node-require.js b/node-require.js
index c3e985cfa..c99edb01c 100644
--- a/node-require.js
+++ b/node-require.js
@@ -19,7 +19,13 @@ const path = require('path');
 const resolveFrom = require('resolve-from');
 const fs = require('fs');
 const fsReadOptions = { encoding: 'utf8' };
-const consolidateExtensions = require('./util/consolidateExtensions');
+
+function normalizeExtension(extension) {
+    if (extension.charAt(0) !== '.') {
+        extension = '.' + extension;
+    }
+    return extension;
+}
 
 function compile(templatePath, markoCompiler, compilerOptions) {
 
@@ -81,8 +87,10 @@ function getLoadedTemplate(path) {
 function install(options) {
     options = options || {};
 
-    let extension = options.extension;
-    let extensions = options.extensions;
+    var requireExtensions = options.require ? // options.require introduced for testing
+        options.require.extensions :
+        require.extensions;
+
     var compilerOptions = options.compilerOptions;
 
     if (compilerOptions) {
@@ -91,7 +99,21 @@ function install(options) {
         compilerOptions = {};
     }
 
-    function markoExtension(module, filename) {
+    var extensions = [];
+
+    if (options.extension) {
+        extensions.push(options.extension);
+    }
+
+    if (options.extensions) {
+        extensions = extensions.concat(options.extensions);
+    }
+
+    if (extensions.length === 0) {
+        extensions.push('.marko');
+    }
+
+    function markoRequireExtension(module, filename) {
         var targetFile = filename + '.js';
         var cachedTemplate = getLoadedTemplate(targetFile) || getLoadedTemplate(filename);
         if (cachedTemplate) {
@@ -115,7 +137,13 @@ function install(options) {
         module._compile(compiledSrc, targetFile);
     }
 
-    consolidateExtensions(extension, extensions, require, markoExtension);
+    extensions.forEach((extension) => {
+        extension = normalizeExtension(extension);
+
+        if (!requireExtensions[extension]) {
+            requireExtensions[extension] = markoRequireExtension;
+        }
+    });
 }
 
 install();
diff --git a/test/node-require-test.js b/test/node-require-test.js
index d969326fe..c0d3d3759 100644
--- a/test/node-require-test.js
+++ b/test/node-require-test.js
@@ -4,99 +4,72 @@ const chai = require('chai');
 chai.Assertion.includeStack = true;
 require('chai').should();
 const expect = require('chai').expect;
-const consolidateExtensions = require('../util/consolidateExtensions');
 
-function testConsolidated(options) {
-    let extension = options.extension;
-    let extensions = options.extensions;
-    let markoExtensionFn = options.markoExtensionFn;
-    let expected = options.expected;
+var nodeRequire = require('../node-require');
 
+function testNodeRequireInstall(options, expected) {
     let requireObj = {
         extensions: {}
     };
 
-    consolidateExtensions(extension, extensions, requireObj, markoExtensionFn);
-    expect(requireObj.extensions).to.deep.equal(expected);
+    options.require = requireObj;
+
+    nodeRequire.install(options);
+
+    for (let i=0; i<expected.length; i++) {
+        let ext = expected[i];
+        expect(requireObj.extensions[ext]).to.be.a('function');
+    }
+
+    expected.sort();
+
+    var actualKeys = Object.keys(requireObj.extensions).sort();
+    expect(expected).to.deep.equal(actualKeys);
 }
 
 describe('node-require' , function() {
 
     it('should consolidate using both extension and extensions', function() {
-        let markoExtensionFn = () => {};
-
-        testConsolidated({
-            extension: '.marko.xml',
-            extensions: ['.marko', '.html'],
-            markoExtensionFn,
-            expected: {
-                '.marko.xml': markoExtensionFn,
-                '.marko': markoExtensionFn,
-                '.html': markoExtensionFn,
-            }
-        });
+        testNodeRequireInstall({
+                extension: '.marko.xml',
+                extensions: ['.marko', '.html']
+            },
+            ['.marko.xml', '.marko', '.html']);
     });
 
     it('should consolidate using only extensions', function() {
-        let markoExtensionFn = () => {};
-
-        testConsolidated({
-            extensions: ['.marko', '.html'],
-            markoExtensionFn,
-            expected: {
-                '.marko': markoExtensionFn,
-                '.html': markoExtensionFn,
-            }
-        });
+        testNodeRequireInstall({
+                extensions: ['.marko', '.html']
+            },
+            ['.marko', '.html']);
     });
 
     it('should consolidate using only extension', function() {
-        let markoExtensionFn = () => {};
-
-        testConsolidated({
-            extension: '.marko.xml',
-            markoExtensionFn,
-            expected: {
-                '.marko.xml': markoExtensionFn
-            }
-        });
+        testNodeRequireInstall({
+                extension: '.marko.xml'
+            },
+            ['.marko.xml']);
     });
 
     it('should consolidate using extension and empty array of extensions', function() {
-        let markoExtensionFn = () => {};
-
-        testConsolidated({
-            extension: '.marko.xml',
-            extensions: [],
-            markoExtensionFn,
-            expected: {
-                '.marko.xml': markoExtensionFn
-            }
-        });
+        testNodeRequireInstall({
+                extension: '.marko.xml',
+                extensions: []
+            },
+            ['.marko.xml']);
     });
 
     it('should consolidate with .marko when neither extension or extensions provided', function() {
-        let markoExtensionFn = () => {};
-
-        testConsolidated({
-            markoExtensionFn,
-            expected: {
-                '.marko': markoExtensionFn
-            }
-        });
+        testNodeRequireInstall({
+            },
+            ['.marko']);
     });
 
     it('should insert missing period into extensions', function() {
-        let markoExtensionFn = () => {};
-
-        testConsolidated({
-            extension: 'marko.xml',
-            extensions: ['html'],
-            markoExtensionFn,
-            expected: {
-                '.marko.xml': markoExtensionFn,
-                '.html': markoExtensionFn
-            }
-        });
+        testNodeRequireInstall({
+                extension: 'marko.xml',
+                extensions: ['html']
+            },
+            ['.marko.xml', '.html']);
     });
 });
diff --git a/util/consolidateExtensions.js b/util/consolidateExtensions.js
deleted file mode 100644
index b46c6fdb2..000000000
--- a/util/consolidateExtensions.js
+++ /dev/null
@@ -1,30 +0,0 @@
-function applyPeriodToExtension(extension) {
-    if (extension.charAt(0) !== '.') {
-        extension = '.' + extension;
-    }
-    return extension;
-}
-
-/**
- * Consolidate extension and extensions properties provided to node-require
- *
- * @param  {String} extension - Single extension
- * @param  {String[]} extensions - Array of extensions
- * @param  {Object} requireObj - Node.js require
- * @param  {Function} extensionFn - Function to set the function extension to
- */
-module.exports = function(extension, extensions, requireObj, extensionFn) {
-    if ((extension || (!extensions || !extensions.length)) && !requireObj.extensions[extension]) {
-        extension = (extension && applyPeriodToExtension(extension)) || '.marko';
-        requireObj.extensions[extension] = extensionFn;
-    }
-
-    if (extensions && extensions.length) {
-        extensions.forEach((extension) => {
-            extension = applyPeriodToExtension(extension);
-            if (!requireObj.extensions[extension]) {
-                requireObj.extensions[extension] = extensionFn;
-            }
-        });
-    }
-};