@jaredwray/fumanchu 3.1.3 → 4.0.0

package/dist/index.js

@@ -1,2133 +1,2105 @@
-"use strict";
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getOwnPropSymbols = Object.getOwnPropertySymbols;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __propIsEnum = Object.prototype.propertyIsEnumerable;
-var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __spreadValues = (a, b) => {
-  for (var prop in b || (b = {}))
-    if (__hasOwnProp.call(b, prop))
-      __defNormalProp(a, prop, b[prop]);
-  if (__getOwnPropSymbols)
-    for (var prop of __getOwnPropSymbols(b)) {
-      if (__propIsEnum.call(b, prop))
-        __defNormalProp(a, prop, b[prop]);
-    }
-  return a;
-};
-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());
-  });
+// src/index.ts
+import * as HandlebarsLib from "handlebars";
+
+// src/helpers/array.ts
+var after = (array, n) => {
+  if (!Array.isArray(array)) return [];
+  return array.slice(n);
+};
+var before = (array, n) => {
+  if (!Array.isArray(array)) return [];
+  return array.slice(0, -n);
+};
+var arrayify = (value) => {
+  if (value == null) return [];
+  return Array.isArray(value) ? value : [value];
+};
+var first = (array, n) => {
+  if (!Array.isArray(array)) return void 0;
+  if (typeof n !== "number") {
+    return array[0];
+  }
+  return array.slice(0, n);
+};
+var last = (value, n) => {
+  if (!Array.isArray(value) && typeof value !== "string") {
+    return void 0;
+  }
+  if (typeof n !== "number") {
+    const array = value;
+    return array[array.length - 1];
+  }
+  const start = Math.abs(n);
+  if (typeof value === "string") {
+    return value.slice(-start);
+  }
+  return value.slice(-start);
+};
+var length = (value) => {
+  if (value && typeof value === "object" && !Array.isArray(value)) {
+    return Object.keys(value).length;
+  }
+  if (typeof value === "string" || Array.isArray(value)) {
+    return value.length;
+  }
+  return 0;
+};
+var join = (array, separator = ", ") => {
+  if (typeof array === "string") return array;
+  if (!Array.isArray(array)) return "";
+  return array.join(separator);
+};
+var helpers = [
+  {
+    name: "after",
+    category: "array",
+    compatibility: ["browser", "nodejs"],
+    fn: after
+  },
+  {
+    name: "before",
+    category: "array",
+    compatibility: ["browser", "nodejs"],
+    fn: before
+  },
+  {
+    name: "arrayify",
+    category: "array",
+    compatibility: ["browser", "nodejs"],
+    fn: arrayify
+  },
+  {
+    name: "first",
+    category: "array",
+    compatibility: ["browser", "nodejs"],
+    fn: first
+  },
+  {
+    name: "last",
+    category: "array",
+    compatibility: ["browser", "nodejs"],
+    fn: last
+  },
+  {
+    name: "length",
+    category: "array",
+    compatibility: ["browser", "nodejs"],
+    fn: length
+  },
+  {
+    name: "join",
+    category: "array",
+    compatibility: ["browser", "nodejs"],
+    fn: join
+  }
+];
+
+// src/helpers/code.ts
+import fs from "fs";
+import path from "path";
+import tag from "html-tag";
+import codeBlock from "to-gfm-code-block";
+var embed = (filepath, language) => {
+  let ext = typeof language === "string" ? language : path.extname(filepath).slice(1);
+  let code = fs.readFileSync(filepath, "utf8");
+  if (ext === "markdown" || ext === "md") {
+    ext = "markdown";
+    code = code.split("`").join("&#x60");
+  }
+  return `${codeBlock(code, ext).trim()}
+`;
+};
+var gist = (id) => {
+  return tag("script", { src: `https://gist.github.com/${id}.js` });
 };
+var jsfiddle = (options) => {
+  if (!options || !options.id) {
+    throw new Error("jsfiddle helper expects an `id`");
+  }
+  const {
+    id,
+    width = "100%",
+    height = "300",
+    skin = "/presentation/",
+    tabs = "result,js,html,css",
+    allowfullscreen = "allowfullscreen",
+    frameborder = "0"
+  } = options;
+  const src = `http://jsfiddle.net/${id}/embedded/${tabs}${skin}`;
+  return tag("iframe", { width, height, src, allowfullscreen, frameborder });
+};
+var helpers2 = [
+  {
+    name: "embed",
+    category: "code",
+    compatibility: ["nodejs"],
+    fn: embed
+  },
+  {
+    name: "gist",
+    category: "code",
+    compatibility: ["browser", "nodejs"],
+    fn: gist
+  },
+  {
+    name: "jsfiddle",
+    category: "code",
+    compatibility: ["browser", "nodejs"],
+    fn: jsfiddle
+  }
+];
 
-// 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;
+// src/helpers/collection.ts
+var isEmpty = (collection) => {
+  if (collection == null) return true;
+  if (Array.isArray(collection)) return collection.length === 0;
+  if (typeof collection === "object")
+    return Object.keys(collection).length === 0;
+  return false;
+};
+var iterate = (collection, fn, inverse) => {
+  if (Array.isArray(collection)) {
+    let result = "";
+    for (let i = 0; i < collection.length; i++) {
+      result += fn(collection[i], i);
     }
-    module2.exports = falsey;
+    return result;
   }
-});
+  if (collection && typeof collection === "object") {
+    let result = "";
+    for (const key of Object.keys(collection)) {
+      result += fn(collection[key], key);
+    }
+    return result;
+  }
+  return inverse ? inverse() : "";
+};
+var helpers3 = [
+  {
+    name: "isEmpty",
+    category: "collection",
+    compatibility: ["browser", "nodejs"],
+    fn: isEmpty
+  },
+  {
+    name: "iterate",
+    category: "collection",
+    compatibility: ["browser", "nodejs"],
+    fn: iterate
+  }
+];
 
-// 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;
+// src/helpers/comparison.ts
+var and = (...values) => values.every(Boolean);
+var compare = (a, operator, b) => {
+  switch (operator) {
+    case "==":
+      return a == b;
+    // eslint-disable-line eqeqeq
+    case "===":
+      return a === b;
+    case "!=":
+      return a != b;
+    // eslint-disable-line eqeqeq
+    case "!==":
+      return a !== b;
+    case "<":
+      return a < b;
+    case ">":
+      return a > b;
+    case "<=":
+      return a <= b;
+    case ">=":
+      return a >= b;
+    case "typeof":
+      return typeof a === b;
+    default:
+      throw new Error(`helper {{compare}}: invalid operator: '${operator}'`);
   }
-});
+};
+var contains = (collection, value, startIndex = 0) => {
+  if (collection == null) return false;
+  if (typeof collection === "string" || Array.isArray(collection)) {
+    return collection.indexOf(value, startIndex) > -1;
+  }
+  if (typeof collection === "object") {
+    return value in collection;
+  }
+  return false;
+};
+var defaultHelper = (...values) => {
+  for (const val of values) {
+    if (val != null) return val;
+  }
+  return "";
+};
+var eq = (a, b) => a === b;
+var gt = (a, b) => a > b;
+var gte = (a, b) => a >= b;
+var has = (value, pattern) => {
+  if (value == null || pattern == null) return false;
+  if (Array.isArray(value) || typeof value === "string") {
+    return value.indexOf(pattern) > -1;
+  }
+  if (typeof value === "object") {
+    return pattern in value;
+  }
+  return false;
+};
+var falsey = (val, keywords) => {
+  if (!val) return true;
+  const words = Array.isArray(keywords) ? keywords : keywords != null ? [keywords] : [
+    "0",
+    "false",
+    "nada",
+    "nil",
+    "nay",
+    "nah",
+    "negative",
+    "no",
+    "none",
+    "nope",
+    "nul",
+    "null",
+    "nix",
+    "nyet",
+    "uh-uh",
+    "veto",
+    "zero"
+  ];
+  const lower = typeof val === "string" ? val.toLowerCase() : null;
+  for (const word of words) {
+    if (word === val) return true;
+    if (lower != null && word === lower) return true;
+  }
+  return false;
+};
+var isFalsey = (val) => falsey(val);
+var isTruthy = (val) => !falsey(val);
+var ifEven = (num) => typeof num === "number" && num % 2 === 0;
+var ifNth = (a, b) => typeof a === "number" && typeof b === "number" && b % a === 0;
+var ifOdd = (val) => typeof val === "number" && Math.abs(val % 2) === 1;
+var is = (a, b) => a == b;
+var isnt = (a, b) => a != b;
+var lt = (a, b) => a < b;
+var lte = (a, b) => a <= b;
+var neither = (a, b) => !a && !b;
+var not = (val) => !val;
+var or = (...values) => values.some(Boolean);
+var unlessEq = (a, b) => a !== b;
+var unlessGt = (a, b) => a <= b;
+var unlessLt = (a, b) => a >= b;
+var unlessGteq = (a, b) => a < b;
+var unlessLteq = (a, b) => a > b;
+var helpers4 = [
+  {
+    name: "and",
+    category: "comparison",
+    compatibility: ["browser", "nodejs"],
+    fn: and
+  },
+  {
+    name: "compare",
+    category: "comparison",
+    compatibility: ["browser", "nodejs"],
+    fn: compare
+  },
+  {
+    name: "contains",
+    category: "comparison",
+    compatibility: ["browser", "nodejs"],
+    fn: contains
+  },
+  {
+    name: "default",
+    category: "comparison",
+    compatibility: ["browser", "nodejs"],
+    fn: defaultHelper
+  },
+  {
+    name: "eq",
+    category: "comparison",
+    compatibility: ["browser", "nodejs"],
+    fn: eq
+  },
+  {
+    name: "gt",
+    category: "comparison",
+    compatibility: ["browser", "nodejs"],
+    fn: gt
+  },
+  {
+    name: "gte",
+    category: "comparison",
+    compatibility: ["browser", "nodejs"],
+    fn: gte
+  },
+  {
+    name: "has",
+    category: "comparison",
+    compatibility: ["browser", "nodejs"],
+    fn: has
+  },
+  {
+    name: "isFalsey",
+    category: "comparison",
+    compatibility: ["browser", "nodejs"],
+    fn: isFalsey
+  },
+  {
+    name: "isTruthy",
+    category: "comparison",
+    compatibility: ["browser", "nodejs"],
+    fn: isTruthy
+  },
+  {
+    name: "ifEven",
+    category: "comparison",
+    compatibility: ["browser", "nodejs"],
+    fn: ifEven
+  },
+  {
+    name: "ifNth",
+    category: "comparison",
+    compatibility: ["browser", "nodejs"],
+    fn: ifNth
+  },
+  {
+    name: "ifOdd",
+    category: "comparison",
+    compatibility: ["browser", "nodejs"],
+    fn: ifOdd
+  },
+  {
+    name: "is",
+    category: "comparison",
+    compatibility: ["browser", "nodejs"],
+    fn: is
+  },
+  {
+    name: "isnt",
+    category: "comparison",
+    compatibility: ["browser", "nodejs"],
+    fn: isnt
+  },
+  {
+    name: "lt",
+    category: "comparison",
+    compatibility: ["browser", "nodejs"],
+    fn: lt
+  },
+  {
+    name: "lte",
+    category: "comparison",
+    compatibility: ["browser", "nodejs"],
+    fn: lte
+  },
+  {
+    name: "neither",
+    category: "comparison",
+    compatibility: ["browser", "nodejs"],
+    fn: neither
+  },
+  {
+    name: "not",
+    category: "comparison",
+    compatibility: ["browser", "nodejs"],
+    fn: not
+  },
+  {
+    name: "or",
+    category: "comparison",
+    compatibility: ["browser", "nodejs"],
+    fn: or
+  },
+  {
+    name: "unlessEq",
+    category: "comparison",
+    compatibility: ["browser", "nodejs"],
+    fn: unlessEq
+  },
+  {
+    name: "unlessGt",
+    category: "comparison",
+    compatibility: ["browser", "nodejs"],
+    fn: unlessGt
+  },
+  {
+    name: "unlessLt",
+    category: "comparison",
+    compatibility: ["browser", "nodejs"],
+    fn: unlessLt
+  },
+  {
+    name: "unlessGteq",
+    category: "comparison",
+    compatibility: ["browser", "nodejs"],
+    fn: unlessGteq
+  },
+  {
+    name: "unlessLteq",
+    category: "comparison",
+    compatibility: ["browser", "nodejs"],
+    fn: unlessLteq
+  }
+];
 
