js-confuser 1.7.2 → 1.7.3

package/.github/workflows/node.js.yml

@@ -15,7 +15,7 @@ jobs:
 
     strategy:
       matrix:
-        node-version: [14.15, 16.10, 18.0]
+        node-version: [14.15, 16.10, 18.0, 20.16]
         # See supported Node.js release schedule at https://nodejs.org/en/about/releases/
 
     steps:

package/CHANGELOG.md

@@ -1,3 +1,38 @@
+# `1.7.3`
+Tamper Protection
+
+### `Tamper Protection`
+
+Tamper Protection safeguards the runtime behavior from being altered by JavaScript pitfalls. 
+
+[Learn more here.](/docs/TamperProtection.md)
+
+---
+
+- Rename Variables improvements:
+
+- A new exposed function, `__JS_CONFUSER_VAR__`, can be used to access renamed variables. [Learn more here](/docs/RenameVariables.md).
+
+
+```js
+// Input
+var name = "John Doe";
+eval("console.log(" + __JS_CONFUSER_VAR__(name) + ")");
+
+// Output
+var CA1HU0 = 'John Doe';
+eval('console.log(' + 'CA1HU0' + ')');
+```
+
+- Improved the `Zero Width` identifier generator (Thanks @doctor8296!)
+
+- Pad the `String Concealing` array with more fake strings
+
+- Improve `String Compression`
+
+- New Web UI sneak peak: https://new--confuser.netlify.app/
+
+
 # `1.7.2`
 Updates
 

package/README.md

