@rhinostone/swig 2.0.1 → 2.1.0

package/dist/swig.js

@@ -1,4 +1,4 @@
-/*! Swig v2.0.1 | https://github.com/gina-io/swig | @license https://github.com/gina-io/swig/blob/master/LICENSE */
+/*! Swig v2.1.0 | https://github.com/gina-io/swig | @license https://github.com/gina-io/swig/blob/master/LICENSE */
 /*! DateZ (c) 2011 Tomo Universalis | @license https://github.com/ocrybit/DateZ/blob/master/LISENCE */
 (() => {
   var __getOwnPropNames = Object.getOwnPropertyNames;
@@ -275,6 +275,49 @@
       exports.legacyJS = function(js, loc) {
         return withLoc({ type: "LegacyJS", js }, loc);
       };
+      exports.extendsDeferred = function(path, childBlocks, childIRs, resolveFrom, loc) {
+        var node = { type: "ExtendsDeferred", path };
+        if (childBlocks !== void 0) {
+          node.childBlocks = childBlocks;
+        }
+        if (childIRs !== void 0) {
+          node.childIRs = childIRs;
+        }
+        if (resolveFrom !== void 0) {
+          node.resolveFrom = resolveFrom;
+        }
+        return withLoc(node, loc);
+      };
+      exports.includeDeferred = function(path, context, isolated, ignoreMissing, resolveFrom, loc) {
+        var node = { type: "IncludeDeferred", path };
+        if (context !== void 0) {
+          node.context = context;
+        }
+        if (isolated !== void 0) {
+          node.isolated = isolated;
+        }
+        if (ignoreMissing !== void 0) {
+          node.ignoreMissing = ignoreMissing;
+        }
+        if (resolveFrom !== void 0) {
+          node.resolveFrom = resolveFrom;
+        }
+        return withLoc(node, loc);
+      };
+      exports.importDeferred = function(path, alias, resolveFrom, loc) {
+        var node = { type: "ImportDeferred", path, alias };
+        if (resolveFrom !== void 0) {
+          node.resolveFrom = resolveFrom;
+        }
+        return withLoc(node, loc);
+      };
+      exports.fromImportDeferred = function(path, imports, resolveFrom, loc) {
+        var node = { type: "FromImportDeferred", path, imports };
+        if (resolveFrom !== void 0) {
+          node.resolveFrom = resolveFrom;
+        }
+        return withLoc(node, loc);
+      };
       exports.literal = function(kind, value, loc) {
         return withLoc({ type: "Literal", kind, value }, loc);
       };
@@ -1345,6 +1388,12 @@
               macroIndexOfJS = '"' + macroParams.join('","') + '"';
             }
             out += "_ctx." + node.name + " = function (" + macroSigJS + ') {\n  var _output = "",\n    __ctx = _utils.extend({}, _ctx);\n  _utils.each(_ctx, function (v, k) {\n    if ([' + macroIndexOfJS + "].indexOf(k) !== -1) { delete _ctx[k]; }\n  });\n" + macroBodyJS + "\n _ctx = _utils.extend(_ctx, __ctx);\n  return _output;\n};\n_ctx." + node.name + ".safe = true;\n";
+            if (options && options.codegenMode === "async") {
+              if (_security.dangerousProps.indexOf(node.name) !== -1) {
+                throw new Error('Macro name "' + node.name + '" is reserved.');
+              }
+              out += "_exports." + node.name + " = _ctx." + node.name + ";\n";
+            }
             return;
           }
           if (node.type === "Parent") {
@@ -1361,6 +1410,24 @@
             return;
           }
           if (node.type === "Block") {
+            if (options && options.codegenMode === "async") {
+              var blockNameJS = JSON.stringify(node.name);
+              out += "if (_blocks && _blocks[" + blockNameJS + "]) {\n";
+              out += "  _output += await _blocks[" + blockNameJS + "](_ctx);\n";
+              out += "} else {\n";
+              utils.each(node.body, function(b) {
+                if (b.type === "LegacyJS") {
+                  out += b.js;
+                  return;
+                }
+                if (b.type === "Text" || b.type === "Raw") {
+                  out += '_output += "' + escapeTextValue(b.value) + '";\n';
+                  return;
+                }
+              });
+              out += "}\n";
+              return;
+            }
             utils.each(node.body, function(b) {
               if (b.type === "LegacyJS") {
                 out += b.js;
@@ -1398,6 +1465,106 @@
             out += (node.ignoreMissing ? "  try {\n" : "") + "_output += _swig.compileFile(" + incPathJS + ', {resolveFrom: "' + node.resolveFrom + '"})(' + incSelector + ");\n" + (node.ignoreMissing ? "} catch (e) {}\n" : "");
             return;
           }
+          if (node.type === "IncludeDeferred") {
+            var incdPathJS, incdCtxJS;
+            if (node.path && typeof node.path === "object" && typeof node.path.type === "string") {
+              incdPathJS = exports.emitExpr(node.path);
+            } else {
+              incdPathJS = node.path;
+            }
+            if (node.context !== void 0) {
+              if (typeof node.context === "object" && typeof node.context.type === "string") {
+                incdCtxJS = exports.emitExpr(node.context);
+              } else {
+                incdCtxJS = node.context;
+              }
+            }
+            var incdSelector;
+            if (node.isolated && incdCtxJS) {
+              incdSelector = incdCtxJS;
+            } else if (!incdCtxJS) {
+              incdSelector = "_ctx";
+            } else {
+              incdSelector = "_utils.extend({}, _ctx, " + incdCtxJS + ")";
+            }
+            var incdOpts = '{resolveFrom: "' + (node.resolveFrom || "") + '"}';
+            out += (node.ignoreMissing ? "  try {\n" : "") + "_output += (await (await _swig.getTemplate(" + incdPathJS + ", " + incdOpts + "))(" + incdSelector + ")).output;\n" + (node.ignoreMissing ? "} catch (e) {}\n" : "");
+            return;
+          }
+          if (node.type === "ImportDeferred") {
+            if (_security.dangerousProps.indexOf(node.alias) !== -1) {
+              throw new Error('Import alias "' + node.alias + '" is reserved.');
+            }
+            var impdPathJS;
+            if (node.path && typeof node.path === "object" && typeof node.path.type === "string") {
+              impdPathJS = exports.emitExpr(node.path);
+            } else {
+              impdPathJS = node.path;
+            }
+            var impdOpts = '{resolveFrom: "' + (node.resolveFrom || "") + '"}';
+            out += "_ctx." + node.alias + " = (await (await _swig.getTemplate(" + impdPathJS + ", " + impdOpts + "))(_ctx)).exports;\n";
+            return;
+          }
+          if (node.type === "FromImportDeferred") {
+            var fromdImports = node.imports || [];
+            utils.each(fromdImports, function(entry) {
+              if (_security.dangerousProps.indexOf(entry.name) !== -1) {
+                throw new Error('From-import name "' + entry.name + '" is reserved.');
+              }
+              var bindName = entry.alias || entry.name;
+              if (_security.dangerousProps.indexOf(bindName) !== -1) {
+                throw new Error('From-import binding "' + bindName + '" is reserved.');
+              }
+            });
+            var fromdPathJS;
+            if (node.path && typeof node.path === "object" && typeof node.path.type === "string") {
+              fromdPathJS = exports.emitExpr(node.path);
+            } else {
+              fromdPathJS = node.path;
+            }
+            var fromdOpts = '{resolveFrom: "' + (node.resolveFrom || "") + '"}';
+            var fromdBindings = "";
+            utils.each(fromdImports, function(entry) {
+              var bindName = entry.alias || entry.name;
+              fromdBindings += "  _ctx." + bindName + ' = _imp["' + entry.name + '"];\n';
+            });
+            out += "await (async function () {\n  var _imp = (await (await _swig.getTemplate(" + fromdPathJS + ", " + fromdOpts + "))(_ctx)).exports;\n" + fromdBindings + "})();\n";
+            return;
+          }
+          if (node.type === "ExtendsDeferred") {
+            if (node.childIRs && node.childIRs.length) {
+              out += exports.compile(node.childIRs, parents, options);
+            }
+            out += "var _localChildBlocks = {};\n";
+            if (node.childBlocks) {
+              utils.each(node.childBlocks, function(block, name) {
+                var blockBodyJS = "";
+                utils.each(block.body, function(b) {
+                  if (b.type === "LegacyJS") {
+                    blockBodyJS += b.js;
+                    return;
+                  }
+                  if (b.type === "Text" || b.type === "Raw") {
+                    blockBodyJS += '_output += "' + escapeTextValue(b.value) + '";\n';
+                    return;
+                  }
+                });
+                out += "_localChildBlocks[" + JSON.stringify(name) + '] = async function (_ctx) {\n  var _output = "";\n' + blockBodyJS + "  return _output;\n};\n";
+              });
+            }
+            out += "var _mergedBlocks = _utils.extend({}, _localChildBlocks, _blocks || {});\n";
+            var extPathJS;
+            if (node.path && typeof node.path === "object" && typeof node.path.type === "string") {
+              extPathJS = exports.emitExpr(node.path);
+            } else {
+              extPathJS = node.path;
+            }
+            var extOpts = '{resolveFrom: "' + (node.resolveFrom || "") + '"}';
+            out += "var _parentTpl = await _swig.getTemplate(" + extPathJS + ", " + extOpts + ");\n";
+            out += "var _parentResult = await _parentTpl(_ctx, _mergedBlocks);\n";
+            out += "_output = _parentResult.output;\n";
+            return;
+          }
           if (node.type === "With") {
             var withCtxJS;
             if (node.context !== void 0) {
@@ -1575,12 +1742,8 @@
         return build;
       }
       function checkMatchExpr(match) {
-        var result;
-        function buildDot(ctx) {
-          return "(" + checkDotExpr(match, ctx) + " ? " + ctx + match.join(".") + ' : "")';
-        }
-        result = "(" + checkDotExpr(match, "_ctx.") + " ? " + buildDot("_ctx.") + " : " + buildDot("") + ")";
-        return "(" + result + " !== null ? " + result + ' : "" )';
+        var leaf = match.join(".");
+        return "(" + checkDotExpr(match, "_ctx.") + " ? _ctx." + leaf + " : (" + checkDotExpr(match, "") + " ? " + leaf + ' : ""))';
       }
       function emitAccess(node, d) {
         if (node.key && node.key.type === "Literal" && node.key.kind === "string") {
@@ -2652,7 +2815,7 @@
          * @private
          */
         checkMatch: function(match) {
-          var temp = match[0], result;
+          var temp = match[0], leaf = match.join(".");
           function checkDot(ctx) {
             var c = ctx + temp, m = match, build = "";
             build = "(typeof " + c + ' !== "undefined" && ' + c + " !== null";
@@ -2666,11 +2829,7 @@
             build += ")";
             return build;
           }
-          function buildDot(ctx) {
-            return "(" + checkDot(ctx) + " ? " + ctx + match.join(".") + ' : "")';
-          }
-          result = "(" + checkDot("_ctx.") + " ? " + buildDot("_ctx.") + " : " + buildDot("") + ")";
-          return "(" + result + " !== null ? " + result + ' : "" )';
+          return "(" + checkDot("_ctx.") + " ? _ctx." + leaf + " : (" + checkDot("") + " ? " + leaf + ' : ""))';
         }
       };
       exports.TokenParser = TokenParser;
@@ -3789,6 +3948,155 @@
     }
   });
 
+  // lib/async/pre-walker.js
+  var require_pre_walker = __commonJS({
+    "lib/async/pre-walker.js"(exports) {
+      var utils = require_utils2();
+      function escapeRegExp(str) {
+        return str.replace(/[\-\/\\\^$*+?.()|\[\]{}]/g, "\\$&");
+      }
+      function buildSplitter(controls) {
+        var anyChar = "[\\s\\S]*?", varOpen = escapeRegExp(controls.varControls[0]), varClose = escapeRegExp(controls.varControls[1]), tagOpen = escapeRegExp(controls.tagControls[0]), tagClose = escapeRegExp(controls.tagControls[1]), cmtOpen = escapeRegExp(controls.cmtControls[0]), cmtClose = escapeRegExp(controls.cmtControls[1]);
+        return new RegExp(
+          "(" + tagOpen + anyChar + tagClose + "|" + varOpen + anyChar + varClose + "|" + cmtOpen + anyChar + cmtClose + ")"
+        );
+      }
+      function stripTagBody(chunk, tagOpen, tagClose) {
+        var body = chunk.substr(tagOpen.length, chunk.length - tagOpen.length - tagClose.length);
+        if (body.charAt(0) === "-") {
+          body = body.substr(1);
+        }
+        if (body.charAt(body.length - 1) === "-") {
+          body = body.substr(0, body.length - 1);
+        }
+        return body.replace(/^\s+|\s+$/g, "");
+      }
+      exports.scan = function(source, opts) {
+        source = source.replace(/\r\n/g, "\n");
+        var splitter = buildSplitter(opts), tagOpen = opts.tagControls[0], tagClose = opts.tagControls[1], rawTag = opts.rawTag, endRawTag = "end" + rawTag, keywordRegex = new RegExp(
+          "^(" + opts.keywords.join("|") + `)\\s+["\\']([^"\\']+)["\\']`
+        ), chunks = source.split(splitter), results = [], inRaw = false, i, chunk, body, name, m;
+        for (i = 0; i < chunks.length; i += 1) {
+          chunk = chunks[i];
+          if (typeof chunk !== "string" || !chunk) {
+            continue;
+          }
+          if (!utils.startsWith(chunk, tagOpen) || !utils.endsWith(chunk, tagClose)) {
+            continue;
+          }
+          body = stripTagBody(chunk, tagOpen, tagClose);
+          name = body.split(/\s+/)[0];
+          if (name === rawTag) {
+            inRaw = true;
+            continue;
+          }
+          if (name === endRawTag) {
+            inRaw = false;
+            continue;
+          }
+          if (inRaw) {
+            continue;
+          }
+          m = keywordRegex.exec(body);
+          if (m) {
+            results.push({ kind: m[1], path: m[2] });
+          }
+        }
+        return results;
+      };
+      exports.walk = function(entryPath, loader, scanOpts) {
+        var memMap = {};
+        var pending = {};
+        return new Promise(function(resolve, reject) {
+          var inFlight = 0;
+          var queue = [];
+          var hasError = false;
+          function enqueue(path) {
+            if (memMap.hasOwnProperty(path) || pending[path]) {
+              return;
+            }
+            pending[path] = true;
+            queue.push(path);
+          }
+          function drain() {
+            while (queue.length > 0 && !hasError) {
+              var path = queue.shift();
+              inFlight += 1;
+              startLoad(path);
+            }
+            if (inFlight === 0 && !hasError && queue.length === 0) {
+              resolve(memMap);
+            }
+          }
+          function startLoad(resolvedPath) {
+            loader.load(resolvedPath, function(err, src) {
+              if (hasError) {
+                return;
+              }
+              if (err) {
+                hasError = true;
+                reject(err);
+                return;
+              }
+              if (typeof src !== "string") {
+                hasError = true;
+                reject(new Error('Async loader returned non-string source for "' + resolvedPath + '"'));
+                return;
+              }
+              memMap[resolvedPath] = src;
+              var targets;
+              try {
+                targets = exports.scan(src, scanOpts);
+              } catch (e) {
+                hasError = true;
+                reject(e);
+                return;
+              }
+              var i, resolvedChild;
+              for (i = 0; i < targets.length; i += 1) {
+                try {
+                  resolvedChild = loader.resolve(targets[i].path, resolvedPath);
+                } catch (e) {
+                  hasError = true;
+                  reject(e);
+                  return;
+                }
+                enqueue(resolvedChild);
+              }
+              inFlight -= 1;
+              drain();
+            });
+          }
+          enqueue(entryPath);
+          drain();
+        });
+      };
+      exports.makeMemoryWrapper = function(userLoader, memMap) {
+        return {
+          resolve: function(to, from) {
+            return userLoader.resolve(to, from);
+          },
+          load: function(id, cb) {
+            var src = memMap[id];
+            if (typeof src !== "string") {
+              var err = new Error('Pre-walked map missing path: "' + id + '"');
+              if (cb) {
+                cb(err);
+                return;
+              }
+              throw err;
+            }
+            if (cb) {
+              cb(null, src);
+              return;
+            }
+            return src;
+          }
+        };
+      };
+    }
+  });
+
   // packages/swig-core/lib/cache.js
   var require_cache = __commonJS({
     "packages/swig-core/lib/cache.js"(exports) {
@@ -3824,6 +4132,8 @@
       var utils = require_utils();
       var backend = require_backend();
       var cache = require_cache();
+      var AsyncFunction = Object.getPrototypeOf(async function() {
+      }).constructor;
       function efn() {
         return "";
       }
@@ -3874,14 +4184,12 @@
         return parents;
       };
       exports.buildTemplateFunction = function(tokens, parents, options) {
-        return new Function(
-          "_swig",
-          "_ctx",
-          "_filters",
-          "_utils",
-          "_fn",
-          '  var _ext = _swig.extensions,\n    _output = "";\n' + backend.compile(tokens, parents, options) + "\n  return _output;\n"
-        );
+        if (options && options.codegenMode === "async") {
+          var asyncBody = '  var _ext = _swig.extensions,\n    _output = "",\n    _exports = {};\n' + backend.compile(tokens, parents, options) + "\n  return { output: _output, exports: _exports };\n";
+          return new AsyncFunction("_swig", "_ctx", "_filters", "_utils", "_fn", "_blocks", asyncBody);
+        }
+        var body = '  var _ext = _swig.extensions,\n    _output = "";\n' + backend.compile(tokens, parents, options) + "\n  return _output;\n";
+        return new Function("_swig", "_ctx", "_filters", "_utils", "_fn", body);
       };
       exports.install = function(self, frontend) {
         var parser = frontend.parser, tags = utils.extend({}, frontend.tags), filters = utils.extend({}, frontend.filters), validateOptions = frontend.validateOptions, onCompileError = frontend.onCompileError;
@@ -3979,7 +4287,7 @@
           context = getLocals(options);
           contextLength = utils.keys(context).length;
           pre = self.precompile(source, options);
-          function compiled(locals) {
+          function compiled(locals, blocks) {
             var lcls;
             if (locals && contextLength) {
               lcls = utils.extend({}, context, locals);
@@ -3990,7 +4298,7 @@
             } else {
               lcls = {};
             }
-            return pre.tpl(self, lcls, filters, utils, efn);
+            return pre.tpl(self, lcls, filters, utils, efn, blocks);
           }
           utils.extend(compiled, pre.tokens);
           if (key) {
@@ -4035,6 +4343,52 @@
           src = self.options.loader.load(pathname);
           return self.compile(src, options);
         };
+        self.getTemplate = function(pathname, options) {
+          options = options || {};
+          var resolved;
+          try {
+            resolved = self.options.loader.resolve(pathname, options.resolveFrom);
+          } catch (e) {
+            return Promise.reject(e);
+          }
+          var compileOpts = utils.extend({}, options, {
+            filename: options.filename || resolved,
+            codegenMode: "async",
+            cache: false
+          });
+          return new Promise(function(resolve, reject) {
+            function onLoaded(err, src2) {
+              if (err) {
+                reject(err);
+                return;
+              }
+              var compiled;
+              try {
+                compiled = self.compile(src2, compileOpts);
+              } catch (err2) {
+                reject(err2);
+                return;
+              }
+              resolve(compiled);
+            }
+            if (self.options.loader.load.length >= 2) {
+              try {
+                self.options.loader.load(resolved, onLoaded);
+              } catch (e) {
+                onLoaded(e);
+              }
+            } else {
+              var src;
+              try {
+                src = self.options.loader.load(resolved);
+              } catch (e) {
+                onLoaded(e);
+                return;
+              }
+              onLoaded(null, src);
+            }
+          });
+        };
         self.render = function(source, options) {
           return self.compile(source, options)();
         };
@@ -4078,8 +4432,9 @@
       var parser = require_parser();
       var dateformatter = require_dateformatter2();
       var loaders = require_loaders2();
+      var preWalker = require_pre_walker();
       var engine = require_engine();
-      exports.version = "2.0.1";
+      exports.version = "2.1.0";
       var defaultOptions = {
         autoescape: true,
         varControls: ["{{", "}}"],
@@ -4182,6 +4537,94 @@
             utils.throwError(err, null, options.filename);
           }
         });
+        var self = this;
+        function buildScanOpts() {
+          return {
+            varControls: self.options.varControls,
+            tagControls: self.options.tagControls,
+            cmtControls: self.options.cmtControls,
+            rawTag: "raw",
+            keywords: ["extends", "include", "import"]
+          };
+        }
+        this.renderFileAsync = function(pathName, locals, cb) {
+          if (typeof locals === "function") {
+            cb = locals;
+            locals = void 0;
+          }
+          var loader = self.options.loader;
+          var entry;
+          try {
+            entry = loader.resolve(pathName);
+          } catch (e) {
+            cb(e);
+            return;
+          }
+          preWalker.walk(entry, loader, buildScanOpts()).then(function(memMap) {
+            var memWrapper = preWalker.makeMemoryWrapper(loader, memMap);
+            var origLoader = self.options.loader;
+            self.options.loader = memWrapper;
+            var output, error;
+            try {
+              output = self.renderFile(entry, locals);
+            } catch (e) {
+              error = e;
+            }
+            self.options.loader = origLoader;
+            if (error) {
+              cb(error);
+              return;
+            }
+            cb(null, output);
+          }, function(err) {
+            cb(err);
+          });
+        };
+        this.compileFileAsync = function(pathName, options, cb) {
+          if (typeof options === "function") {
+            cb = options;
+            options = {};
+          }
+          var loader = self.options.loader;
+          var entry;
+          try {
+            entry = loader.resolve(pathName);
+          } catch (e) {
+            cb(e);
+            return;
+          }
+          preWalker.walk(entry, loader, buildScanOpts()).then(function(memMap) {
+            var memWrapper = preWalker.makeMemoryWrapper(loader, memMap);
+            var origLoader = self.options.loader;
+            self.options.loader = memWrapper;
+            var compiled, error;
+            try {
+              compiled = self.compileFile(entry, options);
+            } catch (e) {
+              error = e;
+            }
+            self.options.loader = origLoader;
+            if (error) {
+              cb(error);
+              return;
+            }
+            var wrapped = function(locals) {
+              var origInner = self.options.loader;
+              self.options.loader = memWrapper;
+              try {
+                var output = compiled(locals);
+                self.options.loader = origInner;
+                return output;
+              } catch (e) {
+                self.options.loader = origInner;
+                throw e;
+              }
+            };
+            cb(null, wrapped);
+          }, function(err) {
+            cb(err);
+          });
+        };
       };
       defaultInstance = new exports.Swig();
       exports.setFilter = defaultInstance.setFilter;
@@ -4191,8 +4634,10 @@
       exports.precompile = defaultInstance.precompile;
       exports.compile = defaultInstance.compile;
       exports.compileFile = defaultInstance.compileFile;
+      exports.compileFileAsync = defaultInstance.compileFileAsync;
       exports.render = defaultInstance.render;
       exports.renderFile = defaultInstance.renderFile;
+      exports.renderFileAsync = defaultInstance.renderFileAsync;
       exports.run = defaultInstance.run;
       exports.invalidateCache = defaultInstance.invalidateCache;
       exports.loaders = loaders;
@@ -4273,10 +4718,13 @@
  * compiled VarRef body relies on. @private
  */
 /*!
- * Replica of `TokenParser.prototype.checkMatch`. Kept as a local private
- * helper rather than imported from tokenparser.js because (a) it is a
- * pure function of its argument and (b) the backend must not acquire a
- * runtime dependency on the TokenParser module (which is a specific
+ * Build the dot-path emit. `(checkDot_ctx ? _ctx.<path> : (checkDot_closure
+ * ? <path> : ""))` — checks the `_ctx.<path>` walk first, falls back to a
+ * bare-closure walk (covers macro params, host-globals like `Math`), and
+ * coerces a missing path to `""` for safe interpolation. Kept as a local
+ * private helper rather than imported from tokenparser.js because (a) it
+ * is a pure function of its argument and (b) the backend must not acquire
+ * a runtime dependency on the TokenParser module (which is a specific
  * frontend concern, not a shared-backend one). @private
  */
 /*!
@@ -4316,6 +4764,21 @@
  * Loop over the source, split via the tag/var/comment regular expression splitter.
  * Send each chunk to the appropriate parser.
  */
+/*!
+ * Makes a string safe for a regular expression. Mirrors lib/parser.js.
+ * @private
+ */
+/*!
+ * Build the splitter regex from the controls trio. Mirrors the regex that
+ * parser.parse() builds at parse-time so the pre-walker chunks the same
+ * way the real parser would.
+ * @private
+ */
+/*!
+ * Strip tag controls and optional whitespace-control markers from a tag
+ * chunk, returning the trimmed tag body (e.g. `extends "x.html"`).
+ * @private
+ */
 /*!
  * Export methods publicly
  */