-// 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;
+// src/helpers/date.ts
+import { parseDate } from "chrono-node";
+import dayjs from "dayjs";
+var year = () => (/* @__PURE__ */ new Date()).getFullYear().toString();
+var date = (humanReadableDate, formatString) => {
+  const parsedDate = parseDate(humanReadableDate);
+  if (!parsedDate) {
+    throw new Error(`Unable to parse date: ${humanReadableDate}`);
   }
-});
+  return dayjs(parsedDate).format(formatString);
+};
+var helpers5 = [
+  {
+    name: "year",
+    category: "date",
+    compatibility: ["browser", "nodejs"],
+    fn: year
+  },
+  {
+    name: "date",
+    category: "date",
+    compatibility: ["browser", "nodejs"],
+    fn: date
+  },
+  {
+    /* Adding this in for legacy support */
+    name: "moment",
+    category: "date",
+    compatibility: ["browser", "nodejs"],
+    fn: date
+  }
+];
 
-// 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 helpers4 = module2.exports;
-    helpers4.after = function(array, n) {
-      if (util.isUndefined(array)) return "";
-      return array.slice(n);
-    };
-    helpers4.arrayify = function(value) {
-      return value ? Array.isArray(value) ? value : [value] : [];
-    };
-    helpers4.before = function(array, n) {
-      if (util.isUndefined(array)) return "";
-      return array.slice(0, -n);
-    };
-    helpers4.eachIndex = function(array, options) {
-      var result = "";
-      for (var i = 0; i < array.length; i++) {
-        result += options.fn({ item: array[i], index: i });
-      }
-      return result;
-    };
-    helpers4.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);
-    };
-    helpers4.first = function(array, n) {
-      if (util.isUndefined(array)) return "";
-      if (!utils.isNumber(n)) {
-        return array[0];
-      }
-      return array.slice(0, n);
-    };
-    helpers4.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;
-    };
-    helpers4.inArray = function(array, value, options) {
-      return util.value(util.indexOf(array, value) > -1, this, options);
-    };
-    helpers4.isArray = function(value) {
-      return Array.isArray(value);
-    };
-    helpers4.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];
-        }
-      }
-    };
-    helpers4.join = function(array, separator) {
-      if (typeof array === "string") return array;
-      if (!Array.isArray(array)) return "";
-      separator = util.isString(separator) ? separator : ", ";
-      return array.join(separator);
-    };
-    helpers4.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);
-    };
-    helpers4.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));
-    };
-    helpers4.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;
-    };
-    helpers4.lengthEqual = helpers4.equalsLength;
-    helpers4.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;
-    };
-    helpers4.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;
-    };
-    helpers4.reverse = function(val) {
-      if (Array.isArray(val)) {
-        val.reverse();
-        return val;
-      }
-      if (val && typeof val === "string") {
-        return val.split("").reverse().join("");
-      }
-    };
-    helpers4.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);
-    };
-    helpers4.sort = function(array, options) {
-      if (!Array.isArray(array)) return "";
-      if (utils.get(options, "hash.reverse")) {
-        return array.sort().reverse();
-      }
-      return array.sort();
-    };
-    helpers4.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);
-    };
-    helpers4.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;
-    };
-    helpers4.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;
-    };
-    helpers4.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;
-    };
-    helpers4.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;
-    };
-    helpers4.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;
-    };
-    helpers4.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;
-    };
-    helpers4.unique = function(array, options) {
-      if (util.isUndefined(array)) return "";
-      return array.filter(function(item, index, arr) {
-        return arr.indexOf(item) === index;
+// src/helpers/fs.ts
+import fs2 from "fs";
+import path2 from "path";
+import isGlob from "is-glob";
+import micromatch from "micromatch";
+var fileSize = (value, precision) => {
+  if (value == null) return "0 B";
+  const number = typeof value === "number" ? value : value.length ?? 0;
+  if (!number) return "0 B";
+  const precisionNumber = typeof precision === "number" ? precision : 2;
+  const abbr = ["B", "kB", "MB", "GB", "TB", "PB", "EB", "ZB", "YB"];
+  const factor = 10 ** precisionNumber;
+  let i = abbr.length - 1;
+  do {
+    const size = 10 ** (i * 3);
+    if (size <= number + 1) {
+      const num = Math.round(number * factor / size) / factor;
+      return `${num} ${abbr[i]}`;
+    }
+  } while (--i >= 0);
+  return `${number} B`;
+};
+var read = (filepath) => {
+  return fs2.readFileSync(filepath, "utf8");
+};
+var isOptions = (value) => {
+  return Boolean(
+    value && typeof value === "object" && "hash" in value
+  );
+};
+var readdir = (dir, filter) => {
+  const files = fs2.readdirSync(dir).map((fp) => path2.join(dir, fp));
+  const filterArg = isOptions(filter) ? void 0 : filter;
+  if (typeof filterArg === "function") {
+    return filterArg(files);
+  }
+  if (filterArg instanceof RegExp) {
+    return files.filter((fp) => filterArg.test(fp));
+  }
+  if (typeof filterArg === "string") {
+    if (isGlob(filterArg)) {
+      return micromatch(files, filterArg);
+    }
+    if (filterArg === "isFile" || filterArg === "isDirectory") {
+      return files.filter((fp) => {
+        const stat = fs2.statSync(fp);
+        return filterArg === "isFile" ? stat.isFile() : stat.isDirectory();
       });
-    };
+    }
   }
-});
+  return files;
+};
+var helpers6 = [
+  {
+    name: "fileSize",
+    category: "fs",
+    compatibility: ["nodejs"],
+    fn: fileSize
+  },
+  {
+    name: "read",
+    category: "fs",
+    compatibility: ["nodejs"],
+    fn: read
+  },
+  {
+    name: "readdir",
+    category: "fs",
+    compatibility: ["nodejs"],
+    fn: readdir
+  }
+];
 