@@ -183,6 +183,8 @@ var qFaI6S = function () {
 qFaI6S();
 ```
 
+[Learn mode here.](https://github.com/MichaelXF/js-confuser/blob/master/docs/RenameVariables.md)
+
 ### `renameGlobals`
 
 Renames top-level variables, turn this off for web-related scripts. Enabled by default. (`true/false`)
@@ -390,6 +392,8 @@ Use a number to control the percentage of strings.
 
 String Encoding transforms a string into an encoded representation. (`true/false/0-1`)
 
+**⚠️ Warning: Significantly increases file size! It is not recommended for most use cases.**
+
 Use a number to control the percentage of strings.
 
 `"console"` -> `'\x63\x6f\x6e\x73\x6f\x6c\x65'`
@@ -577,9 +581,16 @@ Creates a calculator function to handle arithmetic and logical expressions. (`tr
 
 Adds `debugger` statements throughout the code. Additionally adds a background function for DevTools detection. (`true/false/0-1`)
 
-### `lock.context`
+### `lock.tamperProtection`
 
-Properties that must be present on the `window` object (or `global` for NodeJS). (`string[]`)
+Tamper Protection safeguards the runtime behavior from being altered by JavaScript pitfalls. (`true/false`)
+
+**⚠️ Tamper Protection requires eval and ran in a non-strict mode environment!**
+
+- **This can break your code.**
+- **Due to the security concerns of arbitrary code execution, you must enable this yourself.**
+
+[Learn more here](https://github.com/MichaelXF/js-confuser/blob/master/TamperProtection.md).
 
 ### `lock.startDate`
 
@@ -629,10 +640,14 @@ Integrity ensures the source code is unchanged. (`true/false/0-1`)
 
 A custom callback function to invoke when a lock is triggered. (`string/false`)
 
-[Learn more about the countermeasures function](https://github.com/MichaelXF/js-confuser/blob/master/docs/Countermeasures.md).
+[Learn more here.](https://github.com/MichaelXF/js-confuser/blob/master/docs/Countermeasures.md)
 
 Otherwise, the obfuscator falls back to crashing the process.
 
+### `lock.context`
+
+Properties that must be present on the `window` object (or `global` for NodeJS). (`string[]`)
+
 ### `movedDeclarations`
 
 Moves variable declarations to the top of the context. (`true/false`)
@@ -785,6 +800,7 @@ You must enable locks yourself, and configure them to your needs.
   lock: {
     integrity: true,
     selfDefending: true,
+    tamperProtection: true,
     domainLock: ["mywebsite.com"],
     osLock: ["windows", "linux"],
     browserLock: ["firefox"],
@@ -813,7 +829,7 @@ These features are experimental or a security concern.
   // set to false for web-related scripts
   renameGlobals: false,
 
-  // experimental
+  // custom implementation
   identifierGenerator: function(){
     return "myvar_" + (counter++);
   },

package/dist/constants.js

@@ -3,7 +3,7 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.reservedKeywords = exports.reservedIdentifiers = exports.predictableFunctionTag = exports.placeholderVariablePrefix = exports.noRenameVariablePrefix = exports.criticalFunctionTag = void 0;
+exports.variableFunctionName = exports.reservedKeywords = exports.reservedIdentifiers = exports.predictableFunctionTag = exports.placeholderVariablePrefix = exports.noRenameVariablePrefix = exports.criticalFunctionTag = void 0;
 /**
  * Keywords disallowed for variable names in ES5 and under.
  */
@@ -26,4 +26,9 @@ const predictableFunctionTag = exports.predictableFunctionTag = "__JS_PREDICT__"
  * Tells the obfuscator this function is critical for the Obfuscated code.
  * -  Example: string decryption function
  */
-const criticalFunctionTag = exports.criticalFunctionTag = "__JS_CRITICAL__";
+const criticalFunctionTag = exports.criticalFunctionTag = "__JS_CRITICAL__";
+
+/**
+ * Allows the user to grab the variable name of a renamed variable.
+ */
+const variableFunctionName = exports.variableFunctionName = "__JS_CONFUSER_VAR__";

package/dist/index.js

@@ -9,6 +9,12 @@ Object.defineProperty(exports, "Obfuscator", {
     return _obfuscator.default;
   }
 });
+Object.defineProperty(exports, "Template", {
+  enumerable: true,
+  get: function () {
+    return _template.default;
+  }
+});
 Object.defineProperty(exports, "Transform", {
   enumerable: true,
   get: function () {
@@ -28,6 +34,7 @@ var _compiler = _interopRequireWildcard(require("./compiler"));
 var _parser = _interopRequireWildcard(require("./parser"));
 var _obfuscator = _interopRequireDefault(require("./obfuscator"));
 var _transform = _interopRequireDefault(require("./transforms/transform"));
+var _template = _interopRequireDefault(require("./templates/template"));
 var _object = require("./util/object");
 var _presets = _interopRequireDefault(require("./presets"));
 var assert = _interopRequireWildcard(require("assert"));
@@ -156,6 +163,7 @@ JsConfuser.debugTransformations = debugTransformations;
 JsConfuser.debugObfuscation = debugObfuscation;
 JsConfuser.Obfuscator = _obfuscator.default;
 JsConfuser.Transform = _transform.default;
+JsConfuser.Template = _template.default;
 if (typeof window !== "undefined") {
   window["JsConfuser"] = JsConfuser;
 }

package/dist/options.js

@@ -9,6 +9,7 @@ var _assert = require("assert");
 var _presets = _interopRequireDefault(require("./presets"));
 function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
 const validProperties = new Set(["preset", "target", "indent", "compact", "hexadecimalNumbers", "minify", "es5", "renameVariables", "renameGlobals", "identifierGenerator", "controlFlowFlattening", "globalConcealing", "stringCompression", "stringConcealing", "stringEncoding", "stringSplitting", "duplicateLiteralsRemoval", "dispatcher", "rgf", "objectExtraction", "flatten", "deadCode", "calculator", "lock", "movedDeclarations", "opaquePredicates", "shuffle", "stack", "verbose", "globalVariables", "debugComments", "preserveFunctionLength"]);
+const validLockProperties = new Set(["selfDefending", "antiDebug", "context", "tamperProtection", "startDate", "endDate", "domainLock", "osLock", "browserLock", "integrity", "countermeasures"]);
 const validOses = new Set(["windows", "linux", "osx", "ios", "android"]);
 const validBrowsers = new Set(["firefox", "chrome", "iexplorer", "edge", "safari", "opera"]);
 function validateOptions(options) {
@@ -31,6 +32,13 @@ function validateOptions(options) {
     throw new TypeError('browserLock can only be used when target="browser"');
   }
   if (options.lock) {
+    (0, _assert.ok)(typeof options.lock === "object", "options.lock must be an object");
+    Object.keys(options.lock).forEach(key => {
+      if (!validLockProperties.has(key)) {
+        throw new TypeError("Invalid lock option: '" + key + "'");
+      }
+    });
+
     // Validate browser-lock option
     if (options.lock.browserLock && typeof options.lock.browserLock !== "undefined") {
       (0, _assert.ok)(Array.isArray(options.lock.browserLock), "browserLock must be an array");
@@ -93,8 +101,10 @@ async function correctOptions(options) {
   if (options.globalVariables && !(options.globalVariables instanceof Set)) {
     options.globalVariables = new Set(Object.keys(options.globalVariables));
   }
-  if (options.lock && options.lock.selfDefending) {
-    options.compact = true; // self defending forcibly enables this
+  if (options.lock) {
+    if (options.lock.selfDefending) {
+      options.compact = true; // self defending forcibly enables this
+    }
   }
 
   // options.globalVariables outlines generic globals that should be present in the execution context

package/dist/templates/bufferToString.js

@@ -3,11 +3,33 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.GetGlobalTemplate = exports.BufferToStringTemplate = void 0;
+exports.createGetGlobalTemplate = exports.BufferToStringTemplate = void 0;
 var _constants = require("../constants");
 var _template = _interopRequireDefault(require("./template"));
 function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
-const GetGlobalTemplate = exports.GetGlobalTemplate = (0, _template.default)(`
+const createGetGlobalTemplate = (transform, object, parents) => {
+  var _options$lock;
+  var options = transform.options;
+  if ((_options$lock = options.lock) !== null && _options$lock !== void 0 && _options$lock.tamperProtection) {
+    return new _template.default(`
+      function {getGlobalFnName}(){
+        var localVar = false;
+        eval(${transform.jsConfuserVar("localVar")} + " = true")
+        if (!localVar) {
+          {countermeasures}
+        }
+    
+        const root = eval("this");
+        return root;
+      }
+    `).setDefaultVariables({
+      countermeasures: transform.lockTransform.getCounterMeasuresCode(object, parents)
+    });
+  }
+  return GetGlobalTemplate;
+};
+exports.createGetGlobalTemplate = createGetGlobalTemplate;
+const GetGlobalTemplate = new _template.default(`
   function ${_constants.placeholderVariablePrefix}CFG__getGlobalThis${_constants.predictableFunctionTag}(){
     return globalThis
   }
@@ -51,9 +73,8 @@ const GetGlobalTemplate = exports.GetGlobalTemplate = (0, _template.default)(`
 		return bestMatch || this;
   }
 `);
-const BufferToStringTemplate = exports.BufferToStringTemplate = (0, _template.default)(`
-
-  ${GetGlobalTemplate.source}
+const BufferToStringTemplate = exports.BufferToStringTemplate = new _template.default(`
+  {GetGlobalTemplate}
 
   var __globalObject = {getGlobalFnName}() || {};
   var __TextDecoder = __globalObject["TextDecoder"];

package/dist/templates/core.js

@@ -0,0 +1,35 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.IndexOfTemplate = void 0;
+var _template = _interopRequireDefault(require("./template"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+const IndexOfTemplate = exports.IndexOfTemplate = new _template.default(`
+function indexOf(str, substr) {
+  const len = str.length;
+  const sublen = substr.length;
+  let count = 0;
+
+  if (sublen > len) {
+    return -1;
+  }
+
+  for (let i = 0; i <= len - sublen; i++) {
+    for (let j = 0; j < sublen; j++) {
+      if (str[i + j] === substr[j]) {
+        count++;
+        if (count === sublen) {
+          return i;
+        }
+      } else {
+        count = 0;
+        break;
+      }
+    }
+  }
+
+  return -1;
+}
+`);

package/dist/templates/crash.js

@@ -3,16 +3,17 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.CrashTemplate3 = exports.CrashTemplate2 = exports.CrashTemplate1 = void 0;
+exports.CrashTemplate2 = exports.CrashTemplate1 = void 0;
 var _template = _interopRequireDefault(require("./template"));
 function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
-const CrashTemplate1 = exports.CrashTemplate1 = (0, _template.default)(`
-var {var} = "a";
-while(1){
-    {var} = {var} += "a";
+const CrashTemplate1 = exports.CrashTemplate1 = new _template.default(`
+var {var} = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789!#$%&()*+,./:;<=>?@[]^_\`{|}~"';
+while(true){
+    {var} = {var};
+    if(!{var}) break;
 }
 `);
-const CrashTemplate2 = exports.CrashTemplate2 = (0, _template.default)(`
+const CrashTemplate2 = exports.CrashTemplate2 = new _template.default(`
 while(true) {
     var {var} = 99;
     for({var} = 99; {var} == {var}; {var} *= {var}) {
@@ -24,36 +25,4 @@ while(true) {
     if({var} === 100) {
         {var}--
     }
- };`);
-const CrashTemplate3 = exports.CrashTemplate3 = (0, _template.default)(`
-try {
-    function {$2}(y, x){
-        return x;
-      }
-      
-      var {$1} = {$2}(this, function () {
-        var {$3} = function () {
-            var regExp = {$3}
-                .constructor('return /" + this + "/')()
-                .constructor('^([^ ]+( +[^ ]+)+)+[^ ]}');
-            
-            return !regExp.call({$1});
-        };
-        
-        return {$3}();
-      });
-      
-      {$1}();
-} catch ( {$1}e ) {
-    while({$1}e ? {$1}e : !{$1}e){
-        var {$1}b;
-        var {$1}c = 0;
-        ({$1}e ? !{$1}e : {$1}e) ? (function({$1}e){
-            {$1}c = {$1}e ? 0 : !{$1}e ? 1 : 0;
-        })({$1}e) : {$1}b = 1;
-
-        if({$1}b&&{$1}c){break;}
-        if({$1}b){continue;}
-    }
-}
-`);
+ };`);

package/dist/templates/es5.js

@@ -11,7 +11,7 @@ function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e
  *
  * Source: https://vanillajstoolkit.com/polyfills/
  */
-const ES5Template = exports.ES5Template = (0, _template.default)(`
+const ES5Template = exports.ES5Template = new _template.default(`
 if (!Array.prototype.forEach) {
   Array.prototype.forEach = function forEach (callback, thisArg) {
     if (typeof callback !== 'function') {

package/dist/templates/functionLength.js

@@ -9,7 +9,7 @@ function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e
 /**
  * Helper function to set `function.length` property.
  */
-const FunctionLengthTemplate = exports.FunctionLengthTemplate = (0, _template.default)(`
+const FunctionLengthTemplate = exports.FunctionLengthTemplate = new _template.default(`
 function {name}(functionObject, functionLength){
   {ObjectDefineProperty}(functionObject, "length", {
     "value": functionLength,

package/dist/templates/globals.js

@@ -6,4 +6,4 @@ Object.defineProperty(exports, "__esModule", {
 exports.ObjectDefineProperty = void 0;
 var _template = _interopRequireDefault(require("./template"));
 function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
-const ObjectDefineProperty = exports.ObjectDefineProperty = (0, _template.default)(`Object["defineProperty"]`);
+const ObjectDefineProperty = exports.ObjectDefineProperty = new _template.default(`Object["defineProperty"]`);

package/dist/templates/template.js

@@ -3,57 +3,135 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.default = Template;
+exports.default = void 0;
 var _parser = require("../parser");
 var _assert = require("assert");
 var _random = require("../util/random");
-var _constants = require("../constants");
-function Template() {
-  for (var _len = arguments.length, templates = new Array(_len), _key = 0; _key < _len; _key++) {
-    templates[_key] = arguments[_key];
+var _traverse = _interopRequireDefault(require("../traverse"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+function _defineProperty(e, r, t) { return (r = _toPropertyKey(r)) in e ? Object.defineProperty(e, r, { value: t, enumerable: !0, configurable: !0, writable: !0 }) : e[r] = t, e; }
+function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == typeof i ? i : i + ""; }
+function _toPrimitive(t, r) { if ("object" != typeof t || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != typeof i) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+/**
+ * Templates provides an easy way to parse code snippets into AST subtrees.
+ *
+ * These AST subtrees can added to the obfuscated code, tailored with variable names.
+ *
+ * 1. Basic string interpolation
+ *
+ * ```js
+ * var Base64Template = new Template(`
+ * function {name}(str){
+ *   return btoa(str)
+ * }
+ * `);
+ *
+ * var functionDeclaration = Base64Template.single({ name: "atob" });
+ * ```
+ *
+ * 2. AST subtree insertion
+ *
+ * ```js
+ * var Base64Template = new Template(`
+ * function {name}(str){
+ *   {getWindow}
+ *
+ *   return {getWindowName}btoa(str)
+ * }`)
+ *
+ * var functionDeclaration = Base64Template.single({
+ *  name: "atob",
+ *  getWindowName: "newWindow",
+ *  getWindow: () => {
+ *    return acorn.parse("var newWindow = {}").body[0];
+ *  }
+ * });
+ * ```
+ *
+ * Here, the `getWindow` variable is a function that returns an AST subtree. This must be a `Node[]` array or Template.
+ * Optionally, the function can be replaced with just the `Node[]` array or Template if it's already computed.
+ *
+ * 3. Template subtree insertion
+ *
+ * ```js
+ * var NewWindowTemplate = new Template(`
+ *   var newWindow = {};
+ * `);
+ *
+ * var Base64Template = new Template(`
+ * function {name}(str){
+ *   {NewWindowTemplate}
+ *
+ *   return newWindow.btoa(str)
+ * }`)
+ *
+ * var functionDeclaration = Base64Template.single({
+ *  name: "atob",
+ *  NewWindowTemplate: NewWindowTemplate
+ * });
+ * ```
+ */
+class Template {
+  constructor() {
+    _defineProperty(this, "templates", void 0);
+    _defineProperty(this, "defaultVariables", void 0);
+    _defineProperty(this, "requiredVariables", void 0);
+    for (var _len = arguments.length, templates = new Array(_len), _key = 0; _key < _len; _key++) {
+      templates[_key] = arguments[_key];
+    }
+    this.templates = templates;
+    this.defaultVariables = Object.create(null);
+    this.requiredVariables = new Set();
+    this.findRequiredVariables();
   }
-  (0, _assert.ok)(templates.length);
-  var requiredVariables = new Set();
-  var providedVariables = {};
-  var defaultVariables = Object.create(null);
-
-  // This may picked up "$mb[pP`x]" from String Encoding function
-  // ignoreMissingVariables() prevents this
-  var matches = templates[0].match(/{[$A-z0-9_]+}/g);
-  if (matches !== null) {
-    matches.forEach(variable => {
-      var name = variable.slice(1, -1);
+  setDefaultVariables(defaultVariables) {
+    this.defaultVariables = defaultVariables;
+    return this;
+  }
+  findRequiredVariables() {
+    var matches = this.templates[0].match(/{[$A-z0-9_]+}/g);
+    if (matches !== null) {
+      matches.forEach(variable => {
+        var name = variable.slice(1, -1);
 
-      // $ variables are for default variables
-      if (name.startsWith("$")) {
-        defaultVariables[name] = _constants.placeholderVariablePrefix + "td_" + Object.keys(defaultVariables).length;
-      } else {
-        requiredVariables.add(name);
-      }
-    });
+        // $ variables are for default variables
+        if (name.startsWith("$")) {
+          throw new Error("Default variables are no longer supported.");
+        } else {
+          this.requiredVariables.add(name);
+        }
+      });
+    }
   }
-  function fill() {
-    let variables = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : Object.create(null);
-    var userVariables = {
-      ...providedVariables,
+
+  /**
+   * Interpolates the template with the given variables.
+   *
+   * Prepares the template string for AST parsing.
+   *
+   * @param variables
+   */
+  interpolateTemplate() {
+    let variables = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+    var allVariables = {
+      ...this.defaultVariables,
       ...variables
     };
 
     // Validate all variables were passed in
-    for (var requiredVariable of requiredVariables) {
-      if (typeof userVariables[requiredVariable] === "undefined") {
-        throw new Error(templates[0] + " missing variable: " + requiredVariable + " from " + JSON.stringify(userVariables));
+    for (var requiredVariable of this.requiredVariables) {
+      if (typeof allVariables[requiredVariable] === "undefined") {
+        throw new Error(this.templates[0] + " missing variable: " + requiredVariable + " from " + JSON.stringify(allVariables));
       }
     }
-    var template = (0, _random.choice)(templates);
+    var template = (0, _random.choice)(this.templates);
     var output = template;
-    var allVariables = {
-      ...defaultVariables,
-      ...userVariables
-    };
     Object.keys(allVariables).forEach(name => {
       var bracketName = "{" + name.replace("$", "\\$") + "}";
       var value = allVariables[name] + "";
+      if (typeof allVariables[name] !== "string") {
+        value = name;
+      }
       var reg = new RegExp(bracketName, "g");
       output = output.replace(reg, value);
     });
@@ -62,45 +140,72 @@ function Template() {
       template
     };
   }
-  function compile(variables) {
+
+  /**
+   * Finds the variables in the AST and replaces them with the given values.
+   *
+   * Note: Mutates the AST.
+   * @param ast
+   * @param variables
+   */
+  interpolateAST(ast, variables) {
+    var allVariables = {
+      ...this.defaultVariables,
+      ...variables
+    };
+    var astNames = new Set(Object.keys(allVariables).filter(name => {
+      return typeof allVariables[name] !== "string";
+    }));
+    if (astNames.size === 0) return;
+    (0, _traverse.default)(ast, (o, p) => {
+      if (o.type === "Identifier" && allVariables[o.name]) {
+        return () => {
+          var value = allVariables[o.name];
+          (0, _assert.ok)(typeof value !== "string");
+          var insertNodes = typeof value === "function" ? value() : value;
+          if (insertNodes instanceof Template) {
+            insertNodes = insertNodes.compile(allVariables);
+          }
+          if (!Array.isArray(insertNodes)) {
+            // Replace with expression
+
+            Object.assign(o, insertNodes);
+          } else {
+            // Insert multiple statements/declarations
+            var expressionStatement = p[0];
+            var body = p[1];
+            (0, _assert.ok)(expressionStatement.type === "ExpressionStatement");
+            (0, _assert.ok)(Array.isArray(body));
+            var index = body.indexOf(expressionStatement);
+            body.splice(index, 1, ...insertNodes);
+          }
+        };
+      }
+    });
+  }
+  compile() {
+    let variables = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
     var {
       output,
       template
-    } = fill(variables);
+    } = this.interpolateTemplate(variables);
+    var program;
     try {
-      var program = (0, _parser.parseSnippet)(output);
-      return program.body;
+      program = (0, _parser.parseSnippet)(output);
     } catch (e) {
-      console.error(e);
-      console.error(template);
-      console.error({
-        ...providedVariables,
-        ...variables
-      });
-      throw new Error("Template failed to parse: OUTPUT= " + output + " SOURCE= " + template);
+      throw new Error(output + "\n" + "Template failed to parse: " + e.message);
     }
+    this.interpolateAST(program, variables);
+    return program.body;
   }
-  function single(variables) {
-    var nodes = compile(variables);
+  single() {
+    let variables = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+    var nodes = this.compile(variables);
+    if (nodes.length !== 1) {
+      nodes = nodes.filter(node => node.type !== "EmptyStatement");
+      (0, _assert.ok)(nodes.length === 1, `Expected single node, got ${nodes.map(node => node.type).join(", ")}`);
+    }
     return nodes[0];
   }
-  function variables(newVariables) {
-    Object.assign(providedVariables, newVariables);
-    return obj;
-  }
-  function ignoreMissingVariables() {
-    defaultVariables = Object.create(null);
-    requiredVariables.clear();
-    return obj;
-  }
-  var obj = {
-    fill,
-    compile,
-    single,
-    templates,
-    variables,
-    ignoreMissingVariables,
-    source: templates[0]
-  };
-  return obj;
-}
+}
+exports.default = Template;

package/dist/transforms/antiTooling.js

@@ -23,7 +23,7 @@ class AntiTooling extends _transform.default {
   apply(tree) {
     super.apply(tree);
     if (typeof this.fnName === "string") {
-      (0, _insert.prepend)(tree, (0, _template.default)(`
+      (0, _insert.prepend)(tree, new _template.default(`
       function {fnName}(){
       }
       `).single({