@jaredwray/fumanchu 2.1.0 → 3.0.1

package/dist/index.js

@@ -0,0 +1,2135 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __commonJS = (cb, mod) => function __require() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var __async = (__this, __arguments, generator) => {
+  return new Promise((resolve, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
+
+// helpers/lib/utils/falsey.js
+var require_falsey = __commonJS({
+  "helpers/lib/utils/falsey.js"(exports2, module2) {
+    "use strict";
+    function falsey(val, keywords) {
+      if (!val) {
+        return true;
+      }
+      let words = keywords || [
+        "0",
+        "false",
+        "nada",
+        "nil",
+        "nay",
+        "nah",
+        "negative",
+        "no",
+        "none",
+        "nope",
+        "nul",
+        "null",
+        "nix",
+        "nyet",
+        "uh-uh",
+        "veto",
+        "zero"
+      ];
+      if (!Array.isArray(words)) {
+        words = [words];
+      }
+      const lower = typeof val === "string" ? val.toLowerCase() : null;
+      for (const word of words) {
+        if (word === val) {
+          return true;
+        }
+        if (word === lower) {
+          return true;
+        }
+      }
+      return false;
+    }
+    module2.exports = falsey;
+  }
+});
+
+// helpers/lib/utils/utils.js
+var require_utils = __commonJS({
+  "helpers/lib/utils/utils.js"(exports2, module2) {
+    "use strict";
+    var utils = require("lazy-cache")(require);
+    var falsey = require_falsey();
+    var fn = require;
+    require = utils;
+    require("array-sort", "sortBy");
+    require("arr-flatten", "flatten");
+    require("to-gfm-code-block", "block");
+    require("html-tag", "tag");
+    require("kind-of", "typeOf");
+    require("is-glob");
+    require("micromatch", "mm");
+    utils.falsey = falsey;
+    require("is-even");
+    require("is-number");
+    require("create-frame");
+    require("get-object");
+    require("get-value", "get");
+    require("for-own");
+    require("relative");
+    require = fn;
+    module2.exports = utils;
+  }
+});
+
+// helpers/lib/utils/index.js
+var require_utils2 = __commonJS({
+  "helpers/lib/utils/index.js"(exports2, module2) {
+    "use strict";
+    var util = require("handlebars-utils");
+    var utils = require_utils();
+    utils.contains = function(val, obj, start) {
+      if (val == null || obj == null || !utils.isNumber(val.length)) {
+        return false;
+      }
+      return val.indexOf(obj, start) !== -1;
+    };
+    utils.chop = function(str) {
+      if (!util.isString(str)) return "";
+      var re = /^[-_.\W\s]+|[-_.\W\s]+$/g;
+      if (str.length > 1e3) {
+        throw new Error("utils.chop() regex is too long!");
+      }
+      return str.trim().replace(re, "");
+    };
+    utils.changecase = function(str, fn) {
+      if (!util.isString(str)) return "";
+      if (str.length === 1) {
+        return str.toLowerCase();
+      }
+      str = utils.chop(str).toLowerCase();
+      if (typeof fn !== "function") {
+        fn = utils.identity;
+      }
+      var re = /[-_.\W\s]+(\w|$)/g;
+      return str.replace(re, function(_, ch) {
+        return fn(ch);
+      });
+    };
+    utils.random = function(min, max) {
+      return min + Math.floor(Math.random() * (max - min + 1));
+    };
+    module2.exports = utils;
+  }
+});
+
+// helpers/lib/array.js
+var require_array = __commonJS({
+  "helpers/lib/array.js"(exports2, module2) {
+    "use strict";
+    var util = require("handlebars-utils");
+    var utils = require_utils2();
+    var helpers3 = module2.exports;
+    helpers3.after = function(array, n) {
+      if (util.isUndefined(array)) return "";
+      return array.slice(n);
+    };
+    helpers3.arrayify = function(value) {
+      return value ? Array.isArray(value) ? value : [value] : [];
+    };
+    helpers3.before = function(array, n) {
+      if (util.isUndefined(array)) return "";
+      return array.slice(0, -n);
+    };
+    helpers3.eachIndex = function(array, options) {
+      var result = "";
+      for (var i = 0; i < array.length; i++) {
+        result += options.fn({ item: array[i], index: i });
+      }
+      return result;
+    };
+    helpers3.filter = function(array, value, options) {
+      var content = "";
+      var results = [];
+      var prop = options.hash && (options.hash.property || options.hash.prop);
+      if (prop) {
+        results = array.filter(function(val) {
+          return value === utils.get(val, prop);
+        });
+      } else {
+        results = array.filter(function(v) {
+          return value === v;
+        });
+      }
+      if (results && results.length > 0) {
+        for (var i = 0; i < results.length; i++) {
+          content += options.fn(results[i]);
+        }
+        return content;
+      }
+      return options.inverse(this);
+    };
+    helpers3.first = function(array, n) {
+      if (util.isUndefined(array)) return "";
+      if (!utils.isNumber(n)) {
+        return array[0];
+      }
+      return array.slice(0, n);
+    };
+    helpers3.forEach = function(array, options) {
+      var data = utils.createFrame(options, options.hash);
+      var len = array.length;
+      var buffer = "";
+      var i = -1;
+      while (++i < len) {
+        var item = array[i];
+        data.index = i;
+        item.index = i + 1;
+        item.total = len;
+        item.isFirst = i === 0;
+        item.isLast = i === len - 1;
+        buffer += options.fn(item, { data });
+      }
+      return buffer;
+    };
+    helpers3.inArray = function(array, value, options) {
+      return util.value(util.indexOf(array, value) > -1, this, options);
+    };
+    helpers3.isArray = function(value) {
+      return Array.isArray(value);
+    };
+    helpers3.itemAt = function(array, idx) {
+      array = util.result(array);
+      if (Array.isArray(array)) {
+        idx = utils.isNumber(idx) ? +idx : 0;
+        if (idx < 0) {
+          return array[array.length + idx];
+        }
+        if (idx < array.length) {
+          return array[idx];
+        }
+      }
+    };
+    helpers3.join = function(array, separator) {
+      if (typeof array === "string") return array;
+      if (!Array.isArray(array)) return "";
+      separator = util.isString(separator) ? separator : ", ";
+      return array.join(separator);
+    };
+    helpers3.equalsLength = function(value, length, options) {
+      if (util.isOptions(length)) {
+        options = length;
+        length = 0;
+      }
+      var len = 0;
+      if (typeof value === "string" || Array.isArray(value)) {
+        len = value.length;
+      }
+      return util.value(len === length, this, options);
+    };
+    helpers3.last = function(value, n) {
+      if (!Array.isArray(value) && typeof value !== "string") {
+        return "";
+      }
+      if (!utils.isNumber(n)) {
+        return value[value.length - 1];
+      }
+      return value.slice(-Math.abs(n));
+    };
+    helpers3.length = function(value) {
+      if (util.isObject(value) && !util.isOptions(value)) {
+        value = Object.keys(value);
+      }
+      if (typeof value === "string" || Array.isArray(value)) {
+        return value.length;
+      }
+      return 0;
+    };
+    helpers3.lengthEqual = helpers3.equalsLength;
+    helpers3.map = function(array, iter) {
+      if (!Array.isArray(array)) return "";
+      var len = array.length;
+      var res = new Array(len);
+      var i = -1;
+      if (typeof iter !== "function") {
+        return array;
+      }
+      while (++i < len) {
+        res[i] = iter(array[i], i, array);
+      }
+      return res;
+    };
+    helpers3.pluck = function(arr, prop) {
+      if (util.isUndefined(arr)) return "";
+      var res = [];
+      for (var i = 0; i < arr.length; i++) {
+        var val = utils.get(arr[i], prop);
+        if (typeof val !== "undefined") {
+          res.push(val);
+        }
+      }
+      return res;
+    };
+    helpers3.reverse = function(val) {
+      if (Array.isArray(val)) {
+        val.reverse();
+        return val;
+      }
+      if (val && typeof val === "string") {
+        return val.split("").reverse().join("");
+      }
+    };
+    helpers3.some = function(array, iter, options) {
+      if (Array.isArray(array)) {
+        for (var i = 0; i < array.length; i++) {
+          if (iter(array[i], i, array)) {
+            return options.fn(this);
+          }
+        }
+      }
+      return options.inverse(this);
+    };
+    helpers3.sort = function(array, options) {
+      if (!Array.isArray(array)) return "";
+      if (utils.get(options, "hash.reverse")) {
+        return array.sort().reverse();
+      }
+      return array.sort();
+    };
+    helpers3.sortBy = function(array, prop, options) {
+      if (!Array.isArray(array)) return "";
+      var args = [].slice.call(arguments);
+      args.pop();
+      if (!util.isString(prop) && typeof prop !== "function") {
+        return array.sort();
+      }
+      return utils.sortBy.apply(null, args);
+    };
+    helpers3.withAfter = function(array, idx, options) {
+      if (!Array.isArray(array)) return "";
+      array = array.slice(idx);
+      var result = "";
+      for (var i = 0; i < array.length; i++) {
+        result += options.fn(array[i]);
+      }
+      return result;
+    };
+    helpers3.withBefore = function(array, idx, options) {
+      if (!Array.isArray(array)) return "";
+      array = array.slice(0, -idx);
+      var result = "";
+      for (var i = 0; i < array.length; i++) {
+        result += options.fn(array[i]);
+      }
+      return result;
+    };
+    helpers3.withFirst = function(array, idx, options) {
+      if (util.isUndefined(array)) return "";
+      array = util.result(array);
+      if (!util.isUndefined(idx)) {
+        idx = parseFloat(util.result(idx));
+      }
+      if (util.isUndefined(idx)) {
+        options = idx;
+        return options.fn(array[0]);
+      }
+      array = array.slice(0, idx);
+      var result = "";
+      for (var i = 0; i < array.length; i++) {
+        result += options.fn(array[i]);
+      }
+      return result;
+    };
+    helpers3.withGroup = function(array, size, options) {
+      var result = "";
+      if (Array.isArray(array) && array.length > 0) {
+        var subcontext = [];
+        for (var i = 0; i < array.length; i++) {
+          if (i > 0 && i % size === 0) {
+            result += options.fn(subcontext);
+            subcontext = [];
+          }
+          subcontext.push(array[i]);
+        }
+        result += options.fn(subcontext);
+      }
+      return result;
+    };
+    helpers3.withLast = function(array, idx, options) {
+      if (util.isUndefined(array)) return "";
+      array = util.result(array);
+      if (!util.isUndefined(idx)) {
+        idx = parseFloat(util.result(idx));
+      }
+      if (util.isUndefined(idx)) {
+        options = idx;
+        return options.fn(array[array.length - 1]);
+      }
+      array = array.slice(-idx);
+      var len = array.length, i = -1;
+      var result = "";
+      while (++i < len) {
+        result += options.fn(array[i]);
+      }
+      return result;
+    };
+    helpers3.withSort = function(array, prop, options) {
+      if (util.isUndefined(array)) return "";
+      var result = "";
+      if (util.isUndefined(prop)) {
+        options = prop;
+        array = array.sort();
+        if (utils.get(options, "hash.reverse")) {
+          array = array.reverse();
+        }
+        for (var i = 0, len = array.length; i < len; i++) {
+          result += options.fn(array[i]);
+        }
+        return result;
+      }
+      array.sort(function(a, b) {
+        a = utils.get(a, prop);
+        b = utils.get(b, prop);
+        return a > b ? 1 : a < b ? -1 : 0;
+      });
+      if (utils.get(options, "hash.reverse")) {
+        array = array.reverse();
+      }
+      var alen = array.length, j = -1;
+      while (++j < alen) {
+        result += options.fn(array[j]);
+      }
+      return result;
+    };
+    helpers3.unique = function(array, options) {
+      if (util.isUndefined(array)) return "";
+      return array.filter(function(item, index, arr) {
+        return arr.indexOf(item) === index;
+      });
+    };
+  }
+});
+
+// helpers/lib/code.js
+var require_code = __commonJS({
+  "helpers/lib/code.js"(exports2, module2) {
+    "use strict";
+    var fs = require("fs");
+    var path = require("path");
+    var utils = require_utils2();
+    var helpers3 = module2.exports;
+    helpers3.embed = function embed(filepath, ext) {
+      ext = typeof ext !== "string" ? path.extname(filepath).slice(1) : ext;
+      var code = fs.readFileSync(filepath, "utf8");
+      if (ext === "markdown" || ext === "md") {
+        ext = "markdown";
+        code = code.split("`").join("&#x60");
+      }
+      return utils.block(code, ext).trim() + "\n";
+    };
+    helpers3.gist = function(id) {
+      return utils.tag("script", { src: "https://gist.github.com/" + id + ".js" });
+    };
+    helpers3.jsfiddle = function jsFiddle(options) {
+      var attr = Object.assign({}, options && options.hash);
+      if (typeof attr.id === "undefined") {
+        throw new Error("jsfiddle helper expects an `id`");
+      }
+      attr.id = "http://jsfiddle.net/" + attr.id;
+      attr.width = attr.width || "100%";
+      attr.height = attr.height || "300";
+      attr.skin = attr.skin || "/presentation/";
+      attr.tabs = (attr.tabs || "result,js,html,css") + attr.skin;
+      attr.src = attr.id + "/embedded/" + attr.tabs;
+      attr.allowfullscreen = attr.allowfullscreen || "allowfullscreen";
+      attr.frameborder = attr.frameborder || "0";
+      delete attr.tabs;
+      delete attr.skin;
+      delete attr.id;
+      return utils.tag("iframe", attr);
+    };
+  }
+});
+
+// helpers/lib/object.js
+var require_object = __commonJS({
+  "helpers/lib/object.js"(exports2, module2) {
+    "use strict";
+    var hasOwn = Object.hasOwnProperty;
+    var util = require("handlebars-utils");
+    var array = require_array();
+    var utils = require_utils2();
+    var helpers3 = module2.exports;
+    helpers3.extend = function() {
+      var args = [].slice.call(arguments);
+      var opts = {};
+      if (util.isOptions(args[args.length - 1])) {
+        opts = args.pop().hash;
+        args.push(opts);
+      }
+      var context = {};
+      for (var i = 0; i < args.length; i++) {
+        var obj = args[i];
+        if (util.isObject(obj)) {
+          var keys = Object.keys(obj);
+          for (var j = 0; j < keys.length; j++) {
+            var key = keys[j];
+            context[key] = obj[key];
+          }
+        }
+      }
+      return context;
+    };
+    helpers3.forIn = function(obj, options) {
+      if (!util.isOptions(options)) {
+        return obj.inverse(this);
+      }
+      var data = utils.createFrame(options, options.hash);
+      var result = "";
+      for (var key in obj) {
+        data.key = key;
+        result += options.fn(obj[key], { data });
+      }
+      return result;
+    };
+    helpers3.forOwn = function(obj, options) {
+      if (!util.isOptions(options)) {
+        return obj.inverse(this);
+      }
+      var data = utils.createFrame(options, options.hash);
+      var result = "";
+      for (var key in obj) {
+        if (obj.hasOwnProperty(key)) {
+          data.key = key;
+          result += options.fn(obj[key], { data });
+        }
+      }
+      return result;
+    };
+    helpers3.toPath = function() {
+      var prop = [];
+      for (var i = 0; i < arguments.length; i++) {
+        if (typeof arguments[i] === "string" || typeof arguments[i] === "number") {
+          prop.push(arguments[i]);
+        }
+      }
+      return prop.join(".");
+    };
+    helpers3.get = function(prop, context, options) {
+      var val = utils.get(context, prop);
+      if (options && options.fn) {
+        return val ? options.fn(val) : options.inverse(context);
+      }
+      return val;
+    };
+    helpers3.getObject = function(prop, context) {
+      return utils.getObject(context, prop);
+    };
+    helpers3.hasOwn = function(context, key) {
+      return hasOwn.call(context, key);
+    };
+    helpers3.isObject = function(value) {
+      return utils.typeOf(value) === "object";
+    };
+    helpers3.JSONparse = function(str, options) {
+      return JSON.parse(str);
+    };
+    helpers3.JSONstringify = function(obj, indent) {
+      if (!utils.isNumber(indent)) {
+        indent = 0;
+      }
+      return JSON.stringify(obj, null, indent);
+    };
+    helpers3.merge = function(context) {
+      var args = [].slice.call(arguments);
+      var opts = {};
+      if (util.isOptions(args[args.length - 1])) {
+        opts = args.pop().hash;
+        args.push(opts);
+      }
+      return Object.assign.apply(null, args);
+    };
+    helpers3.parseJSON = helpers3.JSONparse;
+    helpers3.pick = function(props, context, options) {
+      var keys = array.arrayify(props);
+      var len = keys.length, i = -1;
+      var result = {};
+      while (++i < len) {
+        result = helpers3.extend({}, result, utils.getObject(context, keys[i]));
+      }
+      if (options.fn) {
+        if (Object.keys(result).length) {
+          return options.fn(result);
+        }
+        return options.inverse(context);
+      }
+      return result;
+    };
+    helpers3.stringify = helpers3.JSONstringify;
+  }
+});
+
+// helpers/lib/collection.js
+var require_collection = __commonJS({
+  "helpers/lib/collection.js"(exports2, module2) {
+    "use strict";
+    var util = require("handlebars-utils");
+    var object = require_object();
+    var array = require_array();
+    var forEach = array.forEach;
+    var forOwn = object.forOwn;
+    var helpers3 = module2.exports;
+    helpers3.isEmpty = function(collection, options) {
+      if (!util.isOptions(options)) {
+        options = collection;
+        return util.fn(true, this, options);
+      }
+      if (Array.isArray(collection) && !collection.length) {
+        return util.fn(true, this, options);
+      }
+      var keys = Object.keys(collection);
+      var isEmpty = typeof collection === "object" && !keys.length;
+      return util.value(isEmpty, this, options);
+    };
+    helpers3.iterate = function(collection, options) {
+      if (Array.isArray(collection)) {
+        return forEach.apply(null, arguments);
+      }
+      if (util.isObject(collection)) {
+        return forOwn.apply(null, arguments);
+      }
+      return options.inverse(this);
+    };
+  }
+});
+
+// helpers/lib/comparison.js
+var require_comparison = __commonJS({
+  "helpers/lib/comparison.js"(exports2, module2) {
+    "use strict";
+    var has = require("has-value");
+    var util = require("handlebars-utils");
+    var utils = require_utils2();
+    var helpers3 = module2.exports;
+    helpers3.and = function() {
+      var len = arguments.length - 1;
+      var options = arguments[len];
+      var val = true;
+      for (var i = 0; i < len; i++) {
+        if (!arguments[i]) {
+          val = false;
+          break;
+        }
+      }
+      return util.value(val, this, options);
+    };
+    helpers3.compare = function(a, operator, b, options) {
+      if (arguments.length < 4) {
+        throw new Error("handlebars Helper {{compare}} expects 4 arguments");
+      }
+      var result;
+      switch (operator) {
+        case "==":
+          result = a == b;
+          break;
+        case "===":
+          result = a === b;
+          break;
+        case "!=":
+          result = a != b;
+          break;
+        case "!==":
+          result = a !== b;
+          break;
+        case "<":
+          result = a < b;
+          break;
+        case ">":
+          result = a > b;
+          break;
+        case "<=":
+          result = a <= b;
+          break;
+        case ">=":
+          result = a >= b;
+          break;
+        case "typeof":
+          result = typeof a === b;
+          break;
+        default: {
+          throw new Error("helper {{compare}}: invalid operator: `" + operator + "`");
+        }
+      }
+      return util.value(result, this, options);
+    };
+    helpers3.contains = function(collection, value, startIndex, options) {
+      if (typeof startIndex === "object") {
+        options = startIndex;
+        startIndex = void 0;
+      }
+      var val = utils.contains(collection, value, startIndex);
+      return util.value(val, this, options);
+    };
+    helpers3.default = function() {
+      for (var i = 0; i < arguments.length - 1; i++) {
+        if (arguments[i] != null) return arguments[i];
+      }
+      return "";
+    };
+    helpers3.eq = function(a, b, options) {
+      if (arguments.length === 2) {
+        options = b;
+        b = options.hash.compare;
+      }
+      return util.value(a === b, this, options);
+    };
+    helpers3.gt = function(a, b, options) {
+      if (arguments.length === 2) {
+        options = b;
+        b = options.hash.compare;
+      }
+      return util.value(a > b, this, options);
+    };
+    helpers3.gte = function(a, b, options) {
+      if (arguments.length === 2) {
+        options = b;
+        b = options.hash.compare;
+      }
+      return util.value(a >= b, this, options);
+    };
+    helpers3.has = function(value, pattern, options) {
+      if (util.isOptions(value)) {
+        options = value;
+        pattern = null;
+        value = null;
+      }
+      if (util.isOptions(pattern)) {
+        options = pattern;
+        pattern = null;
+      }
+      if (value === null) {
+        return util.value(false, this, options);
+      }
+      if (arguments.length === 2) {
+        return util.value(has(this, value), this, options);
+      }
+      if ((Array.isArray(value) || util.isString(value)) && util.isString(pattern)) {
+        if (value.indexOf(pattern) > -1) {
+          return util.fn(true, this, options);
+        }
+      }
+      if (util.isObject(value) && util.isString(pattern) && pattern in value) {
+        return util.fn(true, this, options);
+      }
+      return util.inverse(false, this, options);
+    };
+    helpers3.isFalsey = function(val, options) {
+      return util.value(utils.falsey(val), this, options);
+    };
+    helpers3.isTruthy = function(val, options) {
+      return util.value(!utils.falsey(val), this, options);
+    };
+    helpers3.ifEven = function(num, options) {
+      return util.value(utils.isEven(num), this, options);
+    };
+    helpers3.ifNth = function(a, b, options) {
+      var isNth = utils.isNumber(a) && utils.isNumber(b) && b % a === 0;
+      return util.value(isNth, this, options);
+    };
+    helpers3.ifOdd = function(val, options) {
+      return util.value(!utils.isEven(val), this, options);
+    };
+    helpers3.is = function(a, b, options) {
+      if (arguments.length === 2) {
+        options = b;
+        b = options.hash.compare;
+      }
+      return util.value(a == b, this, options);
+    };
+    helpers3.isnt = function(a, b, options) {
+      if (arguments.length === 2) {
+        options = b;
+        b = options.hash.compare;
+      }
+      return util.value(a != b, this, options);
+    };
+    helpers3.lt = function(a, b, options) {
+      if (arguments.length === 2) {
+        options = b;
+        b = options.hash.compare;
+      }
+      return util.value(a < b, this, options);
+    };
+    helpers3.lte = function(a, b, options) {
+      if (arguments.length === 2) {
+        options = b;
+        b = options.hash.compare;
+      }
+      return util.value(a <= b, this, options);
+    };
+    helpers3.neither = function(a, b, options) {
+      return util.value(!a && !b, this, options);
+    };
+    helpers3.not = function(val, options) {
+      return util.value(!val, this, options);
+    };
+    helpers3.or = function() {
+      var len = arguments.length - 1;
+      var options = arguments[len];
+      var val = false;
+      for (var i = 0; i < len; i++) {
+        if (arguments[i]) {
+          val = true;
+          break;
+        }
+      }
+      return util.value(val, this, options);
+    };
+    helpers3.unlessEq = function(a, b, options) {
+      if (util.isOptions(b)) {
+        options = b;
+        b = options.hash.compare;
+      }
+      return util.value(a !== b, this, options);
+    };
+    helpers3.unlessGt = function(a, b, options) {
+      if (util.isOptions(b)) {
+        options = b;
+        b = options.hash.compare;
+      }
+      return util.value(a <= b, this, options);
+    };
+    helpers3.unlessLt = function(a, b, options) {
+      if (util.isOptions(b)) {
+        options = b;
+        b = options.hash.compare;
+      }
+      return util.value(a >= b, this, options);
+    };
+    helpers3.unlessGteq = function(a, b, options) {
+      if (util.isOptions(b)) {
+        options = b;
+        b = options.hash.compare;
+      }
+      return util.value(a < b, this, options);
+    };
+    helpers3.unlessLteq = function(a, b, options) {
+      if (util.isOptions(b)) {
+        options = b;
+        b = options.hash.compare;
+      }
+      return util.value(a > b, this, options);
+    };
+  }
+});
+
+// helpers/lib/date.js
+var require_date = __commonJS({
+  "helpers/lib/date.js"(exports2, module2) {
+    "use strict";
+    var helpers3 = module2.exports;
+    helpers3.year = require("year");
+    helpers3.moment = helpers3.date = require("helper-date");
+  }
+});
+
+// helpers/lib/number.js
+var require_number = __commonJS({
+  "helpers/lib/number.js"(exports2, module2) {
+    "use strict";
+    var isNumber = require("is-number");
+    var util = require("handlebars-utils");
+    var utils = require_utils2();
+    var helpers3 = module2.exports;
+    helpers3.bytes = function(number, precision, options) {
+      if (number == null) return "0 B";
+      if (!utils.isNumber(number)) {
+        number = number.length;
+        if (!number) return "0 B";
+      }
+      if (!utils.isNumber(precision)) {
+        precision = 2;
+      }
+      var abbr = ["B", "kB", "MB", "GB", "TB", "PB", "EB", "ZB", "YB"];
+      precision = Math.pow(10, precision);
+      number = Number(number);
+      var len = abbr.length - 1;
+      while (len-- >= 0) {
+        var size = Math.pow(10, len * 3);
+        if (size <= number + 1) {
+          number = Math.round(number * precision / size) / precision;
+          number += " " + abbr[len];
+          break;
+        }
+      }
+      return number;
+    };
+    helpers3.addCommas = function(num) {
+      return num.toString().replace(/(\d)(?=(\d\d\d)+(?!\d))/g, "$1,");
+    };
+    helpers3.phoneNumber = function(num) {
+      num = num.toString();
+      return "(" + num.substr(0, 3) + ") " + num.substr(3, 3) + "-" + num.substr(6, 4);
+    };
+    helpers3.toAbbr = function(number, precision) {
+      if (!utils.isNumber(number)) {
+        number = 0;
+      }
+      if (util.isUndefined(precision)) {
+        precision = 2;
+      }
+      number = Number(number);
+      precision = Math.pow(10, precision);
+      var abbr = ["k", "m", "b", "t", "q"];
+      var len = abbr.length - 1;
+      while (len >= 0) {
+        var size = Math.pow(10, (len + 1) * 3);
+        if (size <= number + 1) {
+          number = Math.round(number * precision / size) / precision;
+          number += abbr[len];
+          break;
+        }
+        len--;
+      }
+      return number;
+    };
+    helpers3.toExponential = function(number, digits) {
+      if (!utils.isNumber(number)) {
+        number = 0;
+      }
+      if (util.isUndefined(digits)) {
+        digits = 0;
+      }
+      return Number(number).toExponential(digits);
+    };
+    helpers3.toFixed = function(number, digits) {
+      if (!utils.isNumber(number)) {
+        number = 0;
+      }
+      if (!isNumber(digits)) {
+        digits = 0;
+      }
+      return Number(number).toFixed(digits);
+    };
+    helpers3.toFloat = function(number) {
+      return parseFloat(number);
+    };
+    helpers3.toInt = function(number) {
+      return parseInt(number, 10);
+    };
+    helpers3.toPrecision = function(number, precision) {
+      if (!utils.isNumber(number)) {
+        number = 0;
+      }
+      if (!isNumber(precision)) {
+        precision = 1;
+      }
+      return Number(number).toPrecision(precision);
+    };
+  }
+});
+
+// helpers/lib/fs.js
+var require_fs = __commonJS({
+  "helpers/lib/fs.js"(exports2, module2) {
+    "use strict";
+    var fs = require("fs");
+    var path = require("path");
+    var util = require("handlebars-utils");
+    var utils = require_utils2();
+    var number = require_number();
+    var helpers3 = module2.exports;
+    helpers3.fileSize = number.bytes;
+    helpers3.read = function(filepath, options) {
+      return fs.readFileSync(filepath, "utf8");
+    };
+    helpers3.readdir = function(dir, filter) {
+      var files = fs.readdirSync(dir);
+      files = files.map(function(fp) {
+        return path.join(dir, fp);
+      });
+      if (util.isOptions(filter)) {
+        return files;
+      }
+      if (typeof filter === "function") {
+        return filter(files);
+      }
+      if (utils.typeOf(filter) === "regexp") {
+        return files.filter(function(fp) {
+          return filter.test(fp);
+        });
+      }
+      if (utils.isGlob(filter)) {
+        const isMatch = utils.mm.matcher(filter);
+        const result = [];
+        for (let i = 0; i < files.length; i++) {
+          if (isMatch(files[i])) {
+            result.push(files[i]);
+          }
+        }
+        return result;
+      }
+      if (["isFile", "isDirectory"].indexOf(filter) !== -1) {
+        return files.filter(function(fp) {
+          var stat = fs.statSync(fp);
+          return stat[filter]();
+        });
+      }
+      return files;
+    };
+  }
+});
+
+// helpers/lib/utils/html.js
+var require_html = __commonJS({
+  "helpers/lib/utils/html.js"(exports2, module2) {
+    "use strict";
+    var util = require("handlebars-utils");
+    var striptags = require("striptags");
+    var html = module2.exports;
+    html.condense = function(str) {
+      return str.replace(/(\r\n|\r|\n|\u2028|\u2029) {2,}/g, "\n");
+    };
+    html.padcomments = function(str) {
+      return str.replace(/(\s*<!--)/g, "\n$1");
+    };
+    html.parseAttributes = function parseAttributes(hash) {
+      return Object.keys(hash).map(function(key) {
+        var val = String(hash[key]).replace(/^['"]|["']$/g, "");
+        return key + '="' + val + '"';
+      }).join(" ");
+    };
+    html.sanitize = function(str) {
+      if (!util.isString(str)) return "";
+      return striptags(str).trim();
+    };
+    html.toAttributes = function toAttributes(hash) {
+      var res = "";
+      var keys = Object.keys(hash);
+      for (var i = 0; i < keys.length; i++) {
+        var val = hash[keys[i]];
+        if (val === true) {
+          res += " " + keys[i];
+        } else {
+          res += " " + keys[i] + '="' + String(val) + '"';
+        }
+      }
+      return res;
+    };
+  }
+});
+
+// helpers/lib/html.js
+var require_html2 = __commonJS({
+  "helpers/lib/html.js"(exports2, module2) {
+    "use strict";
+    var path = require("path");
+    var util = require("handlebars-utils");
+    var html = require_html();
+    var utils = require_utils2();
+    var parseAttr = html.parseAttributes;
+    var helpers3 = module2.exports;
+    helpers3.attr = function(options) {
+      var val = parseAttr(options && options.hash || {});
+      return val.trim() ? " " + val : "";
+    };
+    helpers3.css = function(list, options) {
+      if (arguments.length < 2) {
+        options = list;
+        list = [];
+      }
+      var styles = util.arrayify(list);
+      var assets = "";
+      if (this && this.options) {
+        assets = this.options.assets || "";
+      }
+      if (options.hash.href) {
+        styles = util.arrayify(options.hash.href);
+      }
+      return styles.map(function(item) {
+        var ext = path.extname(item);
+        var fp = item;
+        if (!/(^\/\/)|(:\/\/)/.test(item)) {
+          fp = path.posix.join(assets, item);
+        }
+        if (ext === ".less") {
+          return '<link type="text/css" rel="stylesheet/less" href="' + fp + '">';
+        }
+        return '<link type="text/css" rel="stylesheet" href="' + fp + '">';
+      }).join("\n");
+    };
+    helpers3.js = function(context) {
+      if (utils.typeOf(context) === "object") {
+        var attr = parseAttr(context.hash);
+        return "<script" + (attr ? " " + attr : "") + "></script>";
+      }
+      if (utils.typeOf(context) === "string") {
+        return '<script src="' + context + '"></script>';
+      }
+      context = util.arrayify(context);
+      return context.map(function(fp) {
+        return path.extname(fp) === ".coffee" ? utils.tag("script", { type: "text/coffeescript", src: fp }) : utils.tag("script", { src: fp });
+      }).join("\n");
+    };
+    helpers3.sanitize = function(str) {
+      return html.sanitize(str);
+    };
+    helpers3.ul = function(context, options) {
+      return "<ul " + parseAttr(options.hash) + ">" + context.map(function(item) {
+        if (typeof item !== "string") {
+          item = options.fn(item);
+        }
+        return "<li>" + item + "</li>";
+      }).join("\n") + "</ul>";
+    };
+    helpers3.ol = function(context, options) {
+      return "<ol " + parseAttr(options.hash) + ">" + context.map(function(item) {
+        if (typeof item !== "string") {
+          item = options.fn(item);
+        }
+        return "<li>" + item + "</li>";
+      }).join("\n") + "</ol>";
+    };
+    helpers3.thumbnailImage = function(context) {
+      var figure = "";
+      var image = "";
+      var link = context.full || false;
+      var imageAttributes = {
+        alt: context.alt,
+        src: context.thumbnail,
+        width: context.size.width,
+        height: context.size.height
+      };
+      var figureAttributes = { id: "image-" + context.id };
+      var linkAttributes = { href: link, rel: "thumbnail" };
+      if (context.classes) {
+        if (context.classes.image) {
+          imageAttributes.class = context.classes.image.join(" ");
+        }
+        if (context.classes.figure) {
+          figureAttributes.class = context.classes.figure.join(" ");
+        }
+        if (context.classes.link) {
+          linkAttributes.class = context.classes.link.join(" ");
+        }
+      }
+      figure += "<figure " + parseAttr(figureAttributes) + ">\n";
+      image += "<img " + parseAttr(imageAttributes) + ">\n";
+      if (link) {
+        figure += "<a " + parseAttr(linkAttributes) + ">\n" + image + "</a>\n";
+      } else {
+        figure += image;
+      }
+      if (context.caption) {
+        figure += "<figcaption>" + context.caption + "</figcaption>\n";
+      }
+      figure += "</figure>";
+      return figure;
+    };
+  }
+});
+
+// helpers/lib/i18n.js
+var require_i18n = __commonJS({
+  "helpers/lib/i18n.js"(exports2, module2) {
+    "use strict";
+    var util = require("handlebars-utils");
+    var utils = require_utils2();
+    var helpers3 = module2.exports;
+    helpers3.i18n = function(prop, locals, options) {
+      if (util.isOptions(locals)) {
+        options = locals;
+        locals = {};
+      }
+      if (!util.isString(prop)) {
+        throw new Error('{{i18n}} helper expected "key" to be a string');
+      }
+      var opts = util.options(this, locals, options);
+      var context = Object.assign({}, this, opts);
+      var lang = context.language || context.lang;
+      if (!util.isString(lang)) {
+        throw new TypeError('{{i18n}} helper expected "language" to be a string');
+      }
+      var cache = context[lang];
+      if (typeof cache === "undefined") {
+        throw new Error('{{i18n}} helper cannot find language "' + lang + '"');
+      }
+      var result = utils.get(cache, prop);
+      if (typeof result === "undefined") {
+        throw new Error('{{i18n}} helper cannot find property "' + prop + '" for language "' + lang + '"');
+      }
+      return result;
+    };
+  }
+});
+
+// helpers/lib/inflection.js
+var require_inflection = __commonJS({
+  "helpers/lib/inflection.js"(exports2, module2) {
+    "use strict";
+    var util = require("handlebars-utils");
+    var helpers3 = module2.exports;
+    helpers3.inflect = function(count, singular, plural, includeCount) {
+      var word = count > 1 || count === 0 ? plural : singular;
+      if (includeCount === true) {
+        return String(count) + " " + word;
+      } else {
+        return word;
+      }
+    };
+    helpers3.ordinalize = function(val) {
+      var num = Math.abs(Math.round(val));
+      var str = String(val);
+      var res = num % 100;
+      if (util.indexOf([11, 12, 13], res) >= 0) {
+        return str + "th";
+      }
+      switch (num % 10) {
+        case 1:
+          return str + "st";
+        case 2:
+          return str + "nd";
+        case 3:
+          return str + "rd";
+        default: {
+          return str + "th";
+        }
+      }
+    };
+  }
+});
+
+// helpers/lib/logging.js
+var require_logging = __commonJS({
+  "helpers/lib/logging.js"(exports2, module2) {
+    "use strict";
+    module2.exports = require("logging-helpers");
+  }
+});
+
+// helpers/lib/md.js
+var require_md = __commonJS({
+  "helpers/lib/md.js"(exports2, module2) {
+    "use strict";
+    var fs = require("fs");
+    var path = require("path");
+    var { Remarkable } = require("remarkable");
+    var extend = require("extend-shallow");
+    var exists = require("fs-exists-sync");
+    var ent = require("ent");
+    var helper = module2.exports = function(name, options, cb) {
+      if (typeof options === "function") {
+        cb = options;
+        options = {};
+      }
+      if (typeof cb !== "function") {
+        return helper.sync.apply(this, arguments);
+      }
+      if (typeof this === "undefined" || typeof this.app === "undefined") {
+        throw new Error("md async helper expects `app` to be exposed on the context");
+      }
+      var opts = extend({ cwd: process.cwd() }, this.options, options);
+      opts = extend({}, opts, opts.hash);
+      var md = markdown(opts);
+      var filepath = path.resolve(opts.cwd, name);
+      var view;
+      var str = "";
+      if (exists(filepath)) {
+        this.app.create("mdfiles");
+        str = fs.readFileSync(filepath, "utf8");
+        view = this.app.mdfile(filepath, { path: filepath, content: str });
+      } else {
+        view = this.app.find(name);
+      }
+      if (typeof view === "undefined") {
+        cb(null, "");
+        return;
+      }
+      view.content = ent.decode(md.render(view.content));
+      this.app.render(view, this.context, function(err, res) {
+        if (err) return cb(err);
+        cb(null, res.content);
+      });
+    };
+    helper.sync = function(name, options) {
+      var ctx = this || {};
+      var app = ctx.app || {};
+      var opts = extend({ cwd: process.cwd() }, ctx.options, options);
+      opts = extend({}, opts, opts.hash);
+      var md = markdown(opts);
+      var filepath = path.resolve(opts.cwd, name);
+      var view;
+      var html = "";
+      var str = "";
+      if (exists(filepath)) {
+        str = fs.readFileSync(filepath, "utf8");
+        html = ent.decode(md.render(str));
+      } else if (app.views) {
+        view = app.find(name);
+        if (view) {
+          html = view.content = ent.decode(md.render(view.content));
+        }
+      }
+      if (view && typeof view.compile === "function") {
+        view.compile(opts);
+        var data = ctx.cache ? ctx.cache.data : {};
+        ctx = extend({}, data, view.data);
+        return view.fn(ctx);
+      }
+      if (typeof this.compile === "function") {
+        var fn = this.compile(html);
+        return fn(this);
+      }
+      return html;
+    };
+    function markdown(options) {
+      let optsConfig = options || {};
+      optsConfig.breaks = true;
+      optsConfig.html = true;
+      optsConfig.langPrefix = "lang-";
+      optsConfig.typographer = false;
+      optsConfig.xhtmlOut = false;
+      const md = new Remarkable(optsConfig);
+      return md;
+    }
+  }
+});
+
+// helpers/lib/markdown.js
+var require_markdown = __commonJS({
+  "helpers/lib/markdown.js"(exports2, module2) {
+    "use strict";
+    var hljs = require("highlight.js");
+    var utils = require("handlebars-utils");
+    var { Remarkable } = require("remarkable");
+    var helpers3 = module2.exports;
+    var markdown;
+    Object.defineProperty(helpers3, "markdown", {
+      configurable: true,
+      enumerable: true,
+      set: function(val) {
+        markdown = val;
+      },
+      get: function() {
+        return markdown || (markdown = this.helpersForMarkdown());
+      }
+    });
+    helpers3.md = require_md();
+    helpers3.helpersForMarkdown = function(config) {
+      const defaults = { html: true, breaks: true, highlight: helpers3.highlightFormMarkdown };
+      if (typeof config === "string" || utils.isOptions(config)) {
+        return markdown2.apply(defaults, arguments);
+      }
+      function markdown2(str, locals, options) {
+        if (typeof str !== "string") {
+          options = locals;
+          locals = str;
+          str = true;
+        }
+        if (utils.isOptions(locals)) {
+          options = locals;
+          locals = {};
+        }
+        const ctx = utils.context(this, locals, options);
+        let opts = utils.options(this, locals, options);
+        opts = Object.assign({}, defaults, config, opts);
+        if (opts.hasOwnProperty("lang")) {
+          opts.langPrefix = opts.lang;
+        }
+        const md = new Remarkable(opts);
+        const val = utils.value(str, ctx, options);
+        return md.render(val);
+      }
+      return markdown2;
+    };
+    helpers3.highlightFormMarkdown = function(code, lang) {
+      if (lang) {
+        return hljs.highlight(code, { language: lang }).value;
+      }
+      return hljs.highlightAuto(code).value;
+    };
+  }
+});
+
+// helpers/lib/match.js
+var require_match = __commonJS({
+  "helpers/lib/match.js"(exports2, module2) {
+    "use strict";
+    var util = require("handlebars-utils");
+    var utils = require_utils2();
+    var helpers3 = module2.exports;
+    helpers3.match = function(files, patterns, locals, options) {
+      var opts = util.options(this, locals, options);
+      if (typeof patterns === "string") {
+        patterns = patterns.split(/, */);
+      }
+      return utils.mm(files, patterns, opts);
+    };
+    helpers3.isMatch = function(files, patterns, locals, options) {
+      var opts = util.options(this, locals, options);
+      return utils.mm.isMatch(files, patterns, opts);
+    };
+    helpers3.mm = function() {
+      console.log("the {{mm}} helper is depcrecated and will be removed");
+      console.log("in handlebars-helpers v1.0.0, please use the {{match}}");
+      console.log("helper instead.");
+      return helpers3.match.apply(this, arguments);
+    };
+  }
+});
+
+// helpers/lib/math.js
+var require_math = __commonJS({
+  "helpers/lib/math.js"(exports2, module2) {
+    "use strict";
+    var isNumber = require("is-number");
+    var utils = require_utils2();
+    var helpers3 = module2.exports;
+    helpers3.abs = function(num) {
+      if (!isNumber(num)) {
+        throw new TypeError("expected a number");
+      }
+      return Math.abs(num);
+    };
+    helpers3.add = function(a, b) {
+      if (isNumber(a) && isNumber(b)) {
+        return Number(a) + Number(b);
+      }
+      return "";
+    };
+    helpers3.avg = function() {
+      var args = [].concat.apply([], arguments);
+      args.pop();
+      return helpers3.sum(args) / args.length;
+    };
+    helpers3.ceil = function(num) {
+      if (!isNumber(num)) {
+        throw new TypeError("expected a number");
+      }
+      return Math.ceil(num);
+    };
+    helpers3.divide = function(a, b) {
+      if (!isNumber(a)) {
+        throw new TypeError("expected the first argument to be a number");
+      }
+      if (!isNumber(b)) {
+        throw new TypeError("expected the second argument to be a number");
+      }
+      return Number(a) / Number(b);
+    };
+    helpers3.floor = function(num) {
+      if (!isNumber(num)) {
+        throw new TypeError("expected a number");
+      }
+      return Math.floor(num);
+    };
+    helpers3.minus = function(a, b) {
+      if (!isNumber(a)) {
+        throw new TypeError("expected the first argument to be a number");
+      }
+      if (!isNumber(b)) {
+        throw new TypeError("expected the second argument to be a number");
+      }
+      return Number(a) - Number(b);
+    };
+    helpers3.modulo = function(a, b) {
+      if (!isNumber(a)) {
+        throw new TypeError("expected the first argument to be a number");
+      }
+      if (!isNumber(b)) {
+        throw new TypeError("expected the second argument to be a number");
+      }
+      return Number(a) % Number(b);
+    };
+    helpers3.multiply = function(a, b) {
+      if (!isNumber(a)) {
+        throw new TypeError("expected the first argument to be a number");
+      }
+      if (!isNumber(b)) {
+        throw new TypeError("expected the second argument to be a number");
+      }
+      return Number(a) * Number(b);
+    };
+    helpers3.plus = function(a, b) {
+      if (!isNumber(a)) {
+        throw new TypeError("expected the first argument to be a number");
+      }
+      if (!isNumber(b)) {
+        throw new TypeError("expected the second argument to be a number");
+      }
+      return Number(a) + Number(b);
+    };
+    helpers3.random = function(min, max) {
+      if (!isNumber(min)) {
+        throw new TypeError("expected minimum to be a number");
+      }
+      if (!isNumber(max)) {
+        throw new TypeError("expected maximum to be a number");
+      }
+      return utils.random(min, max);
+    };
+    helpers3.remainder = function(a, b) {
+      return a % b;
+    };
+    helpers3.round = function(num) {
+      if (!isNumber(num)) {
+        throw new TypeError("expected a number");
+      }
+      return Math.round(num);
+    };
+    helpers3.subtract = function(a, b) {
+      if (!isNumber(a)) {
+        throw new TypeError("expected the first argument to be a number");
+      }
+      if (!isNumber(b)) {
+        throw new TypeError("expected the second argument to be a number");
+      }
+      return Number(a) - Number(b);
+    };
+    helpers3.sum = function() {
+      var args = [].concat.apply([], arguments);
+      var len = args.length;
+      var sum = 0;
+      while (len--) {
+        if (utils.isNumber(args[len])) {
+          sum += Number(args[len]);
+        }
+      }
+      return sum;
+    };
+    helpers3.times = function() {
+      return helpers3.multiply.apply(this, arguments);
+    };
+  }
+});
+
+// helpers/lib/misc.js
+var require_misc = __commonJS({
+  "helpers/lib/misc.js"(exports2, module2) {
+    "use strict";
+    var util = require("handlebars-utils");
+    var utils = require_utils2();
+    var helpers3 = module2.exports;
+    helpers3.frame = require("handlebars-helper-create-frame");
+    helpers3.option = function(prop, locals, options) {
+      return utils.get(util.options(this, locals, options), prop);
+    };
+    helpers3.noop = function(options) {
+      return options.fn(this);
+    };
+    helpers3.typeOf = require("kind-of");
+    helpers3.withHash = function(options) {
+      if (options.hash && Object.keys(options.hash).length) {
+        return options.fn(options.hash);
+      } else {
+        return options.inverse(this);
+      }
+    };
+  }
+});
+
+// helpers/lib/path.js
+var require_path = __commonJS({
+  "helpers/lib/path.js"(exports2, module2) {
+    "use strict";
+    var util = require("handlebars-utils");
+    var path = require("path");
+    var utils = require_utils2();
+    var helpers3 = module2.exports;
+    utils.expectedType = (variableName, expectedType, variableValue) => {
+      const actualType = Object.prototype.toString.call(variableValue).slice(8, -1).toLowerCase();
+      if (actualType !== expectedType) {
+        throw new TypeError(`Expected ${variableName} to be of type ${expectedType}, but got ${actualType}`);
+      }
+    };
+    helpers3.absolute = function(filepath, options) {
+      options = options || { data: {} };
+      var context = util.options(this, options);
+      var ctx = Object.assign({}, options.data.root, context);
+      var cwd = ctx.cwd || process.cwd();
+      return path.resolve(cwd, filepath);
+    };
+    helpers3.dirname = function(filepath, options) {
+      if (typeof filepath !== "string") {
+        throw new TypeError(utils.expectedType("filepath", "string", filepath));
+      }
+      return path.dirname(filepath);
+    };
+    helpers3.relative = function(a, b) {
+      if (typeof a !== "string") {
+        throw new TypeError(utils.expectedType("first path", "string", a));
+      }
+      if (typeof b !== "string") {
+        throw new TypeError(utils.expectedType("second path", "string", b));
+      }
+      return utils.relative(a, b);
+    };
+    helpers3.basename = function(filepath) {
+      if (typeof filepath !== "string") {
+        throw new TypeError(utils.expectedType("filepath", "string", filepath));
+      }
+      return path.basename(filepath);
+    };
+    helpers3.stem = function(filepath) {
+      if (typeof filepath !== "string") {
+        throw new TypeError(utils.expectedType("filepath", "string", filepath));
+      }
+      return path.basename(filepath, path.extname(filepath));
+    };
+    helpers3.extname = function(filepath) {
+      if (typeof filepath !== "string") {
+        throw new TypeError(utils.expectedType("filepath", "string", filepath));
+      }
+      return path.extname(filepath);
+    };
+    helpers3.resolve = function(filepath) {
+      var args = [].slice.call(arguments);
+      var opts = util.options(this, args.pop());
+      var cwd = path.resolve(opts.cwd || process.cwd());
+      args.unshift(cwd);
+      return path.resolve.apply(path, args);
+    };
+    helpers3.segments = function(filepath, a, b) {
+      if (typeof filepath !== "string") {
+        throw new TypeError(utils.expectedType("filepath", "string", filepath));
+      }
+      var segments = filepath.split(/[\\\/]+/);
+      return segments.slice(a, b).join("/");
+    };
+  }
+});
+
+// helpers/lib/regex.js
+var require_regex = __commonJS({
+  "helpers/lib/regex.js"(exports2, module2) {
+    "use strict";
+    var util = require("handlebars-utils");
+    var utils = require_utils2();
+    var helpers3 = module2.exports;
+    helpers3.toRegex = function(str, locals, options) {
+      var opts = util.options({}, locals, options);
+      return new RegExp(str, opts.flags);
+    };
+    helpers3.test = function(str, regex) {
+      if (!util.isString(str)) {
+        return false;
+      }
+      if (utils.typeOf(regex) !== "regexp") {
+        throw new TypeError("expected a regular expression");
+      }
+      return regex.test(str);
+    };
+  }
+});
+
+// helpers/lib/string.js
+var require_string = __commonJS({
+  "helpers/lib/string.js"(exports2, module2) {
+    "use strict";
+    var isNumber = require("is-number");
+    var util = require("handlebars-utils");
+    var utils = require_utils2();
+    var helpers3 = module2.exports;
+    helpers3.append = function(str, suffix) {
+      if (typeof str === "string" && typeof suffix === "string") {
+        return str + suffix;
+      }
+      return str;
+    };
+    helpers3.camelcase = function(str) {
+      if (!util.isString(str)) return "";
+      return utils.changecase(str, function(ch) {
+        return ch.toUpperCase();
+      });
+    };
+    helpers3.capitalize = function(str) {
+      if (!util.isString(str)) return "";
+      return str.charAt(0).toUpperCase() + str.slice(1);
+    };
+    helpers3.capitalizeAll = function(str) {
+      if (!util.isString(str)) return "";
+      if (util.isString(str)) {
+        return str.replace(/\w\S*/g, function(word) {
+          return helpers3.capitalize(word);
+        });
+      }
+    };
+    helpers3.center = function(str, spaces) {
+      if (!util.isString(str)) return "";
+      var space = "";
+      var i = 0;
+      while (i < spaces) {
+        space += "&nbsp;";
+        i++;
+      }
+      return space + str + space;
+    };
+    helpers3.chop = function(str) {
+      if (!util.isString(str)) return "";
+      return utils.chop(str);
+    };
+    helpers3.dashcase = function(str) {
+      if (!util.isString(str)) return "";
+      return utils.changecase(str, function(ch) {
+        return "-" + ch;
+      });
+    };
+    helpers3.dotcase = function(str) {
+      if (!util.isString(str)) return "";
+      return utils.changecase(str, function(ch) {
+        return "." + ch;
+      });
+    };
+    helpers3.downcase = function() {
+      return helpers3.lowercase.apply(this, arguments);
+    };
+    helpers3.ellipsis = function(str, limit) {
+      if (util.isString(str)) {
+        if (str.length <= limit) {
+          return str;
+        }
+        return helpers3.truncate(str, limit) + "\u2026";
+      }
+    };
+    helpers3.hyphenate = function(str) {
+      if (!util.isString(str)) return "";
+      return str.split(" ").join("-");
+    };
+    helpers3.isString = function(value) {
+      return typeof value === "string";
+    };
+    helpers3.lowercase = function(str) {
+      if (util.isObject(str) && str.fn) {
+        return str.fn(this).toLowerCase();
+      }
+      if (!util.isString(str)) return "";
+      return str.toLowerCase();
+    };
+    helpers3.occurrences = function(str, substring) {
+      if (!util.isString(str)) return "";
+      var len = substring.length;
+      var pos = 0;
+      var n = 0;
+      while ((pos = str.indexOf(substring, pos)) > -1) {
+        n++;
+        pos += len;
+      }
+      return n;
+    };
+    helpers3.pascalcase = function(str) {
+      if (!util.isString(str)) return "";
+      str = utils.changecase(str, function(ch) {
+        return ch.toUpperCase();
+      });
+      return str.charAt(0).toUpperCase() + str.slice(1);
+    };
+    helpers3.pathcase = function(str) {
+      if (!util.isString(str)) return "";
+      return utils.changecase(str, function(ch) {
+        return "/" + ch;
+      });
+    };
+    helpers3.plusify = function(str, ch) {
+      if (!util.isString(str)) return "";
+      if (!util.isString(ch)) ch = " ";
+      return str.split(ch).join("+");
+    };
+    helpers3.prepend = function(str, prefix) {
+      return typeof str === "string" && typeof prefix === "string" ? prefix + str : str;
+    };
+    helpers3.raw = function(options) {
+      var str = options.fn();
+      var opts = util.options(this, options);
+      if (opts.escape !== false) {
+        var idx = 0;
+        while ((idx = str.indexOf("{{", idx)) !== -1) {
+          if (str[idx - 1] !== "\\") {
+            str = str.slice(0, idx) + "\\" + str.slice(idx);
+          }
+          idx += 3;
+        }
+      }
+      return str;
+    };
+    helpers3.remove = function(str, ch) {
+      if (!util.isString(str)) return "";
+      if (!util.isString(ch)) return str;
+      return str.split(ch).join("");
+    };
+    helpers3.removeFirst = function(str, ch) {
+      if (!util.isString(str)) return "";
+      if (!util.isString(ch)) return str;
+      return str.replace(ch, "");
+    };
+    helpers3.replace = function(str, a, b) {
+      if (!util.isString(str)) return "";
+      if (!util.isString(a)) return str;
+      if (!util.isString(b)) b = "";
+      return str.split(a).join(b);
+    };
+    helpers3.replaceFirst = function(str, a, b) {
+      if (!util.isString(str)) return "";
+      if (!util.isString(a)) return str;
+      if (!util.isString(b)) b = "";
+      return str.replace(a, b);
+    };
+    helpers3.reverse = function(str) {
+      if (!util.isString(str)) return "";
+      return str.split("").reverse().join("");
+    };
+    helpers3.sentence = function(str) {
+      if (!util.isString(str)) return "";
+      return str.replace(/((?:\S[^\.\?\!]*)[\.\?\!]*)/g, function(txt) {
+        return txt.charAt(0).toUpperCase() + txt.substr(1).toLowerCase();
+      });
+    };
+    helpers3.snakecase = function(str) {
+      if (!util.isString(str)) return "";
+      return utils.changecase(str, function(ch) {
+        return "_" + ch;
+      });
+    };
+    helpers3.split = function(str, ch) {
+      if (!util.isString(str)) return "";
+      if (!util.isString(ch)) ch = ",";
+      return str.split(ch);
+    };
+    helpers3.startsWith = function(prefix, str, options) {
+      var args = [].slice.call(arguments);
+      options = args.pop();
+      if (util.isString(str) && str.indexOf(prefix) === 0) {
+        return options.fn(this);
+      }
+      if (typeof options.inverse === "function") {
+        return options.inverse(this);
+      }
+      return "";
+    };
+    helpers3.titleize = function(str) {
+      if (!util.isString(str)) return "";
+      var title = str.replace(/[- _]+/g, " ");
+      var words = title.split(" ");
+      var len = words.length;
+      var res = [];
+      var i = 0;
+      while (len--) {
+        var word = words[i++];
+        res.push(exports2.capitalize(word));
+      }
+      return res.join(" ");
+    };
+    helpers3.trim = function(str) {
+      return typeof str === "string" ? str.trim() : "";
+    };
+    helpers3.trimLeft = function(str) {
+      if (util.isString(str)) {
+        return str.replace(/^\s+/, "");
+      }
+    };
+    helpers3.trimRight = function(str) {
+      if (util.isString(str)) {
+        return str.replace(/\s+$/, "");
+      }
+    };
+    helpers3.truncate = function(str, limit, suffix) {
+      if (util.isString(str)) {
+        if (typeof suffix !== "string") {
+          suffix = "";
+        }
+        if (str.length > limit) {
+          return str.slice(0, limit - suffix.length) + suffix;
+        }
+        return str;
+      }
+    };
+    helpers3.truncateWords = function(str, count, suffix) {
+      if (util.isString(str) && isNumber(count)) {
+        if (typeof suffix !== "string") {
+          suffix = "...";
+        }
+        var num = Number(count);
+        var arr = str.split(" ");
+        if (num < arr.length) {
+          arr = arr.slice(0, num);
+        }
+        var val = arr.join(" ").trim();
+        return val + suffix;
+      }
+    };
+    helpers3.upcase = function() {
+      return helpers3.uppercase.apply(this, arguments);
+    };
+    helpers3.uppercase = function(str) {
+      if (util.isObject(str) && str.fn) {
+        return str.fn(this).toUpperCase();
+      }
+      if (!util.isString(str)) return "";
+      return str.toUpperCase();
+    };
+  }
+});
+
+// helpers/lib/url.js
+var require_url = __commonJS({
+  "helpers/lib/url.js"(exports2, module2) {
+    "use strict";
+    var url = require("url");
+    var util = require("handlebars-utils");
+    var querystring = require("querystring");
+    var helpers3 = module2.exports;
+    helpers3.encodeURI = function(str) {
+      if (util.isString(str)) {
+        return encodeURIComponent(str);
+      }
+    };
+    helpers3.escape = function(str) {
+      if (util.isString(str)) {
+        return querystring.escape(str);
+      }
+    };
+    helpers3.decodeURI = function(str) {
+      if (util.isString(str)) {
+        return decodeURIComponent(str);
+      }
+    };
+    helpers3.url_encode = function() {
+      return helpers3.encodeURI.apply(this, arguments);
+    };
+    helpers3.url_decode = function(val) {
+      return helpers3.decodeURI.apply(this, arguments);
+    };
+    helpers3.urlResolve = function(base, href) {
+      return url.resolve(base, href);
+    };
+    helpers3.urlParse = function(str) {
+      return url.parse(str);
+    };
+    helpers3.stripQuerystring = function(str) {
+      if (util.isString(str)) {
+        return str.split("?")[0];
+      }
+    };
+    helpers3.stripProtocol = function(str) {
+      if (util.isString(str)) {
+        var parsed = url.parse(str);
+        parsed.protocol = "";
+        return parsed.format();
+      }
+    };
+  }
+});
+
+// helpers/lib/index.js
+var require_lib = __commonJS({
+  "helpers/lib/index.js"(exports2, module2) {
+    "use strict";
+    module2.exports = {
+      array: require_array(),
+      code: require_code(),
+      collection: require_collection(),
+      comparison: require_comparison(),
+      date: require_date(),
+      fs: require_fs(),
+      html: require_html2(),
+      i18n: require_i18n(),
+      inflection: require_inflection(),
+      logging: require_logging(),
+      markdown: require_markdown(),
+      match: require_match(),
+      math: require_math(),
+      misc: require_misc(),
+      number: require_number(),
+      object: require_object(),
+      path: require_path(),
+      regex: require_regex(),
+      string: require_string(),
+      url: require_url()
+    };
+  }
+});
+
+// helpers/helpers.js
+var require_helpers = __commonJS({
+  "helpers/helpers.js"(exports2, module2) {
+    "use strict";
+    var forIn = require("for-in");
+    var define = require("define-property");
+    var lib = require_lib();
+    module2.exports = function helpers3(groups, options) {
+      if (typeof groups === "string") {
+        groups = [groups];
+      } else if (!Array.isArray(groups)) {
+        options = groups;
+        groups = null;
+      }
+      options = options || {};
+      var hbs = options.handlebars || options.hbs || require("handlebars");
+      define(module2.exports, "handlebars", hbs);
+      if (groups) {
+        groups.forEach(function(key) {
+          hbs.registerHelper(lib[key]);
+        });
+      } else {
+        forIn(lib, function(group, key) {
+          hbs.registerHelper(group);
+        });
+      }
+      return hbs.helpers;
+    };
+    forIn(lib, function(group, key) {
+      define(module2.exports, key, function(options) {
+        options = options || {};
+        var hbs = options.handlebars || options.hbs || require("handlebars");
+        define(module2.exports, "handlebars", hbs);
+        hbs.registerHelper(group);
+        return hbs.helpers;
+      });
+    });
+    module2.exports.utils = require_utils2();
+  }
+});
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  Handlebars: () => Handlebars,
+  createHandlebars: () => createHandlebars,
+  fumanchu: () => fumanchu,
+  handlebars: () => handlebars,
+  helpers: () => helpers2
+});
+module.exports = __toCommonJS(src_exports);
+var HandlebarsLib = __toESM(require("handlebars"));
+
+// src/helpers/date.ts
+var year = () => (/* @__PURE__ */ new Date()).getFullYear().toString();
+var helpers = [
+  {
+    name: "year",
+    category: "date",
+    fn: year
+  }
+];
+
+// src/helper-registry.ts
+var HelperRegistry = class {
+  constructor() {
+    this._helpers = [];
+    this.init();
+  }
+  init() {
+    this.registerHelpers(helpers);
+  }
+  register(helper) {
+    const result = false;
+    if (!this.has(helper.name)) {
+      this._helpers.push(helper);
+    }
+    return result;
+  }
+  registerHelpers(helpers3) {
+    for (const helper of helpers3) {
+      this.register(helper);
+    }
+  }
+  has(name) {
+    return this._helpers.some((helper) => helper.name === name);
+  }
+  filter(filter) {
+    return this._helpers.filter((helper) => (!filter.name || helper.name === filter.name) && (!filter.category || helper.category === filter.category) && (!filter.compatibility || helper.compatibility === filter.compatibility));
+  }
+  loadHandlebars(handlebars2) {
+    for (const helper of this._helpers) {
+      handlebars2.registerHelper(helper.name, helper.fn);
+    }
+  }
+  swapHelpers(handlebars2) {
+    for (const helper of this._helpers) {
+      handlebars2.unregisterHelper(helper.name);
+      handlebars2.registerHelper(helper.name, helper.fn);
+    }
+  }
+};
+
+// src/index.ts
+var import_helpers = __toESM(require_helpers());
+var Handlebars = HandlebarsLib;
+var handlebars = HandlebarsLib.create();
+var helpers2 = import_helpers.default;
+function createHandlebars() {
+  return __async(this, null, function* () {
+    const registry = new HelperRegistry();
+    const handlebars2 = HandlebarsLib.create();
+    const helpersFunction = yield Promise.resolve().then(() => __toESM(require_helpers()));
+    helpersFunction.default({ handlebars: handlebars2 });
+    registry.swapHelpers(handlebars2);
+    return handlebars2;
+  });
+}
+function fumanchu(options) {
+  const registry = new HelperRegistry();
+  const handlebars2 = HandlebarsLib.create();
+  registry.loadHandlebars(handlebars2);
+  return handlebars2;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Handlebars,
+  createHandlebars,
+  fumanchu,
+  handlebars,
+  helpers
+});
+/*!
+ * helper-markdown <https://github.com/jonschlinkert/helper-markdown>
+ *
+ * Copyright (c) 2014 Jon Schlinkert, contributors.
+ * Licensed under the MIT license.
+ */
+/*!
+ * handlebars-helpers <https://github.com/helpers/handlebars-helpers>
+ *
+ * Copyright (c) 2013-2017, Jon Schlinkert, Brian Woodward.
+ * Released under the MIT License.
+ */