-// helpers/lib/code.js
-var require_code = __commonJS({
-  "helpers/lib/code.js"(exports2, module2) {
-    "use strict";
-    var fs2 = require("fs");
-    var path2 = require("path");
-    var utils = require_utils2();
-    var helpers4 = module2.exports;
-    helpers4.embed = function embed(filepath, ext) {
-      ext = typeof ext !== "string" ? path2.extname(filepath).slice(1) : ext;
-      var code = fs2.readFileSync(filepath, "utf8");
-      if (ext === "markdown" || ext === "md") {
-        ext = "markdown";
-        code = code.split("`").join("&#x60");
-      }
-      return utils.block(code, ext).trim() + "\n";
-    };
-    helpers4.gist = function(id) {
-      return utils.tag("script", { src: "https://gist.github.com/" + id + ".js" });
-    };
-    helpers4.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);
-    };
+// src/helpers/html.ts
+import path3 from "path";
+import tag2 from "html-tag";
+import striptags from "striptags";
+var parseAttributes = (hash = {}) => Object.keys(hash).map((key) => `${key}="${String(hash[key]).replace(/^['"]|["']$/g, "")}"`).join(" ");
+var attr = (options) => {
+  const val = parseAttributes(options?.hash ?? {});
+  return val.trim() ? ` ${val}` : "";
+};
+var css = function(list, options) {
+  if (arguments.length < 2) {
+    options = list;
+    list = [];
   }
-});
+  let styles = arrayify(list ?? []);
+  let assets = "";
+  if (this && this.options) {
+    assets = this.options.assets || "";
+  }
+  if (options?.hash?.href) {
+    styles = arrayify(options.hash.href);
+  }
+  return styles.map((item) => {
+    const ext = path3.extname(item);
+    let fp = item;
+    if (!/(^\/\/)|(:\/\/)/.test(item)) {
+      fp = path3.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");
+};
+var js = (context) => {
+  if (context && typeof context === "object" && !Array.isArray(context)) {
+    const attrStr = parseAttributes(context.hash ?? {});
+    return `<script${attrStr ? ` ${attrStr}` : ""}></script>`;
+  }
+  if (typeof context === "string") {
+    return `<script src="${context}"></script>`;
+  }
+  const items = arrayify(context);
+  return items.map(
+    (fp) => path3.extname(fp) === ".coffee" ? tag2("script", { type: "text/coffeescript", src: fp }) : tag2("script", { src: fp })
+  ).join("\n");
+};
+var sanitize = (str) => {
+  if (typeof str !== "string") return "";
+  return striptags(str).trim();
+};
+var ul = (context, options) => {
+  const attrs = parseAttributes(options.hash ?? {});
+  const items = context.map(
+    (item) => typeof item === "string" ? item : options.fn(item)
+  );
+  const open = attrs ? `<ul ${attrs}>` : "<ul>";
+  return `${open}${items.map((i) => `<li>${i}</li>`).join("\n")}</ul>`;
+};
+var ol = (context, options) => {
+  const attrs = parseAttributes(options.hash ?? {});
+  const items = context.map(
+    (item) => typeof item === "string" ? item : options.fn(item)
+  );
+  const open = attrs ? `<ol ${attrs}>` : "<ol>";
+  return `${open}${items.map((i) => `<li>${i}</li>`).join("\n")}</ol>`;
+};
+var thumbnailImage = (context) => {
+  let figure = "";
+  let image = "";
+  const link = context.full || false;
+  const imageAttributes = {
+    alt: context.alt,
+    src: context.thumbnail,
+    width: context.size.width,
+    height: context.size.height
+  };
+  const figureAttributes = { id: `image-${context.id}` };
+  const 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 ${parseAttributes(figureAttributes)}>
+`;
+  image += `<img ${parseAttributes(imageAttributes)}>
+`;
+  if (link) {
+    figure += `<a ${parseAttributes(linkAttributes)}>
+${image}</a>
+`;
+  } else {
+    figure += image;
+  }
+  if (context.caption) {
+    figure += `<figcaption>${context.caption}</figcaption>
+`;
+  }
+  figure += "</figure>";
+  return figure;
+};
+var helpers7 = [
+  {
+    name: "attr",
+    category: "html",
+    compatibility: ["browser", "nodejs"],
+    fn: attr
+  },
+  {
+    name: "css",
+    category: "html",
+    compatibility: ["nodejs"],
+    fn: css
+  },
+  {
+    name: "js",
+    category: "html",
+    compatibility: ["nodejs"],
+    fn: js
+  },
+  {
+    name: "sanitize",
+    category: "html",
+    compatibility: ["browser", "nodejs"],
+    fn: sanitize
+  },
+  {
+    name: "ul",
+    category: "html",
+    compatibility: ["browser", "nodejs"],
+    fn: ul
+  },
+  {
+    name: "ol",
+    category: "html",
+    compatibility: ["browser", "nodejs"],
+    fn: ol
+  },
+  {
+    name: "thumbnailImage",
+    category: "html",
+    compatibility: ["browser", "nodejs"],
+    fn: thumbnailImage
+  }
+];
 
-// 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 helpers4 = module2.exports;
-    helpers4.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;
-    };
-    helpers4.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;
-    };
-    helpers4.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;
-    };
-    helpers4.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(".");
-    };
-    helpers4.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;
-    };
-    helpers4.getObject = function(prop, context) {
-      return utils.getObject(context, prop);
-    };
-    helpers4.hasOwn = function(context, key) {
-      return hasOwn.call(context, key);
-    };
-    helpers4.isObject = function(value) {
-      return utils.typeOf(value) === "object";
-    };
-    helpers4.JSONparse = function(str, options) {
-      return JSON.parse(str);
-    };
-    helpers4.JSONstringify = function(obj, indent) {
-      if (!utils.isNumber(indent)) {
-        indent = 0;
-      }
-      return JSON.stringify(obj, null, indent);
-    };
-    helpers4.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);
-    };
-    helpers4.parseJSON = helpers4.JSONparse;
-    helpers4.pick = function(props, context, options) {
-      var keys = array.arrayify(props);
-      var len = keys.length, i = -1;
-      var result = {};
-      while (++i < len) {
-        result = helpers4.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;
-    };
-    helpers4.stringify = helpers4.JSONstringify;
+// src/helpers/i18n.ts
+import get from "get-value";
+var i18n = function(prop, locals, options) {
+  if (locals && typeof locals === "object" && "hash" in locals && options === void 0) {
+    options = locals;
+    locals = {};
   }
-});
+  if (typeof prop !== "string") {
+    throw new Error('{{i18n}} helper expected "key" to be a string');
+  }
+  const context = {
+    ...this,
+    ...locals,
+    ...options?.hash ?? {}
+  };
+  const lang = context.language || context.lang;
+  if (typeof lang !== "string") {
+    throw new TypeError('{{i18n}} helper expected "language" to be a string');
+  }
+  const cache = context[lang];
+  if (typeof cache === "undefined") {
+    throw new Error(`{{i18n}} helper cannot find language "${lang}"`);
+  }
+  const result = get(cache, prop);
+  if (typeof result === "undefined") {
+    throw new Error(
+      '{{i18n}} helper cannot find property "' + String(prop) + '" for language "' + lang + '"'
+    );
+  }
+  return String(result);
+};
+var helpers8 = [
+  {
+    name: "i18n",
+    category: "i18n",
+    compatibility: ["browser", "nodejs"],
+    fn: i18n
+  }
+];
 
-// 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 helpers4 = module2.exports;
-    helpers4.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);
-    };
-    helpers4.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);
-    };
+// src/helpers/inflection.ts
+var inflect = (count, singular, plural, includeCount) => {
+  const word = count > 1 || count === 0 ? plural : singular;
+  return includeCount ? `${count} ${word}` : word;
+};
+var ordinalize = (value) => {
+  const num = Math.abs(Math.round(Number(value)));
+  const str = String(value);
+  const res = num % 100;
+  if ([11, 12, 13].includes(res)) {
+    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`;
+  }
+};
+var helpers9 = [
+  {
+    name: "inflect",
+    category: "inflection",
+    compatibility: ["browser", "nodejs"],
+    fn: inflect
+  },
+  {
+    name: "ordinalize",
+    category: "inflection",
+    compatibility: ["browser", "nodejs"],
+    fn: ordinalize
+  }
+];
+
+// src/helpers/logging.ts
+import loggingHelpers from "logging-helpers";
+var {
+  log,
+  ok,
+  success,
+  info,
+  warning,
+  warn,
+  error,
+  danger,
+  bold,
+  _debug,
+  _inspect
+} = loggingHelpers;
+var helpers10 = [
+  {
+    name: "log",
+    category: "logging",
+    compatibility: ["nodejs"],
+    fn: log
+  },
+  {
+    name: "ok",
+    category: "logging",
+    compatibility: ["nodejs"],
+    fn: ok
+  },
+  {
+    name: "success",
+    category: "logging",
+    compatibility: ["nodejs"],
+    fn: success
+  },
+  {
+    name: "info",
+    category: "logging",
+    compatibility: ["nodejs"],
+    fn: info
+  },
+  {
+    name: "warning",
+    category: "logging",
+    compatibility: ["nodejs"],
+    fn: warning
+  },
+  {
+    name: "warn",
+    category: "logging",
+    compatibility: ["nodejs"],
+    fn: warn
+  },
+  {
+    name: "error",
+    category: "logging",
+    compatibility: ["nodejs"],
+    fn: error
+  },
+  {
+    name: "danger",
+    category: "logging",
+    compatibility: ["nodejs"],
+    fn: danger
+  },
+  {
+    name: "bold",
+    category: "logging",
+    compatibility: ["nodejs"],
+    fn: bold
+  },
+  {
+    name: "_debug",
+    category: "logging",
+    compatibility: ["nodejs"],
+    fn: _debug
+  },
+  {
+    name: "_inspect",
+    category: "logging",
+    compatibility: ["nodejs"],
+    fn: _inspect
+  }
+];
+
+// src/helpers/match.ts
+import micromatch2 from "micromatch";
+var match = (files, patterns, options) => {
+  const pats = typeof patterns === "string" ? patterns.split(/, */) : patterns;
+  return micromatch2(files, pats, options);
+};
+var isMatch = (filepath, pattern, options) => {
+  return micromatch2.isMatch(filepath, pattern, options);
+};
+var mm = (...args) => {
+  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 match(...args);
+};
+var helpers11 = [
+  {
+    name: "match",
+    category: "match",
+    compatibility: ["browser", "nodejs"],
+    fn: match
+  },
+  {
+    name: "isMatch",
+    category: "match",
+    compatibility: ["browser", "nodejs"],
+    fn: isMatch
+  },
+  {
+    name: "mm",
+    category: "match",
+    compatibility: ["browser", "nodejs"],
+    fn: mm
+  }
+];
+
+// src/helpers/math.ts
+var isNumeric = (value) => typeof value === "number" && !Number.isNaN(value) || typeof value === "string" && value.trim() !== "" && !Number.isNaN(Number(value));
+var toNumber = (value, message = "expected a number") => {
+  if (isNumeric(value)) {
+    return Number(value);
+  }
+  throw new TypeError(message);
+};
+var abs = (value) => {
+  const num = toNumber(value);
+  return Math.abs(num);
+};
+var add = (a, b) => {
+  if (isNumeric(a) && isNumeric(b)) {
+    return Number(a) + Number(b);
+  }
+  return "";
+};
+var avg = (...values) => {
+  const flat = values.flat().map((n) => Number(n));
+  return sum(flat) / flat.length;
+};
+var ceil = (value) => {
+  const num = toNumber(value);
+  return Math.ceil(num);
+};
+var divide = (a, b) => {
+  const numA = toNumber(a, "expected the first argument to be a number");
+  const numB = toNumber(b, "expected the second argument to be a number");
+  return numA / numB;
+};
+var floor = (value) => {
+  const num = toNumber(value);
+  return Math.floor(num);
+};
+var minus = (a, b) => {
+  const numA = toNumber(a, "expected the first argument to be a number");
+  const numB = toNumber(b, "expected the second argument to be a number");
+  return numA - numB;
+};
+var modulo = (a, b) => {
+  const numA = toNumber(a, "expected the first argument to be a number");
+  const numB = toNumber(b, "expected the second argument to be a number");
+  return numA % numB;
+};
+var multiply = (a, b) => {
+  const numA = toNumber(a, "expected the first argument to be a number");
+  const numB = toNumber(b, "expected the second argument to be a number");
+  return numA * numB;
+};
+var plus = (a, b) => {
+  const numA = toNumber(a, "expected the first argument to be a number");
+  const numB = toNumber(b, "expected the second argument to be a number");
+  return numA + numB;
+};
+var random = (min, max) => {
+  const minNum = toNumber(min, "expected minimum to be a number");
+  const maxNum = toNumber(max, "expected maximum to be a number");
+  return minNum + Math.floor(Math.random() * (maxNum - minNum + 1));
+};
+var remainder = (a, b) => a % b;
+var round = (value) => {
+  const num = toNumber(value);
+  return Math.round(num);
+};
+var subtract = (a, b) => {
+  const numA = toNumber(a, "expected the first argument to be a number");
+  const numB = toNumber(b, "expected the second argument to be a number");
+  return numA - numB;
+};
+var sum = (...values) => {
+  const flat = values.flat();
+  let total = 0;
+  for (const value of flat) {
+    if (isNumeric(value)) {
+      total += Number(value);
+    }
+  }
+  return total;
+};
+var times = (a, b) => multiply(a, b);
+var helpers12 = [
+  {
+    name: "abs",
+    category: "math",
+    compatibility: ["browser", "nodejs"],
+    fn: abs
+  },
+  {
+    name: "add",
+    category: "math",
+    compatibility: ["browser", "nodejs"],
+    fn: add
+  },
+  {
+    name: "avg",
+    category: "math",
+    compatibility: ["browser", "nodejs"],
+    fn: avg
+  },
+  {
+    name: "ceil",
+    category: "math",
+    compatibility: ["browser", "nodejs"],
+    fn: ceil
+  },
+  {
+    name: "divide",
+    category: "math",
+    compatibility: ["browser", "nodejs"],
+    fn: divide
+  },
+  {
+    name: "floor",
+    category: "math",
+    compatibility: ["browser", "nodejs"],
+    fn: floor
+  },
+  {
+    name: "minus",
+    category: "math",
+    compatibility: ["browser", "nodejs"],
+    fn: minus
+  },
+  {
+    name: "modulo",
+    category: "math",
+    compatibility: ["browser", "nodejs"],
+    fn: modulo
+  },
+  {
+    name: "multiply",
+    category: "math",
+    compatibility: ["browser", "nodejs"],
+    fn: multiply
+  },
+  {
+    name: "plus",
+    category: "math",
+    compatibility: ["browser", "nodejs"],
+    fn: plus
+  },
+  {
+    name: "random",
+    category: "math",
+    compatibility: ["browser", "nodejs"],
+    fn: random
+  },
+  {
+    name: "remainder",
+    category: "math",
+    compatibility: ["browser", "nodejs"],
+    fn: remainder
+  },
+  {
+    name: "round",
+    category: "math",
+    compatibility: ["browser", "nodejs"],
+    fn: round
+  },
+  {
+    name: "subtract",
+    category: "math",
+    compatibility: ["browser", "nodejs"],
+    fn: subtract
+  },
+  {
+    name: "sum",
+    category: "math",
+    compatibility: ["browser", "nodejs"],
+    fn: sum
+  },
+  {
+    name: "times",
+    category: "math",
+    compatibility: ["browser", "nodejs"],
+    fn: times
+  }
+];
 
-// 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 helpers4 = module2.exports;
-    helpers4.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);
-    };
-    helpers4.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);
-    };
-    helpers4.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);
-    };
-    helpers4.default = function() {
-      for (var i = 0; i < arguments.length - 1; i++) {
-        if (arguments[i] != null) return arguments[i];
-      }
-      return "";
-    };
-    helpers4.eq = function(a, b, options) {
-      if (arguments.length === 2) {
-        options = b;
-        b = options.hash.compare;
-      }
-      return util.value(a === b, this, options);
-    };
-    helpers4.gt = function(a, b, options) {
-      if (arguments.length === 2) {
-        options = b;
-        b = options.hash.compare;
-      }
-      return util.value(a > b, this, options);
-    };
-    helpers4.gte = function(a, b, options) {
-      if (arguments.length === 2) {
-        options = b;
-        b = options.hash.compare;
-      }
-      return util.value(a >= b, this, options);
-    };
-    helpers4.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);
-    };
-    helpers4.isFalsey = function(val, options) {
-      return util.value(utils.falsey(val), this, options);
-    };
-    helpers4.isTruthy = function(val, options) {
-      return util.value(!utils.falsey(val), this, options);
-    };
-    helpers4.ifEven = function(num, options) {
-      return util.value(utils.isEven(num), this, options);
-    };
-    helpers4.ifNth = function(a, b, options) {
-      var isNth = utils.isNumber(a) && utils.isNumber(b) && b % a === 0;
-      return util.value(isNth, this, options);
-    };
-    helpers4.ifOdd = function(val, options) {
-      return util.value(!utils.isEven(val), this, options);
-    };
-    helpers4.is = function(a, b, options) {
-      if (arguments.length === 2) {
-        options = b;
-        b = options.hash.compare;
-      }
-      return util.value(a == b, this, options);
-    };
-    helpers4.isnt = function(a, b, options) {
-      if (arguments.length === 2) {
-        options = b;
-        b = options.hash.compare;
-      }
-      return util.value(a != b, this, options);
-    };
-    helpers4.lt = function(a, b, options) {
-      if (arguments.length === 2) {
-        options = b;
-        b = options.hash.compare;
-      }
-      return util.value(a < b, this, options);
-    };
-    helpers4.lte = function(a, b, options) {
-      if (arguments.length === 2) {
-        options = b;
-        b = options.hash.compare;
-      }
-      return util.value(a <= b, this, options);
-    };
-    helpers4.neither = function(a, b, options) {
-      return util.value(!a && !b, this, options);
-    };
-    helpers4.not = function(val, options) {
-      return util.value(!val, this, options);
-    };
-    helpers4.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);
-    };
-    helpers4.unlessEq = function(a, b, options) {
-      if (util.isOptions(b)) {
-        options = b;
-        b = options.hash.compare;
-      }
-      return util.value(a !== b, this, options);
-    };
-    helpers4.unlessGt = function(a, b, options) {
-      if (util.isOptions(b)) {
-        options = b;
-        b = options.hash.compare;
-      }
-      return util.value(a <= b, this, options);
-    };
-    helpers4.unlessLt = function(a, b, options) {
-      if (util.isOptions(b)) {
-        options = b;
-        b = options.hash.compare;
-      }
-      return util.value(a >= b, this, options);
-    };
-    helpers4.unlessGteq = function(a, b, options) {
-      if (util.isOptions(b)) {
-        options = b;
-        b = options.hash.compare;
-      }
-      return util.value(a < b, this, options);
-    };
-    helpers4.unlessLteq = function(a, b, options) {
-      if (util.isOptions(b)) {
-        options = b;
-        b = options.hash.compare;
-      }
-      return util.value(a > b, this, options);
-    };
+// src/helpers/md.ts
+import fs3 from "fs";
+import path4 from "path";
+import process2 from "process";
+import ent from "ent";
+import Handlebars from "handlebars";
+import { Remarkable } from "remarkable";
+var renderMarkdown = (input, options = {}) => {
+  const options_ = { cwd: process2.cwd(), ...options };
+  const md = new Remarkable({
+    breaks: true,
+    html: true,
+    langPrefix: "lang-",
+    typographer: false,
+    xhtmlOut: false
+  });
+  const filepath = path4.resolve(options_.cwd, input);
+  let string_ = input;
+  if (fs3.existsSync(filepath)) {
+    string_ = fs3.readFileSync(filepath, "utf8");
+  }
+  return new Handlebars.SafeString(ent.decode(md.render(string_)));
+};
+var helpers13 = [
+  {
+    name: "md",
+    category: "markdown",
+    compatibility: ["nodejs"],
+    fn: renderMarkdown
+  }
+];
+
+// src/helpers/misc.ts
+import get2 from "get-value";
+import createFrame from "handlebars-helper-create-frame";
+import util from "handlebars-utils";
+import kindOf from "kind-of";
+var frame = createFrame;
+function option(prop, locals, options) {
+  return get2(util.options(this, locals, options), prop);
+}
+function noop(options) {
+  return options.fn(this);
+}
+var typeOf = kindOf;
+function withHash(options) {
+  if (options.hash && Object.keys(options.hash).length) {
+    return options.fn(options.hash);
+  }
+  return options.inverse(this);
+}
+var helpers14 = [
+  {
+    name: "frame",
+    category: "misc",
+    compatibility: ["browser", "nodejs"],
+    fn: frame
+  },
+  {
+    name: "option",
+    category: "misc",
+    compatibility: ["browser", "nodejs"],
+    fn: option
+  },
+  {
+    name: "noop",
+    category: "misc",
+    compatibility: ["browser", "nodejs"],
+    fn: noop
+  },
+  {
+    name: "typeOf",
+    category: "misc",
+    compatibility: ["browser", "nodejs"],
+    fn: typeOf
+  },
+  {
+    name: "withHash",
+    category: "misc",
+    compatibility: ["browser", "nodejs"],
+    fn: withHash
+  }
+];
+
+// src/helpers/number.ts
+var isNumeric2 = (value) => typeof value === "number" && !Number.isNaN(value);
+var bytes = (value, precision) => {
+  if (value == null) return "0 B";
+  let num;
+  if (typeof value === "string") {
+    num = value.length;
+    if (!num) return "0 B";
+  } else if (isNumeric2(value)) {
+    num = Number(value);
+  } else if (typeof value.length === "number") {
+    num = value.length;
+    if (!num) return "0 B";
+  } else {
+    return "0 B";
+  }
+  const prec = typeof precision === "number" && !Number.isNaN(precision) ? precision : 2;
+  const abbr = ["B", "kB", "MB", "GB", "TB", "PB", "EB", "ZB", "YB"];
+  const factor = 10 ** prec;
+  for (let i = abbr.length - 1; i >= 0; i--) {
+    const size = 10 ** (i * 3);
+    if (size <= num + 1) {
+      const val = Math.round(num * factor / size) / factor;
+      return `${val} ${abbr[i]}`;
+    }
+  }
+  return `${num}`;
+};
+var addCommas = (num) => num.toString().replace(/(\d)(?=(\d\d\d)+(?!\d))/g, "$1,");
+var phoneNumber = (num) => {
+  const str = num.toString();
+  return `(${str.substr(0, 3)}) ${str.substr(3, 3)}-${str.substr(6, 4)}`;
+};
+var toAbbr = (value, precision) => {
+  const num = isNumeric2(value) ? Number(value) : 0;
+  const prec = typeof precision === "number" && !Number.isNaN(precision) ? precision : 2;
+  const factor = 10 ** prec;
+  const abbr = ["k", "m", "b", "t", "q"];
+  for (let i = abbr.length - 1; i >= 0; i--) {
+    const size = 10 ** ((i + 1) * 3);
+    if (size <= num + 1) {
+      const val = Math.round(num * factor / size) / factor;
+      return `${val}${abbr[i]}`;
+    }
+  }
+  return `${num}`;
+};
+var toExponential = (value, digits) => {
+  const num = isNumeric2(value) ? Number(value) : 0;
+  const d = typeof digits === "number" && !Number.isNaN(digits) ? digits : 0;
+  return Number(num).toExponential(d);
+};
+var toFixed = (value, digits) => {
+  const num = isNumeric2(value) ? Number(value) : 0;
+  const d = typeof digits === "number" && !Number.isNaN(digits) ? digits : 0;
+  return Number(num).toFixed(d);
+};
+var toFloat = (value) => parseFloat(String(value));
+var toInt = (value) => parseInt(String(value), 10);
+var toPrecision = (value, precision) => {
+  const num = isNumeric2(value) ? Number(value) : 0;
+  const prec = typeof precision === "number" && !Number.isNaN(precision) ? precision : 1;
+  return Number(num).toPrecision(prec);
+};
+var helpers15 = [
+  {
+    name: "bytes",
+    category: "number",
+    compatibility: ["browser", "nodejs"],
+    fn: bytes
+  },
+  {
+    name: "addCommas",
+    category: "number",
+    compatibility: ["browser", "nodejs"],
+    fn: addCommas
+  },
+  {
+    name: "phoneNumber",
+    category: "number",
+    compatibility: ["browser", "nodejs"],
+    fn: phoneNumber
+  },
+  {
+    name: "toAbbr",
+    category: "number",
+    compatibility: ["browser", "nodejs"],
+    fn: toAbbr
+  },
+  {
+    name: "toExponential",
+    category: "number",
+    compatibility: ["browser", "nodejs"],
+    fn: toExponential
+  },
+  {
+    name: "toFixed",
+    category: "number",
+    compatibility: ["browser", "nodejs"],
+    fn: toFixed
+  },
+  {
+    name: "toFloat",
+    category: "number",
+    compatibility: ["browser", "nodejs"],
+    fn: toFloat
+  },
+  {
+    name: "toInt",
+    category: "number",
+    compatibility: ["browser", "nodejs"],
+    fn: toInt
+  },
+  {
+    name: "toPrecision",
+    category: "number",
+    compatibility: ["browser", "nodejs"],
+    fn: toPrecision
+  }
+];
+
+// src/helpers/object.ts
+import getObject from "get-object";
+import get3 from "get-value";
+var isOptions2 = (value) => {
+  return Boolean(value && typeof value === "object" && "hash" in value);
+};
+var createFrame2 = (options, hash) => ({
+  ...options?.data || {},
+  ...hash
+});
+var extend = (...objects) => {
+  const args = [...objects];
+  if (args.length && isOptions2(args[args.length - 1])) {
+    const opts = args.pop();
+    args.push(opts.hash);
+  }
+  const result = {};
+  for (const obj of args) {
+    if (obj && typeof obj === "object" && !Array.isArray(obj)) {
+      Object.assign(result, obj);
+    }
+  }
+  return result;
+};
+var forIn = (obj, options) => {
+  if (!isOptions2(options)) {
+    return options?.inverse?.(obj) ?? "";
+  }
+  const data = createFrame2(options, options.hash || {});
+  let result = "";
+  for (const key in obj) {
+    data.key = key;
+    result += options.fn(obj[key], { data });
+  }
+  return result;
+};
+var forOwn = (obj, options) => {
+  if (!isOptions2(options)) {
+    return options?.inverse?.(obj) ?? "";
+  }
+  const data = createFrame2(options, options.hash || {});
+  let result = "";
+  for (const key in obj) {
+    if (Object.hasOwn(obj, key)) {
+      data.key = key;
+      result += options.fn(obj[key], { data });
+    }
+  }
+  return result;
+};
+var toPath = (...prop) => {
+  const parts = [];
+  for (const p of prop) {
+    if (typeof p === "string" || typeof p === "number") {
+      parts.push(p);
+    }
+  }
+  return parts.join(".");
+};
+var getHelper = (prop, context, options) => {
+  const val = get3(context, prop);
+  if (options && typeof options.fn === "function") {
+    return val ? options.fn(val) : options.inverse?.(context);
+  }
+  return val;
+};
+var getObjectHelper = (prop, context) => {
+  return getObject(context, prop);
+};
+var hasOwn = (context, key) => {
+  return Object.hasOwn(context, key);
+};
+var isObject = (value) => {
+  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+};
+var JSONparse = (str) => {
+  return JSON.parse(str);
+};
+var JSONstringify = (obj, indent) => {
+  const ind = typeof indent === "number" ? indent : 0;
+  return JSON.stringify(obj, null, ind);
+};
+var merge = (context, ...objects) => {
+  const args = [context, ...objects];
+  if (args.length && isOptions2(args[args.length - 1])) {
+    const opts = args.pop();
+    args.push(opts.hash);
+  }
+  return Object.assign(...args);
+};
+var parseJSON = JSONparse;
+var stringify = JSONstringify;
+var pick = (props, context, options) => {
+  const keys = arrayify(props);
+  let result = {};
+  for (const key of keys) {
+    result = Object.assign({}, result, getObject(context, key));
+  }
+  if (options && typeof options.fn === "function") {
+    if (Object.keys(result).length) {
+      return options.fn(result);
+    }
+    return options.inverse?.(context);
+  }
+  return result;
+};
+var helpers16 = [
+  {
+    name: "extend",
+    category: "object",
+    compatibility: ["browser", "nodejs"],
+    fn: extend
+  },
+  {
+    name: "forIn",
+    category: "object",
+    compatibility: ["browser", "nodejs"],
+    fn: forIn
+  },
+  {
+    name: "forOwn",
+    category: "object",
+    compatibility: ["browser", "nodejs"],
+    fn: forOwn
+  },
+  {
+    name: "toPath",
+    category: "object",
+    compatibility: ["browser", "nodejs"],
+    fn: toPath
+  },
+  {
+    name: "get",
+    category: "object",
+    compatibility: ["browser", "nodejs"],
+    fn: getHelper
+  },
+  {
+    name: "getObject",
+    category: "object",
+    compatibility: ["browser", "nodejs"],
+    fn: getObjectHelper
+  },
+  {
+    name: "hasOwn",
+    category: "object",
+    compatibility: ["browser", "nodejs"],
+    fn: hasOwn
+  },
+  {
+    name: "isObject",
+    category: "object",
+    compatibility: ["browser", "nodejs"],
+    fn: isObject
+  },
+  {
+    name: "JSONparse",
+    category: "object",
+    compatibility: ["browser", "nodejs"],
+    fn: JSONparse
+  },
+  {
+    name: "JSONstringify",
+    category: "object",
+    compatibility: ["browser", "nodejs"],
+    fn: JSONstringify
+  },
+  {
+    name: "merge",
+    category: "object",
+    compatibility: ["browser", "nodejs"],
+    fn: merge
+  },
+  {
+    name: "parseJSON",
+    category: "object",
+    compatibility: ["browser", "nodejs"],
+    fn: parseJSON
+  },
+  {
+    name: "pick",
+    category: "object",
+    compatibility: ["browser", "nodejs"],
+    fn: pick
+  },
+  {
+    name: "stringify",
+    category: "object",
+    compatibility: ["browser", "nodejs"],
+    fn: stringify
   }
-});
+];
 
-// helpers/lib/date.js
-var require_date = __commonJS({
-  "helpers/lib/date.js"(exports2, module2) {
-    "use strict";
-    var helpers4 = module2.exports;
-    helpers4.year = require("year");
-    helpers4.moment = helpers4.date = require("helper-date");
+// src/helpers/path.ts
+import path5 from "path";
+var expectedType = (variableName, expectedType2, variableValue) => {
+  const actualType = Object.prototype.toString.call(variableValue).slice(8, -1).toLowerCase();
+  return `Expected ${variableName} to be of type ${expectedType2}, but got ${actualType}`;
+};
+var assertString = (name, value) => {
+  if (typeof value !== "string") {
+    throw new TypeError(expectedType(name, "string", value));
   }
-});
-
-// 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 helpers4 = module2.exports;
-    helpers4.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;
-    };
-    helpers4.addCommas = function(num) {
-      return num.toString().replace(/(\d)(?=(\d\d\d)+(?!\d))/g, "$1,");
-    };
-    helpers4.phoneNumber = function(num) {
-      num = num.toString();
-      return "(" + num.substr(0, 3) + ") " + num.substr(3, 3) + "-" + num.substr(6, 4);
-    };
-    helpers4.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;
-    };
-    helpers4.toExponential = function(number, digits) {
-      if (!utils.isNumber(number)) {
-        number = 0;
-      }
-      if (util.isUndefined(digits)) {
-        digits = 0;
-      }
-      return Number(number).toExponential(digits);
-    };
-    helpers4.toFixed = function(number, digits) {
-      if (!utils.isNumber(number)) {
-        number = 0;
-      }
-      if (!isNumber(digits)) {
-        digits = 0;
-      }
-      return Number(number).toFixed(digits);
-    };
-    helpers4.toFloat = function(number) {
-      return parseFloat(number);
-    };
-    helpers4.toInt = function(number) {
-      return parseInt(number, 10);
-    };
-    helpers4.toPrecision = function(number, precision) {
-      if (!utils.isNumber(number)) {
-        number = 0;
-      }
-      if (!isNumber(precision)) {
-        precision = 1;
-      }
-      return Number(number).toPrecision(precision);
-    };
+  return value;
+};
+var absolute = function(filepath, options) {
+  const fp = assertString("filepath", filepath);
+  const cwd = options?.data?.root?.cwd ?? this?.cwd ?? process.cwd();
+  return path5.resolve(cwd, fp);
+};
+var dirname = (filepath) => {
+  const fp = assertString("filepath", filepath);
+  return path5.dirname(fp);
+};
+var relative = (a, b) => {
+  const from = assertString("first path", a);
+  const to = assertString("second path", b);
+  return path5.relative(path5.dirname(from), to);
+};
+var basename = (filepath) => {
+  const fp = assertString("filepath", filepath);
+  return path5.basename(fp);
+};
+var stem = (filepath) => {
+  const fp = assertString("filepath", filepath);
+  return path5.basename(fp, path5.extname(fp));
+};
+var extname = (filepath) => {
+  const fp = assertString("filepath", filepath);
+  return path5.extname(fp);
+};
+var resolveFn = function(filepath, ...paths) {
+  let options;
+  const last2 = paths[paths.length - 1];
+  if (typeof last2 === "object" && last2 && "data" in last2) {
+    options = paths.pop();
   }
-});
-
-// helpers/lib/fs.js
-var require_fs = __commonJS({
-  "helpers/lib/fs.js"(exports2, module2) {
-    "use strict";
-    var fs2 = require("fs");
-    var path2 = require("path");
-    var util = require("handlebars-utils");
-    var utils = require_utils2();
-    var number = require_number();
-    var helpers4 = module2.exports;
-    helpers4.fileSize = number.bytes;
-    helpers4.read = function(filepath, options) {
-      return fs2.readFileSync(filepath, "utf8");
-    };
-    helpers4.readdir = function(dir, filter) {
-      var files = fs2.readdirSync(dir);
-      files = files.map(function(fp) {
-        return path2.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 = fs2.statSync(fp);
-          return stat[filter]();
-        });
-      }
-      return files;
-    };
+  const cwd = options?.data?.root?.cwd ?? this?.cwd ?? process.cwd();
+  const all2 = [
+    cwd,
+    assertString("filepath", filepath),
+    ...paths.map((p, i) => assertString(`path${i}`, p))
+  ];
+  return path5.resolve(...all2);
+};
+var segments = (filepath, a, b) => {
+  const fp = assertString("filepath", filepath);
+  const start = Number(a);
+  const end = Number(b);
+  const segmentsArr = fp.split(/[\\/]+/);
+  return segmentsArr.slice(start, end).join("/");
+};
+var helpers17 = [
+  {
+    name: "absolute",
+    category: "path",
+    compatibility: ["nodejs"],
+    fn: absolute
+  },
+  {
+    name: "dirname",
+    category: "path",
+    compatibility: ["nodejs"],
+    fn: dirname
+  },
+  {
+    name: "relative",
+    category: "path",
+    compatibility: ["nodejs"],
+    fn: relative
+  },
+  {
+    name: "basename",
+    category: "path",
+    compatibility: ["nodejs"],
+    fn: basename
+  },
+  {
+    name: "stem",
+    category: "path",
+    compatibility: ["nodejs"],
+    fn: stem
+  },
+  {
+    name: "extname",
+    category: "path",
+    compatibility: ["nodejs"],
+    fn: extname
+  },
+  {
+    name: "resolve",
+    category: "path",
+    compatibility: ["nodejs"],
+    fn: resolveFn
+  },
+  {
+    name: "segments",
+    category: "path",
+    compatibility: ["nodejs"],
+    fn: segments
   }
-});
+];
 
-// 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;
-    };
+// src/helpers/regex.ts
+import util2 from "handlebars-utils";
+var toRegex = (str, locals, options) => {
+  const opts = util2.options({}, locals, options);
+  return new RegExp(str, opts.flags);
+};
+var test = (str, regex) => {
+  if (typeof str !== "string") {
+    return false;
   }
-});
-
-// helpers/lib/html.js
-var require_html2 = __commonJS({
-  "helpers/lib/html.js"(exports2, module2) {
-    "use strict";
-    var path2 = require("path");
-    var util = require("handlebars-utils");
-    var html = require_html();
-    var utils = require_utils2();
-    var parseAttr = html.parseAttributes;
-    var helpers4 = module2.exports;
-    helpers4.attr = function(options) {
-      var val = parseAttr(options && options.hash || {});
-      return val.trim() ? " " + val : "";
-    };
-    helpers4.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 = path2.extname(item);
-        var fp = item;
-        if (!/(^\/\/)|(:\/\/)/.test(item)) {
-          fp = path2.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");
-    };
-    helpers4.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 path2.extname(fp) === ".coffee" ? utils.tag("script", { type: "text/coffeescript", src: fp }) : utils.tag("script", { src: fp });
-      }).join("\n");
-    };
-    helpers4.sanitize = function(str) {
-      return html.sanitize(str);
-    };
-    helpers4.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>";
-    };
-    helpers4.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>";
-    };
-    helpers4.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;
-    };
+  if (!(regex instanceof RegExp)) {
+    throw new TypeError("expected a regular expression");
   }
-});
-
-// 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 helpers4 = module2.exports;
-    helpers4.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;
-    };
+  return regex.test(str);
+};
+var helpers18 = [
+  {
+    name: "toRegex",
+    category: "regex",
+    compatibility: ["browser", "nodejs"],
+    fn: toRegex
+  },
+  {
+    name: "test",
+    category: "regex",
+    compatibility: ["browser", "nodejs"],
+    fn: test
   }
-});
+];
 
-// helpers/lib/inflection.js
-var require_inflection = __commonJS({
-  "helpers/lib/inflection.js"(exports2, module2) {
-    "use strict";
-    var util = require("handlebars-utils");
-    var helpers4 = module2.exports;
-    helpers4.inflect = function(count, singular, plural, includeCount) {
-      var word = count > 1 || count === 0 ? plural : singular;
-      if (includeCount === true) {
-        return String(count) + " " + word;
-      } else {
-        return word;
-      }
-    };
-    helpers4.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";
-        }
-      }
-    };
+// src/helpers/string.ts
+var chop = (str) => str.trim().replace(/^[-_.\W\s]+|[-_.\W\s]+$/g, "");
+var changecase = (str, fn) => {
+  if (str.length === 1) return str.toLowerCase();
+  const res = chop(str).toLowerCase();
+  return res.replace(/[-_.\W\s]+(\w|$)/g, (_, ch) => fn(ch));
+};
+var append = (str, suffix) => {
+  if (typeof str === "string" && typeof suffix === "string") {
+    return str + suffix;
   }
-});
-
-// helpers/lib/logging.js
-var require_logging = __commonJS({
-  "helpers/lib/logging.js"(exports2, module2) {
-    "use strict";
-    module2.exports = require("logging-helpers");
+  return str;
+};
+var camelcase = (str) => typeof str === "string" ? changecase(str, (ch) => ch.toUpperCase()) : "";
+var capitalize = (str) => {
+  if (typeof str !== "string" || str.length === 0) return "";
+  return str.charAt(0).toUpperCase() + str.slice(1);
+};
+var capitalizeAll = (str) => {
+  if (typeof str !== "string") return "";
+  return str.replace(/\w\S*/g, (word) => capitalize(word));
+};
+var center = (str, spaces) => {
+  if (typeof str !== "string") return "";
+  let space = "";
+  for (let i = 0; i < spaces; i++) {
+    space += "&nbsp;";
   }
-});
-
-// helpers/lib/md.js
-var require_md = __commonJS({
-  "helpers/lib/md.js"(exports2, module2) {
-    "use strict";
-    var fs2 = require("fs");
-    var path2 = require("path");
-    var { Remarkable: Remarkable2 } = 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 = path2.resolve(opts.cwd, name);
-      var view;
-      var str = "";
-      if (exists(filepath)) {
-        this.app.create("mdfiles");
-        str = fs2.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 = path2.resolve(opts.cwd, name);
-      var view;
-      var html = "";
-      var str = "";
-      if (exists(filepath)) {
-        str = fs2.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 Remarkable2(optsConfig);
-      return md;
+  return space + str + space;
+};
+var chopStr = (str) => typeof str === "string" ? chop(str) : "";
+var dashcase = (str) => typeof str === "string" ? changecase(str, (ch) => `-${ch}`) : "";
+var dotcase = (str) => typeof str === "string" ? changecase(str, (ch) => `.${ch}`) : "";
+var truncate = (str, limit, suffix) => {
+  if (typeof str === "string") {
+    if (typeof suffix !== "string") {
+      suffix = "";
     }
+    if (str.length > limit) {
+      return str.slice(0, limit - suffix.length) + suffix;
+    }
+    return str;
   }
-});
-
-// 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: Remarkable2 } = require("remarkable");
-    var helpers4 = module2.exports;
-    var markdown;
-    Object.defineProperty(helpers4, "markdown", {
-      configurable: true,
-      enumerable: true,
-      set: function(val) {
-        markdown = val;
-      },
-      get: function() {
-        return markdown || (markdown = this.helpersForMarkdown());
-      }
-    });
-    helpers4.md = require_md();
-    helpers4.helpersForMarkdown = function(config) {
-      const defaults = { html: true, breaks: true, highlight: helpers4.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 Remarkable2(opts);
-        const val = utils.value(str, ctx, options);
-        return md.render(val);
-      }
-      return markdown2;
-    };
-    helpers4.highlightFormMarkdown = function(code, lang) {
-      if (lang) {
-        return hljs.highlight(code, { language: lang }).value;
-      }
-      return hljs.highlightAuto(code).value;
-    };
+  return "";
+};
+var ellipsis = (str, limit) => {
+  if (typeof str === "string") {
+    if (str.length <= limit) {
+      return str;
+    }
+    return `${truncate(str, limit)}\u2026`;
   }
-});
-
-// 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 helpers4 = module2.exports;
-    helpers4.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);
-    };
-    helpers4.isMatch = function(files, patterns, locals, options) {
-      var opts = util.options(this, locals, options);
-      return utils.mm.isMatch(files, patterns, opts);
-    };
-    helpers4.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 helpers4.match.apply(this, arguments);
-    };
+  return "";
+};
+var hyphenate = (str) => typeof str === "string" ? str.split(" ").join("-") : "";
+var isString = (value) => typeof value === "string";
+var lowercase = (str) => {
+  if (typeof str === "object" && str !== null && "fn" in str && typeof str.fn === "function") {
+    return String(str.fn()).toLowerCase();
   }
-});
-
-// 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 helpers4 = module2.exports;
-    helpers4.abs = function(num) {
-      if (!isNumber(num)) {
-        throw new TypeError("expected a number");
-      }
-      return Math.abs(num);
-    };
-    helpers4.add = function(a, b) {
-      if (isNumber(a) && isNumber(b)) {
-        return Number(a) + Number(b);
-      }
-      return "";
-    };
-    helpers4.avg = function() {
-      var args = [].concat.apply([], arguments);
-      args.pop();
-      return helpers4.sum(args) / args.length;
-    };
-    helpers4.ceil = function(num) {
-      if (!isNumber(num)) {
-        throw new TypeError("expected a number");
-      }
-      return Math.ceil(num);
-    };
-    helpers4.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);
-    };
-    helpers4.floor = function(num) {
-      if (!isNumber(num)) {
-        throw new TypeError("expected a number");
-      }
-      return Math.floor(num);
-    };
-    helpers4.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);
-    };
-    helpers4.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);
-    };
-    helpers4.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);
-    };
-    helpers4.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);
-    };
-    helpers4.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);
-    };
-    helpers4.remainder = function(a, b) {
-      return a % b;
-    };
-    helpers4.round = function(num) {
-      if (!isNumber(num)) {
-        throw new TypeError("expected a number");
-      }
-      return Math.round(num);
-    };
-    helpers4.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);
-    };
-    helpers4.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;
-    };
-    helpers4.times = function() {
-      return helpers4.multiply.apply(this, arguments);
-    };
+  if (typeof str !== "string") return "";
+  return str.toLowerCase();
+};
+var downcase = (...args) => lowercase(...args);
+var occurrences = (str, substring) => {
+  if (typeof str !== "string") return "";
+  const len = substring.length;
+  let pos = str.indexOf(substring, 0);
+  let n = 0;
+  while (pos > -1) {
+    n++;
+    pos = str.indexOf(substring, pos + len);
   }
-});
-
-// 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 helpers4 = module2.exports;
-    helpers4.frame = require("handlebars-helper-create-frame");
-    helpers4.option = function(prop, locals, options) {
-      return utils.get(util.options(this, locals, options), prop);
-    };
-    helpers4.noop = function(options) {
-      return options.fn(this);
-    };
-    helpers4.typeOf = require("kind-of");
-    helpers4.withHash = function(options) {
-      if (options.hash && Object.keys(options.hash).length) {
-        return options.fn(options.hash);
-      } else {
-        return options.inverse(this);
-      }
-    };
+  return n;
+};
+var pascalcase = (str) => {
+  if (typeof str !== "string") return "";
+  const res = changecase(str, (ch) => ch.toUpperCase());
+  return res.charAt(0).toUpperCase() + res.slice(1);
+};
+var pathcase = (str) => typeof str === "string" ? changecase(str, (ch) => `/${ch}`) : "";
+var plusify = (str, ch) => {
+  if (typeof str !== "string") return "";
+  if (typeof ch !== "string") ch = " ";
+  return str.split(ch).join("+");
+};
+var prepend = (str, prefix) => {
+  return typeof str === "string" && typeof prefix === "string" ? prefix + str : str;
+};
+var remove = (str, ch) => {
+  if (typeof str !== "string") return "";
+  if (typeof ch !== "string") return str;
+  return str.split(ch).join("");
+};
+var removeFirst = (str, ch) => {
+  if (typeof str !== "string") return "";
+  if (typeof ch !== "string") return str;
+  return str.replace(ch, "");
+};
+var replace = (str, a, b) => {
+  if (typeof str !== "string") return "";
+  if (typeof a !== "string") return str;
+  if (typeof b !== "string") b = "";
+  return str.split(a).join(b);
+};
+var replaceFirst = (str, a, b) => {
+  if (typeof str !== "string") return "";
+  if (typeof a !== "string") return str;
+  if (typeof b !== "string") b = "";
+  return str.replace(a, b);
+};
+var reverse = (str) => typeof str === "string" ? str.split("").reverse().join("") : "";
+var sentence = (str) => {
+  if (typeof str !== "string") return "";
+  return str.replace(
+    /((?:\S[^.?!]*)[.?!]*)/g,
+    (txt) => txt.charAt(0).toUpperCase() + txt.substr(1).toLowerCase()
+  );
+};
+var snakecase = (str) => typeof str === "string" ? changecase(str, (ch) => `_${ch}`) : "";
+var trim = (str) => typeof str === "string" ? str.trim() : "";
+var trimLeft = (str) => typeof str === "string" ? str.replace(/^\s+/, "") : "";
+var trimRight = (str) => typeof str === "string" ? str.replace(/\s+$/, "") : "";
+var truncateWords = (str, count, suffix) => {
+  if (typeof str === "string" && typeof count === "number" && Number.isFinite(count)) {
+    if (typeof suffix !== "string") {
+      suffix = "...";
+    }
+    const num = Math.trunc(count);
+    let arr = str.split(" ");
+    if (num < arr.length) {
+      arr = arr.slice(0, num);
+    }
+    const val = arr.join(" ").trim();
+    return val + suffix;
   }
-});
-
-// helpers/lib/path.js
-var require_path = __commonJS({
-  "helpers/lib/path.js"(exports2, module2) {
-    "use strict";
-    var util = require("handlebars-utils");
-    var path2 = require("path");
-    var utils = require_utils2();
-    var helpers4 = 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}`);
-      }
-    };
-    helpers4.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 path2.resolve(cwd, filepath);
-    };
-    helpers4.dirname = function(filepath, options) {
-      if (typeof filepath !== "string") {
-        throw new TypeError(utils.expectedType("filepath", "string", filepath));
-      }
-      return path2.dirname(filepath);
-    };
-    helpers4.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);
-    };
-    helpers4.basename = function(filepath) {
-      if (typeof filepath !== "string") {
-        throw new TypeError(utils.expectedType("filepath", "string", filepath));
-      }
-      return path2.basename(filepath);
-    };
-    helpers4.stem = function(filepath) {
-      if (typeof filepath !== "string") {
-        throw new TypeError(utils.expectedType("filepath", "string", filepath));
-      }
-      return path2.basename(filepath, path2.extname(filepath));
-    };
-    helpers4.extname = function(filepath) {
-      if (typeof filepath !== "string") {
-        throw new TypeError(utils.expectedType("filepath", "string", filepath));
-      }
-      return path2.extname(filepath);
-    };
-    helpers4.resolve = function(filepath) {
-      var args = [].slice.call(arguments);
-      var opts = util.options(this, args.pop());
-      var cwd = path2.resolve(opts.cwd || process.cwd());
-      args.unshift(cwd);
-      return path2.resolve.apply(path2, args);
-    };
-    helpers4.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("/");
-    };
+  return "";
+};
+var truncateWordsAlias = truncateWords;
+var uppercase = (str) => {
+  if (typeof str === "object" && str !== null && "fn" in str && typeof str.fn === "function") {
+    return String(str.fn()).toUpperCase();
   }
-});
-
-// 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 helpers4 = module2.exports;
-    helpers4.toRegex = function(str, locals, options) {
-      var opts = util.options({}, locals, options);
-      return new RegExp(str, opts.flags);
-    };
-    helpers4.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);
-    };
+  if (typeof str !== "string") return "";
+  return str.toUpperCase();
+};
+var upcase = (...args) => uppercase(...args);
+var helpers19 = [
+  {
+    name: "append",
+    category: "string",
+    compatibility: ["browser", "nodejs"],
+    fn: append
+  },
+  {
+    name: "camelcase",
+    category: "string",
+    compatibility: ["browser", "nodejs"],
+    fn: camelcase
+  },
+  {
+    name: "capitalize",
+    category: "string",
+    compatibility: ["browser", "nodejs"],
+    fn: capitalize
+  },
+  {
+    name: "capitalizeAll",
+    category: "string",
+    compatibility: ["browser", "nodejs"],
+    fn: capitalizeAll
+  },
+  {
+    name: "center",
+    category: "string",
+    compatibility: ["browser", "nodejs"],
+    fn: center
+  },
+  {
+    name: "chop",
+    category: "string",
+    compatibility: ["browser", "nodejs"],
+    fn: chopStr
+  },
+  {
+    name: "dashcase",
+    category: "string",
+    compatibility: ["browser", "nodejs"],
+    fn: dashcase
+  },
+  {
+    name: "dotcase",
+    category: "string",
+    compatibility: ["browser", "nodejs"],
+    fn: dotcase
+  },
+  {
+    name: "ellipsis",
+    category: "string",
+    compatibility: ["browser", "nodejs"],
+    fn: ellipsis
+  },
+  {
+    name: "hyphenate",
+    category: "string",
+    compatibility: ["browser", "nodejs"],
+    fn: hyphenate
+  },
+  {
+    name: "isString",
+    category: "string",
+    compatibility: ["browser", "nodejs"],
+    fn: isString
+  },
+  {
+    name: "lowercase",
+    category: "string",
+    compatibility: ["browser", "nodejs"],
+    fn: lowercase
+  },
+  {
+    name: "downcase",
+    category: "string",
+    compatibility: ["browser", "nodejs"],
+    fn: downcase
+  },
+  {
+    name: "occurrences",
+    category: "string",
+    compatibility: ["browser", "nodejs"],
+    fn: occurrences
+  },
+  {
+    name: "pascalcase",
+    category: "string",
+    compatibility: ["browser", "nodejs"],
+    fn: pascalcase
+  },
+  {
+    name: "pathcase",
+    category: "string",
+    compatibility: ["browser", "nodejs"],
+    fn: pathcase
+  },
+  {
+    name: "plusify",
+    category: "string",
+    compatibility: ["browser", "nodejs"],
+    fn: plusify
+  },
+  {
+    name: "prepend",
+    category: "string",
+    compatibility: ["browser", "nodejs"],
+    fn: prepend
+  },
+  {
+    name: "remove",
+    category: "string",
+    compatibility: ["browser", "nodejs"],
+    fn: remove
+  },
+  {
+    name: "removeFirst",
+    category: "string",
+    compatibility: ["browser", "nodejs"],
+    fn: removeFirst
+  },
+  {
+    name: "replace",
+    category: "string",
+    compatibility: ["browser", "nodejs"],
+    fn: replace
+  },
+  {
+    name: "replaceFirst",
+    category: "string",
+    compatibility: ["browser", "nodejs"],
+    fn: replaceFirst
+  },
+  {
+    name: "reverse",
+    category: "string",
+    compatibility: ["browser", "nodejs"],
+    fn: reverse
+  },
+  {
+    name: "sentence",
+    category: "string",
+    compatibility: ["browser", "nodejs"],
+    fn: sentence
+  },
+  {
+    name: "snakecase",
+    category: "string",
+    compatibility: ["browser", "nodejs"],
+    fn: snakecase
+  },
+  {
+    name: "trim",
+    category: "string",
+    compatibility: ["browser", "nodejs"],
+    fn: trim
+  },
+  {
+    name: "trimLeft",
+    category: "string",
+    compatibility: ["browser", "nodejs"],
+    fn: trimLeft
+  },
+  {
+    name: "trimRight",
+    category: "string",
+    compatibility: ["browser", "nodejs"],
+    fn: trimRight
+  },
+  {
+    name: "truncate",
+    category: "string",
+    compatibility: ["browser", "nodejs"],
+    fn: truncate
+  },
+  {
+    name: "truncateWords",
+    category: "string",
+    compatibility: ["browser", "nodejs"],
+    fn: truncateWordsAlias
+  },
+  {
+    name: "uppercase",
+    category: "string",
+    compatibility: ["browser", "nodejs"],
+    fn: uppercase
+  },
+  {
+    name: "upcase",
+    category: "string",
+    compatibility: ["browser", "nodejs"],
+    fn: upcase
   }
-});
+];
 
-// 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 helpers4 = module2.exports;
-    helpers4.append = function(str, suffix) {
-      if (typeof str === "string" && typeof suffix === "string") {
-        return str + suffix;
-      }
-      return str;
-    };
-    helpers4.camelcase = function(str) {
-      if (!util.isString(str)) return "";
-      return utils.changecase(str, function(ch) {
-        return ch.toUpperCase();
-      });
-    };
-    helpers4.capitalize = function(str) {
-      if (!util.isString(str)) return "";
-      return str.charAt(0).toUpperCase() + str.slice(1);
-    };
-    helpers4.capitalizeAll = function(str) {
-      if (!util.isString(str)) return "";
-      if (util.isString(str)) {
-        return str.replace(/\w\S*/g, function(word) {
-          return helpers4.capitalize(word);
-        });
-      }
-    };
-    helpers4.center = function(str, spaces) {
-      if (!util.isString(str)) return "";
-      var space = "";
-      var i = 0;
-      while (i < spaces) {
-        space += "&nbsp;";
-        i++;
-      }
-      return space + str + space;
-    };
-    helpers4.chop = function(str) {
-      if (!util.isString(str)) return "";
-      return utils.chop(str);
-    };
-    helpers4.dashcase = function(str) {
-      if (!util.isString(str)) return "";
-      return utils.changecase(str, function(ch) {
-        return "-" + ch;
-      });
-    };
-    helpers4.dotcase = function(str) {
-      if (!util.isString(str)) return "";
-      return utils.changecase(str, function(ch) {
-        return "." + ch;
-      });
-    };
-    helpers4.downcase = function() {
-      return helpers4.lowercase.apply(this, arguments);
-    };
-    helpers4.ellipsis = function(str, limit) {
-      if (util.isString(str)) {
-        if (str.length <= limit) {
-          return str;
-        }
-        return helpers4.truncate(str, limit) + "\u2026";
-      }
-    };
-    helpers4.hyphenate = function(str) {
-      if (!util.isString(str)) return "";
-      return str.split(" ").join("-");
-    };
-    helpers4.isString = function(value) {
-      return typeof value === "string";
-    };
-    helpers4.lowercase = function(str) {
-      if (util.isObject(str) && str.fn) {
-        return str.fn(this).toLowerCase();
-      }
-      if (!util.isString(str)) return "";
-      return str.toLowerCase();
-    };
-    helpers4.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;
-    };
-    helpers4.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);
-    };
-    helpers4.pathcase = function(str) {
-      if (!util.isString(str)) return "";
-      return utils.changecase(str, function(ch) {
-        return "/" + ch;
-      });
-    };
-    helpers4.plusify = function(str, ch) {
-      if (!util.isString(str)) return "";
-      if (!util.isString(ch)) ch = " ";
-      return str.split(ch).join("+");
-    };
-    helpers4.prepend = function(str, prefix) {
-      return typeof str === "string" && typeof prefix === "string" ? prefix + str : str;
-    };
-    helpers4.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;
-    };
-    helpers4.remove = function(str, ch) {
-      if (!util.isString(str)) return "";
-      if (!util.isString(ch)) return str;
-      return str.split(ch).join("");
-    };
-    helpers4.removeFirst = function(str, ch) {
-      if (!util.isString(str)) return "";
-      if (!util.isString(ch)) return str;
-      return str.replace(ch, "");
-    };
-    helpers4.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);
-    };
-    helpers4.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);
-    };
-    helpers4.reverse = function(str) {
-      if (!util.isString(str)) return "";
-      return str.split("").reverse().join("");
-    };
-    helpers4.sentence = function(str) {
-      if (!util.isString(str)) return "";
-      return str.replace(/((?:\S[^\.\?\!]*)[\.\?\!]*)/g, function(txt) {
-        return txt.charAt(0).toUpperCase() + txt.substr(1).toLowerCase();
-      });
-    };
-    helpers4.snakecase = function(str) {
-      if (!util.isString(str)) return "";
-      return utils.changecase(str, function(ch) {
-        return "_" + ch;
-      });
-    };
-    helpers4.split = function(str, ch) {
-      if (!util.isString(str)) return "";
-      if (!util.isString(ch)) ch = ",";
-      return str.split(ch);
-    };
-    helpers4.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 "";
-    };
-    helpers4.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(" ");
-    };
-    helpers4.trim = function(str) {
-      return typeof str === "string" ? str.trim() : "";
-    };
-    helpers4.trimLeft = function(str) {
-      if (util.isString(str)) {
-        return str.replace(/^\s+/, "");
-      }
-    };
-    helpers4.trimRight = function(str) {
-      if (util.isString(str)) {
-        return str.replace(/\s+$/, "");
-      }
-    };
-    helpers4.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;
-      }
-    };
-    helpers4.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;
-      }
-    };
-    helpers4.upcase = function() {
-      return helpers4.uppercase.apply(this, arguments);
-    };
-    helpers4.uppercase = function(str) {
-      if (util.isObject(str) && str.fn) {
-        return str.fn(this).toUpperCase();
-      }
-      if (!util.isString(str)) return "";
-      return str.toUpperCase();
-    };
+// src/helpers/url.ts
+import { escape as qsEscape } from "querystring";
+import { format, parse, resolve } from "url";
+var all = ["browser", "nodejs"];
+var encodeUri = (str) => {
+  if (typeof str === "string") {
+    return encodeURIComponent(str);
   }
-});
-
-// 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 helpers4 = module2.exports;
-    helpers4.encodeURI = function(str) {
-      if (util.isString(str)) {
-        return encodeURIComponent(str);
-      }
-    };
-    helpers4.escape = function(str) {
-      if (util.isString(str)) {
-        return querystring.escape(str);
-      }
-    };
-    helpers4.decodeURI = function(str) {
-      if (util.isString(str)) {
-        return decodeURIComponent(str);
-      }
-    };
-    helpers4.url_encode = function() {
-      return helpers4.encodeURI.apply(this, arguments);
-    };
-    helpers4.url_decode = function(val) {
-      return helpers4.decodeURI.apply(this, arguments);
-    };
-    helpers4.urlResolve = function(base, href) {
-      return url.resolve(base, href);
-    };
-    helpers4.urlParse = function(str) {
-      return url.parse(str);
-    };
-    helpers4.stripQuerystring = function(str) {
-      if (util.isString(str)) {
-        return str.split("?")[0];
-      }
-    };
-    helpers4.stripProtocol = function(str) {
-      if (util.isString(str)) {
-        var parsed = url.parse(str);
-        parsed.protocol = "";
-        return parsed.format();
-      }
-    };
+};
+var escapeFn = (str) => {
+  if (typeof str === "string") {
+    return qsEscape(str);
   }
-});
-
-// 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()
-    };
+};
+var decodeUri = (str) => {
+  if (typeof str === "string") {
+    return decodeURIComponent(str);
   }
-});
-
-// 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 helpers4(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();
+};
+function urlEncode(...args) {
+  return encodeUri.apply(this, args);
+}
+function urlDecode(...args) {
+  return decodeUri.apply(this, args);
+}
+var urlResolve = (base, href) => resolve(String(base), String(href));
+var urlParse = (str) => parse(String(str));
+var stripQuerystring = (str) => {
+  if (typeof str === "string") {
+    return str.split("?")[0];
   }
-});
-
-// src/index.ts
-var index_exports = {};
-__export(index_exports, {
-  Handlebars: () => Handlebars2,
-  HelperRegistry: () => HelperRegistry,
-  createHandlebars: () => createHandlebars,
-  fumanchu: () => fumanchu,
-  handlebars: () => handlebars,
-  helpers: () => helpers3
-});
-module.exports = __toCommonJS(index_exports);
-var HandlebarsLib = __toESM(require("handlebars"));
-var import_helpers = __toESM(require_helpers());
-
-// src/helpers/date.ts
-var import_chrono_node = require("chrono-node");
-var import_dayjs = __toESM(require("dayjs"));
-var year = () => (/* @__PURE__ */ new Date()).getFullYear().toString();
-var date = (humanReadableDate, formatString) => {
-  const parsedDate = (0, import_chrono_node.parseDate)(humanReadableDate);
-  if (!parsedDate) {
-    throw new Error(`Unable to parse date: ${humanReadableDate}`);
+};
+var stripProtocol = (str) => {
+  if (typeof str === "string") {
+    const parsed = parse(str);
+    parsed.protocol = "";
+    return format(parsed);
   }
-  return (0, import_dayjs.default)(parsedDate).format(formatString);
 };
-var helpers = [
+var helpers20 = [
   {
-    name: "year",
-    category: "date",
-    fn: year
+    name: "encodeURI",
+    category: "url",
+    compatibility: all,
+    fn: encodeUri
   },
   {
-    name: "date",
-    category: "date",
-    fn: date
+    name: "escape",
+    category: "url",
+    compatibility: ["nodejs"],
+    fn: escapeFn
   },
   {
-    /* Adding this in for legacy support */
-    name: "moment",
-    category: "date",
-    fn: date
-  }
-];
-
-// src/helpers/md.ts
-var import_node_fs = __toESM(require("fs"));
-var import_node_path = __toESM(require("path"));
-var import_node_process = __toESM(require("process"));
-var import_handlebars = __toESM(require("handlebars"));
-var import_remarkable = require("remarkable");
-var renderMarkdown = (input, options = {}) => {
-  const options_ = __spreadValues({ cwd: import_node_process.default.cwd() }, options);
-  const md = new import_remarkable.Remarkable({
-    breaks: true,
-    html: true,
-    langPrefix: "lang-",
-    typographer: false,
-    xhtmlOut: false
-  });
-  const filepath = import_node_path.default.resolve(options_.cwd, input);
-  let string_ = input;
-  if (import_node_fs.default.existsSync(filepath)) {
-    string_ = import_node_fs.default.readFileSync(filepath, "utf8");
-  }
-  return new import_handlebars.default.SafeString(md.render(string_));
-};
-var helpers2 = [
+    name: "decodeURI",
+    category: "url",
+    compatibility: all,
+    fn: decodeUri
+  },
   {
-    name: "md",
-    category: "markdown",
-    fn: renderMarkdown
+    name: "url_encode",
+    category: "url",
+    compatibility: all,
+    fn: urlEncode
+  },
+  {
+    name: "url_decode",
+    category: "url",
+    compatibility: all,
+    fn: urlDecode
+  },
+  {
+    name: "urlResolve",
+    category: "url",
+    compatibility: ["nodejs"],
+    fn: urlResolve
+  },
+  {
+    name: "urlParse",
+    category: "url",
+    compatibility: ["nodejs"],
+    fn: urlParse
+  },
+  {
+    name: "stripQuerystring",
+    category: "url",
+    compatibility: all,
+    fn: stripQuerystring
+  },
+  {
+    name: "stripProtocol",
+    category: "url",
+    compatibility: ["nodejs"],
+    fn: stripProtocol
   }
 ];
 
 // src/helper-registry.ts
 var HelperRegistry = class {
+  _helpers = [];
   constructor() {
-    this._helpers = [];
     this.init();
   }
+  /**
+   * Get all registered helpers.
+   * @returns {Helper[]} The array of registered helpers.
+   */
+  get helpers() {
+    return this._helpers;
+  }
+  /**
+   * Initialize the helper registry. This is performed during the construction of the registry such as new HelperRegistry().
+   */
   init() {
     this.registerHelpers(helpers);
+    this.registerHelpers(helpers3);
+    this.registerHelpers(helpers5);
+    this.registerHelpers(helpers6);
     this.registerHelpers(helpers2);
+    this.registerHelpers(helpers13);
+    this.registerHelpers(helpers7);
+    this.registerHelpers(helpers4);
+    this.registerHelpers(helpers8);
+    this.registerHelpers(helpers9);
+    this.registerHelpers(helpers10);
+    this.registerHelpers(helpers11);
+    this.registerHelpers(helpers12);
+    this.registerHelpers(helpers14);
+    this.registerHelpers(helpers15);
+    this.registerHelpers(helpers17);
+    this.registerHelpers(helpers18);
+    this.registerHelpers(helpers19);
+    this.registerHelpers(helpers20);
+    this.registerHelpers(helpers16);
   }
+  /**
+   * Register a helper.
+   * @param {Helper} helper The helper to register.
+   * @returns True if the helper was registered, false otherwise.
+   */
   register(helper) {
     const result = false;
     if (!this.has(helper.name)) {
@@ -2135,25 +2107,65 @@ var HelperRegistry = class {
     }
     return result;
   }
-  registerHelpers(helpers4) {
-    for (const helper of helpers4) {
+  /**
+   * Register multiple helpers.
+   * @param {Helper[]} helpers The array of helpers to register.
+   */
+  registerHelpers(helpers22) {
+    for (const helper of helpers22) {
       this.register(helper);
     }
   }
+  /**
+   * Check if a helper is registered.
+   * @param name The name of the helper.
+   * @returns True if the helper is registered, false otherwise.
+   */
   has(name) {
     return this._helpers.some((helper) => helper.name === name);
   }
+  /**
+   * Filter helpers by the given criteria.
+   * @param filter The filter criteria.
+   * @returns The filtered helpers.
+   */
   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)
-    );
+    let result = this._helpers;
+    if (filter.names) {
+      result = result.filter((helper) => filter.names?.includes(helper.name));
+    }
+    if (filter.categories) {
+      result = result.filter(
+        (helper) => filter.categories?.includes(helper.category)
+      );
+    }
+    if (filter.compatibility) {
+      result = result.filter(
+        (helper) => helper.compatibility?.some((c) => filter.compatibility?.includes(c))
+      );
+    }
+    return result;
   }
-  loadHandlebars(handlebars2) {
-    for (const helper of this._helpers) {
+  /**
+   * Load Handlebars helpers.
+   * @param {Handlebars} handlebars The Handlebars instance.
+   * @returns {void}
+   */
+  load(handlebars2, filters) {
+    let helpers22 = this._helpers;
+    if (filters) {
+      helpers22 = this.filter(filters);
+    }
+    for (const helper of helpers22) {
       handlebars2.registerHelper(helper.name, helper.fn);
     }
   }
-  swapHelpers(handlebars2) {
+  /**
+   * Swap Handlebars helpers. This is used when you want to swap out legacy helpers for fumanchu helpers.
+   * @param handlebars The Handlebars instance.
+   * @returns {void}
+   */
+  swap(handlebars2) {
     for (const helper of this._helpers) {
       handlebars2.unregisterHelper(helper.name);
       handlebars2.registerHelper(helper.name, helper.fn);
@@ -2164,41 +2176,35 @@ var HelperRegistry = class {
 // src/index.ts
 var Handlebars2 = HandlebarsLib;
 var handlebars = HandlebarsLib.create();
-var helpers3 = import_helpers.default;
-function createHandlebars() {
-  return __async(this, null, function* () {
-    const registry = new HelperRegistry();
-    const handlebars2 = HandlebarsLib.create();
-    const helpersFunction = yield import_helpers.default;
-    helpersFunction({ handlebars: handlebars2 });
-    registry.swapHelpers(handlebars2);
-    return handlebars2;
-  });
+function helpers21(options) {
+  const registry = new HelperRegistry();
+  registry.load(options.handlebars ?? options.hbs);
 }
-function fumanchu(options) {
+async function createHandlebars() {
   const registry = new HelperRegistry();
   const handlebars2 = HandlebarsLib.create();
-  registry.loadHandlebars(handlebars2);
+  registry.load(handlebars2);
+  if (process.env.NODE_ENV === "development") {
+    console.warn(
+      "createHandlebars will be deprecated in future versions, use `fumanchu` instead."
+    );
+  }
+  return handlebars2;
+}
+function fumanchu(options) {
+  const registry = new HelperRegistry();
+  let handlebars2 = HandlebarsLib.create();
+  if (options?.handlebars) {
+    handlebars2 = options.handlebars;
+  }
+  registry.load(handlebars2);
   return handlebars2;
 }
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  Handlebars,
+export {
+  Handlebars2 as Handlebars,
   HelperRegistry,
   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.
- */
+  helpers21 as helpers
+};