@jaredwray/fumanchu 4.4.0 → 4.5.0

package/dist/index.js

@@ -49,16 +49,16 @@ var join = (array, separator = ", ") => {
   if (!Array.isArray(array)) return "";
   return array.join(separator);
 };
-var forEach = function(collection, options) {
-  if (!Array.isArray(collection) || !options || typeof options.fn !== "function") {
-    return options?.inverse ? options.inverse(this) ?? "" : "";
+var forEach = function(collection, options2) {
+  if (!Array.isArray(collection) || !options2 || typeof options2.fn !== "function") {
+    return options2?.inverse ? options2.inverse(this) ?? "" : "";
   }
   if (collection.length === 0) {
-    return options.inverse ? options.inverse(this) ?? "" : "";
+    return options2.inverse ? options2.inverse(this) ?? "" : "";
   }
   const total = collection.length;
-  const hash = options.hash ?? {};
-  const baseData = options.data ? { ...options.data } : void 0;
+  const hash = options2.hash ?? {};
+  const baseData = options2.data ? { ...options2.data } : void 0;
   let result = "";
   for (let index = 0; index < total; index++) {
     const value = collection[index];
@@ -79,10 +79,334 @@ var forEach = function(collection, options) {
     } else {
       context = { value, ...hash, ...meta };
     }
-    result += options.fn(context, { data });
+    result += options2.fn(context, { data });
   }
   return result;
 };
+var inArray = function(array, value, options2) {
+  if (!Array.isArray(array) || !options2) {
+    return "";
+  }
+  const found = array.includes(value);
+  if (found && options2.fn) {
+    return options2.fn(this);
+  }
+  if (!found && options2.inverse) {
+    return options2.inverse(this);
+  }
+  return "";
+};
+var isArray = (value) => {
+  return Array.isArray(value);
+};
+var itemAt = (array, idx) => {
+  if (!Array.isArray(array)) return void 0;
+  return array[idx];
+};
+var equalsLength = function(value, targetLength, options2) {
+  const actualLength = length(value);
+  const isEqual = actualLength === targetLength;
+  if (options2 && (options2.fn || options2.inverse)) {
+    if (isEqual && options2.fn) {
+      return options2.fn(this);
+    }
+    if (!isEqual && options2.inverse) {
+      return options2.inverse(this);
+    }
+    return "";
+  }
+  return isEqual;
+};
+var some = function(array, iter, options2) {
+  if (!Array.isArray(array) || typeof iter !== "function" || !options2) {
+    return options2?.inverse ? options2.inverse(this) ?? "" : "";
+  }
+  const hasSome = array.some(iter);
+  if (hasSome && options2.fn) {
+    return options2.fn(this);
+  }
+  if (!hasSome && options2.inverse) {
+    return options2.inverse(this);
+  }
+  return "";
+};
+var eachIndex = function(array, options2) {
+  if (!Array.isArray(array) || !options2 || typeof options2.fn !== "function") {
+    return options2?.inverse ? options2.inverse(this) ?? "" : "";
+  }
+  if (array.length === 0) {
+    return options2.inverse ? options2.inverse(this) ?? "" : "";
+  }
+  let result = "";
+  for (let index = 0; index < array.length; index++) {
+    const context = {
+      item: array[index],
+      index
+    };
+    result += options2.fn(context);
+  }
+  return result;
+};
+var withAfter = function(array, idx, options2) {
+  if (!Array.isArray(array) || !options2 || typeof options2.fn !== "function") {
+    return "";
+  }
+  const sliced = array.slice(idx + 1);
+  if (sliced.length === 0) {
+    return options2.inverse ? options2.inverse(this) ?? "" : "";
+  }
+  let result = "";
+  for (const item of sliced) {
+    result += options2.fn(item);
+  }
+  return result;
+};
+var withBefore = function(array, idx, options2) {
+  if (!Array.isArray(array) || !options2 || typeof options2.fn !== "function") {
+    return "";
+  }
+  const sliced = array.slice(0, idx);
+  if (sliced.length === 0) {
+    return options2.inverse ? options2.inverse(this) ?? "" : "";
+  }
+  let result = "";
+  for (const item of sliced) {
+    result += options2.fn(item);
+  }
+  return result;
+};
+var withFirst = function(array, n, options2) {
+  let count = 1;
+  let opts = options2;
+  if (typeof n === "object" && n !== null && !Array.isArray(n)) {
+    opts = n;
+  } else if (typeof n === "number") {
+    count = n;
+  }
+  if (!Array.isArray(array) || !opts || typeof opts.fn !== "function") {
+    return "";
+  }
+  if (array.length === 0) {
+    return opts.inverse ? opts.inverse(this) ?? "" : "";
+  }
+  const items = array.slice(0, count);
+  let result = "";
+  for (const item of items) {
+    result += opts.fn(item);
+  }
+  return result;
+};
+var withLast = function(array, n, options2) {
+  let count = 1;
+  let opts = options2;
+  if (typeof n === "object" && n !== null && !Array.isArray(n)) {
+    opts = n;
+  } else if (typeof n === "number") {
+    count = n;
+  }
+  if (!Array.isArray(array) || !opts || typeof opts.fn !== "function") {
+    return "";
+  }
+  if (array.length === 0) {
+    return opts.inverse ? opts.inverse(this) ?? "" : "";
+  }
+  const items = array.slice(-count);
+  let result = "";
+  for (const item of items) {
+    result += opts.fn(item);
+  }
+  return result;
+};
+var withGroup = function(array, size, options2) {
+  if (!Array.isArray(array) || typeof size !== "number" || size <= 0 || !options2 || typeof options2.fn !== "function") {
+    return "";
+  }
+  if (array.length === 0) {
+    return options2.inverse ? options2.inverse(this) ?? "" : "";
+  }
+  let result = "";
+  const groups = [];
+  for (let i = 0; i < array.length; i += size) {
+    groups.push(array.slice(i, i + size));
+  }
+  for (const group of groups) {
+    result += options2.fn(group);
+  }
+  return result;
+};
+var withSort = function(array, prop, options2) {
+  let sortProp;
+  let opts = options2;
+  if (typeof prop === "object" && prop !== null && !Array.isArray(prop)) {
+    opts = prop;
+  } else if (typeof prop === "string") {
+    sortProp = prop;
+  }
+  if (!Array.isArray(array) || !opts || typeof opts.fn !== "function") {
+    return "";
+  }
+  if (array.length === 0) {
+    return opts.inverse ? opts.inverse(this) ?? "" : "";
+  }
+  const sorted = [...array];
+  if (sortProp) {
+    sorted.sort((a, b) => {
+      const aVal = a?.[sortProp];
+      const bVal = b?.[sortProp];
+      if (aVal === bVal) return 0;
+      if (aVal == null) return 1;
+      if (bVal == null) return -1;
+      if (typeof aVal === "string" && typeof bVal === "string") {
+        return aVal.localeCompare(bVal);
+      }
+      return aVal < bVal ? -1 : 1;
+    });
+  } else {
+    sorted.sort((a, b) => {
+      if (a === b) return 0;
+      if (a == null) return 1;
+      if (b == null) return -1;
+      if (typeof a === "string" && typeof b === "string") {
+        return a.localeCompare(b);
+      }
+      return a < b ? -1 : 1;
+    });
+  }
+  const shouldReverse = opts.hash?.reverse === true || opts.hash?.reverse === "true";
+  if (shouldReverse) {
+    sorted.reverse();
+  }
+  let result = "";
+  for (const item of sorted) {
+    result += opts.fn(item);
+  }
+  return result;
+};
+var filter = function(array, value, options2) {
+  if (!Array.isArray(array) || !options2) {
+    return options2?.inverse ? options2.inverse(this) ?? "" : "";
+  }
+  const filtered = array.filter((item) => item === value);
+  if (filtered.length > 0 && options2.fn) {
+    return options2.fn(this);
+  }
+  if (filtered.length === 0 && options2.inverse) {
+    return options2.inverse(this);
+  }
+  return "";
+};
+var map = (array, fn) => {
+  if (!Array.isArray(array) || typeof fn !== "function") {
+    return [];
+  }
+  return array.map(fn);
+};
+var pluck = (collection, prop) => {
+  if (!Array.isArray(collection) || typeof prop !== "string") {
+    return [];
+  }
+  return collection.map((item) => {
+    if (item == null || typeof item !== "object") {
+      return void 0;
+    }
+    const parts = prop.split(".");
+    let value = item;
+    for (const part of parts) {
+      if (value == null || typeof value !== "object") {
+        return void 0;
+      }
+      value = value[part];
+    }
+    return value;
+  });
+};
+var reverse = (value) => {
+  if (typeof value === "string") {
+    return value.split("").reverse().join("");
+  }
+  if (Array.isArray(value)) {
+    return [...value].reverse();
+  }
+  return void 0;
+};
+var sort = (array, key) => {
+  if (!Array.isArray(array)) {
+    return [];
+  }
+  const sorted = [...array];
+  if (typeof key === "function") {
+    sorted.sort(key);
+  } else if (typeof key === "string") {
+    sorted.sort((a, b) => {
+      const aVal = a?.[key];
+      const bVal = b?.[key];
+      if (aVal === bVal) return 0;
+      if (aVal == null) return 1;
+      if (bVal == null) return -1;
+      if (typeof aVal === "string" && typeof bVal === "string") {
+        return aVal.localeCompare(bVal);
+      }
+      return aVal < bVal ? -1 : 1;
+    });
+  } else {
+    sorted.sort((a, b) => {
+      if (a === b) return 0;
+      if (a == null) return 1;
+      if (b == null) return -1;
+      if (typeof a === "string" && typeof b === "string") {
+        return a.localeCompare(b);
+      }
+      return a < b ? -1 : 1;
+    });
+  }
+  return sorted;
+};
+var sortBy = (array, ...props) => {
+  if (!Array.isArray(array) || props.length === 0) {
+    return [];
+  }
+  const sorted = [...array];
+  sorted.sort((a, b) => {
+    for (const prop of props) {
+      const aVal = a?.[prop];
+      const bVal = b?.[prop];
+      if (aVal === bVal) continue;
+      if (aVal == null) return 1;
+      if (bVal == null) return -1;
+      if (typeof aVal === "string" && typeof bVal === "string") {
+        const result = aVal.localeCompare(bVal);
+        if (result !== 0) return result;
+      } else {
+        return aVal < bVal ? -1 : 1;
+      }
+    }
+    return 0;
+  });
+  return sorted;
+};
+var unique = function(array, options2) {
+  if (!Array.isArray(array)) {
+    if (!options2) {
+      return [];
+    }
+    return options2.inverse ? options2.inverse(this) ?? "" : "";
+  }
+  const uniqueArray = [...new Set(array)];
+  if (!options2) {
+    return uniqueArray;
+  }
+  if (uniqueArray.length === 0 && options2.inverse) {
+    return options2.inverse(this);
+  }
+  if (uniqueArray.length > 0 && options2.fn) {
+    let result = "";
+    for (const item of uniqueArray) {
+      result += options2.fn(item);
+    }
+    return result;
+  }
+  return "";
+};
 var helpers = [
   {
     name: "after",
@@ -131,6 +455,120 @@ var helpers = [
     category: "array",
     compatibility: ["browser", "nodejs"],
     fn: forEach
+  },
+  {
+    name: "inArray",
+    category: "array",
+    compatibility: ["browser", "nodejs"],
+    fn: inArray
+  },
+  {
+    name: "isArray",
+    category: "array",
+    compatibility: ["browser", "nodejs"],
+    fn: isArray
+  },
+  {
+    name: "itemAt",
+    category: "array",
+    compatibility: ["browser", "nodejs"],
+    fn: itemAt
+  },
+  {
+    name: "equalsLength",
+    category: "array",
+    compatibility: ["browser", "nodejs"],
+    fn: equalsLength
+  },
+  {
+    name: "some",
+    category: "array",
+    compatibility: ["browser", "nodejs"],
+    fn: some
+  },
+  {
+    name: "eachIndex",
+    category: "array",
+    compatibility: ["browser", "nodejs"],
+    fn: eachIndex
+  },
+  {
+    name: "withAfter",
+    category: "array",
+    compatibility: ["browser", "nodejs"],
+    fn: withAfter
+  },
+  {
+    name: "withBefore",
+    category: "array",
+    compatibility: ["browser", "nodejs"],
+    fn: withBefore
+  },
+  {
+    name: "withFirst",
+    category: "array",
+    compatibility: ["browser", "nodejs"],
+    fn: withFirst
+  },
+  {
+    name: "withLast",
+    category: "array",
+    compatibility: ["browser", "nodejs"],
+    fn: withLast
+  },
+  {
+    name: "withGroup",
+    category: "array",
+    compatibility: ["browser", "nodejs"],
+    fn: withGroup
+  },
+  {
+    name: "withSort",
+    category: "array",
+    compatibility: ["browser", "nodejs"],
+    fn: withSort
+  },
+  {
+    name: "filter",
+    category: "array",
+    compatibility: ["browser", "nodejs"],
+    fn: filter
+  },
+  {
+    name: "map",
+    category: "array",
+    compatibility: ["browser", "nodejs"],
+    fn: map
+  },
+  {
+    name: "pluck",
+    category: "array",
+    compatibility: ["browser", "nodejs"],
+    fn: pluck
+  },
+  {
+    name: "reverse",
+    category: "array",
+    compatibility: ["browser", "nodejs"],
+    fn: reverse
+  },
+  {
+    name: "sort",
+    category: "array",
+    compatibility: ["browser", "nodejs"],
+    fn: sort
+  },
+  {
+    name: "sortBy",
+    category: "array",
+    compatibility: ["browser", "nodejs"],
+    fn: sortBy
+  },
+  {
+    name: "unique",
+    category: "array",
+    compatibility: ["browser", "nodejs"],
+    fn: unique
   }
 ];
 
@@ -152,8 +590,8 @@ var embed = (filepath, language) => {
 var gist = (id) => {
   return tag("script", { src: `https://gist.github.com/${id}.js` });
 };
-var jsfiddle = (options) => {
-  if (!options || !options.id) {
+var jsfiddle = (options2) => {
+  if (!options2 || !options2.id) {
     throw new Error("jsfiddle helper expects an `id`");
   }
   const {
@@ -164,7 +602,7 @@ var jsfiddle = (options) => {
     tabs = "result,js,html,css",
     allowfullscreen = "allowfullscreen",
     frameborder = "0"
-  } = options;
+  } = options2;
   const src = `http://jsfiddle.net/${id}/embedded/${tabs}${skin}`;
   return tag("iframe", { width, height, src, allowfullscreen, frameborder });
 };
@@ -485,17 +923,164 @@ var helpers4 = [
 // src/helpers/date.ts
 import { parseDate } from "chrono-node";
 import dayjs from "dayjs";
+import isBetween from "dayjs/plugin/isBetween.js";
+import relativeTime from "dayjs/plugin/relativeTime.js";
+import timezone from "dayjs/plugin/timezone.js";
+import utc from "dayjs/plugin/utc.js";
+dayjs.extend(relativeTime);
+dayjs.extend(isBetween);
+dayjs.extend(utc);
+dayjs.extend(timezone);
+var parseDateInput = (input) => {
+  if (!input) {
+    return dayjs();
+  }
+  if (typeof input === "string") {
+    const parsed = parseDate(input);
+    if (parsed) {
+      return dayjs(parsed);
+    }
+    return dayjs(input);
+  }
+  return dayjs(input);
+};
 var year = () => (/* @__PURE__ */ new Date()).getFullYear().toString();
 var convertFormatString = (format2) => {
-  return format2.replace(/yyyy/g, "YYYY").replace(/yy/g, "YY").replace(/dd/g, "DD").replace(/mm/g, "MM").replace(/hh/g, "HH").replace(/ss/g, "SS");
+  return format2.replace(/yyyy/g, "YYYY").replace(/yy/g, "YY").replace(/dd/g, "DD").replace(/mm/g, "MM").replace(/hh/g, "HH");
 };
 var date = (humanReadableDate, formatString) => {
-  const parsedDate = parseDate(humanReadableDate);
-  if (!parsedDate) {
+  const defaultFormat = "YYYY-MM-DD";
+  const format2 = formatString || defaultFormat;
+  const parsedDate = parseDateInput(humanReadableDate);
+  if (!parsedDate.isValid()) {
     throw new Error(`Unable to parse date: ${humanReadableDate}`);
   }
-  const convertedFormat = convertFormatString(formatString);
-  return dayjs(parsedDate).format(convertedFormat);
+  const convertedFormat = convertFormatString(format2);
+  return parsedDate.format(convertedFormat);
+};
+var timestamp = () => {
+  return Date.now().toString();
+};
+var now = (formatString) => {
+  const defaultFormat = "YYYY-MM-DD HH:mm:ss";
+  const format2 = formatString || defaultFormat;
+  const convertedFormat = convertFormatString(format2);
+  return dayjs().format(convertedFormat);
+};
+var fromNow = (dateInput) => {
+  const parsed = parseDateInput(dateInput);
+  if (!parsed.isValid()) {
+    throw new Error(`Unable to parse date: ${dateInput}`);
+  }
+  return parsed.fromNow();
+};
+var toNow = (dateInput) => {
+  const parsed = parseDateInput(dateInput);
+  if (!parsed.isValid()) {
+    throw new Error(`Unable to parse date: ${dateInput}`);
+  }
+  return parsed.toNow();
+};
+var ago = (dateInput) => {
+  return fromNow(dateInput);
+};
+var dateAdd = (dateInput, amount, unit) => {
+  const parsed = parseDateInput(dateInput);
+  if (!parsed.isValid()) {
+    throw new Error(`Unable to parse date: ${dateInput}`);
+  }
+  return parsed.add(amount, unit).format("YYYY-MM-DD HH:mm:ss");
+};
+var dateSubtract = (dateInput, amount, unit) => {
+  const parsed = parseDateInput(dateInput);
+  if (!parsed.isValid()) {
+    throw new Error(`Unable to parse date: ${dateInput}`);
+  }
+  return parsed.subtract(amount, unit).format("YYYY-MM-DD HH:mm:ss");
+};
+var startOf = (dateInput, unit) => {
+  const parsed = parseDateInput(dateInput);
+  if (!parsed.isValid()) {
+    throw new Error(`Unable to parse date: ${dateInput}`);
+  }
+  return parsed.startOf(unit).format("YYYY-MM-DD HH:mm:ss");
+};
+var endOf = (dateInput, unit) => {
+  const parsed = parseDateInput(dateInput);
+  if (!parsed.isValid()) {
+    throw new Error(`Unable to parse date: ${dateInput}`);
+  }
+  return parsed.endOf(unit).format("YYYY-MM-DD HH:mm:ss");
+};
+var isBefore = (date1, date2) => {
+  const parsed1 = parseDateInput(date1);
+  const parsed2 = parseDateInput(date2);
+  if (!parsed1.isValid() || !parsed2.isValid()) {
+    throw new Error(`Unable to parse dates: ${date1}, ${date2}`);
+  }
+  return parsed1.isBefore(parsed2);
+};
+var isAfter = (date1, date2) => {
+  const parsed1 = parseDateInput(date1);
+  const parsed2 = parseDateInput(date2);
+  if (!parsed1.isValid() || !parsed2.isValid()) {
+    throw new Error(`Unable to parse dates: ${date1}, ${date2}`);
+  }
+  return parsed1.isAfter(parsed2);
+};
+var isSame = (date1, date2, unit) => {
+  const parsed1 = parseDateInput(date1);
+  const parsed2 = parseDateInput(date2);
+  if (!parsed1.isValid() || !parsed2.isValid()) {
+    throw new Error(`Unable to parse dates: ${date1}, ${date2}`);
+  }
+  return parsed1.isSame(parsed2, unit);
+};
+var isBetweenDates = (dateInput, startDate, endDate) => {
+  const parsed = parseDateInput(dateInput);
+  const parsedStart = parseDateInput(startDate);
+  const parsedEnd = parseDateInput(endDate);
+  if (!parsed.isValid() || !parsedStart.isValid() || !parsedEnd.isValid()) {
+    throw new Error(
+      `Unable to parse dates: ${dateInput}, ${startDate}, ${endDate}`
+    );
+  }
+  return parsed.isBetween(parsedStart, parsedEnd, null, "[]");
+};
+var diff = (date1, date2, unit) => {
+  const parsed1 = parseDateInput(date1);
+  const parsed2 = parseDateInput(date2);
+  if (!parsed1.isValid() || !parsed2.isValid()) {
+    throw new Error(`Unable to parse dates: ${date1}, ${date2}`);
+  }
+  return parsed1.diff(parsed2, unit);
+};
+var toISOString = (dateInput) => {
+  const parsed = parseDateInput(dateInput);
+  if (!parsed.isValid()) {
+    throw new Error(`Unable to parse date: ${dateInput}`);
+  }
+  return parsed.toISOString();
+};
+var dateTimezone = (dateInput, timezoneStr, formatString) => {
+  const defaultFormat = "YYYY-MM-DD HH:mm:ss";
+  const format2 = formatString || defaultFormat;
+  const convertedFormat = convertFormatString(format2);
+  const parsed = parseDateInput(dateInput);
+  if (!parsed.isValid()) {
+    throw new Error(`Unable to parse date: ${dateInput}`);
+  }
+  return parsed.tz(timezoneStr).format(convertedFormat);
+};
+var dateLocale = (dateInput, locale, formatString) => {
+  const defaultFormat = "YYYY-MM-DD HH:mm:ss";
+  const format2 = formatString || defaultFormat;
+  const convertedFormat = convertFormatString(format2);
+  const parsed = parseDateInput(dateInput);
+  if (!parsed.isValid()) {
+    throw new Error(`Unable to parse date: ${dateInput}`);
+  }
+  return parsed.locale(locale).format(convertedFormat);
 };
 var helpers5 = [
   {
@@ -516,6 +1101,108 @@ var helpers5 = [
     category: "date",
     compatibility: ["browser", "nodejs"],
     fn: date
+  },
+  {
+    name: "timestamp",
+    category: "date",
+    compatibility: ["browser", "nodejs"],
+    fn: timestamp
+  },
+  {
+    name: "now",
+    category: "date",
+    compatibility: ["browser", "nodejs"],
+    fn: now
+  },
+  {
+    name: "fromNow",
+    category: "date",
+    compatibility: ["browser", "nodejs"],
+    fn: fromNow
+  },
+  {
+    name: "toNow",
+    category: "date",
+    compatibility: ["browser", "nodejs"],
+    fn: toNow
+  },
+  {
+    name: "ago",
+    category: "date",
+    compatibility: ["browser", "nodejs"],
+    fn: ago
+  },
+  {
+    name: "dateAdd",
+    category: "date",
+    compatibility: ["browser", "nodejs"],
+    fn: dateAdd
+  },
+  {
+    name: "dateSubtract",
+    category: "date",
+    compatibility: ["browser", "nodejs"],
+    fn: dateSubtract
+  },
+  {
+    name: "startOf",
+    category: "date",
+    compatibility: ["browser", "nodejs"],
+    fn: startOf
+  },
+  {
+    name: "endOf",
+    category: "date",
+    compatibility: ["browser", "nodejs"],
+    fn: endOf
+  },
+  {
+    name: "isBefore",
+    category: "date",
+    compatibility: ["browser", "nodejs"],
+    fn: isBefore
+  },
+  {
+    name: "isAfter",
+    category: "date",
+    compatibility: ["browser", "nodejs"],
+    fn: isAfter
+  },
+  {
+    name: "isSame",
+    category: "date",
+    compatibility: ["browser", "nodejs"],
+    fn: isSame
+  },
+  {
+    name: "isBetween",
+    category: "date",
+    compatibility: ["browser", "nodejs"],
+    fn: isBetweenDates
+  },
+  {
+    name: "diff",
+    category: "date",
+    compatibility: ["browser", "nodejs"],
+    fn: diff
+  },
+  {
+    name: "toISOString",
+    category: "date",
+    compatibility: ["browser", "nodejs"],
+    fn: toISOString
+  },
+  {
+    name: "dateTimezone",
+    category: "date",
+    compatibility: ["browser", "nodejs"],
+    fn: dateTimezone
+  },
+  {
+    name: "dateLocale",
+    category: "date",
+    compatibility: ["browser", "nodejs"],
+    fn: dateLocale
   }
 ];
 
@@ -549,9 +1236,9 @@ var isOptions = (value) => {
     value && typeof value === "object" && "hash" in value
   );
 };
-var readdir = (dir, filter) => {
+var readdir = (dir, filter2) => {
   const files = fs2.readdirSync(dir).map((fp) => path2.join(dir, fp));
-  const filterArg = isOptions(filter) ? void 0 : filter;
+  const filterArg = isOptions(filter2) ? void 0 : filter2;
   if (typeof filterArg === "function") {
     return filterArg(files);
   }
@@ -597,13 +1284,13 @@ 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 ?? {});
+var attr = (options2) => {
+  const val = parseAttributes(options2?.hash ?? {});
   return val.trim() ? ` ${val}` : "";
 };
-var css = function(list, options) {
+var css = function(list, options2) {
   if (arguments.length < 2) {
-    options = list;
+    options2 = list;
     list = [];
   }
   let styles = arrayify(list ?? []);
@@ -611,8 +1298,8 @@ var css = function(list, options) {
   if (this && this.options) {
     assets = this.options.assets || "";
   }
-  if (options?.hash?.href) {
-    styles = arrayify(options.hash.href);
+  if (options2?.hash?.href) {
+    styles = arrayify(options2.hash.href);
   }
   return styles.map((item) => {
     const ext = path3.extname(item);
@@ -643,18 +1330,18 @@ var sanitize = (str) => {
   if (typeof str !== "string") return "";
   return striptags(str).trim();
 };
-var ul = (context, options) => {
-  const attrs = parseAttributes(options.hash ?? {});
+var ul = (context, options2) => {
+  const attrs = parseAttributes(options2.hash ?? {});
   const items = context.map(
-    (item) => typeof item === "string" ? item : options.fn(item)
+    (item) => typeof item === "string" ? item : options2.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 ?? {});
+var ol = (context, options2) => {
+  const attrs = parseAttributes(options2.hash ?? {});
   const items = context.map(
-    (item) => typeof item === "string" ? item : options.fn(item)
+    (item) => typeof item === "string" ? item : options2.fn(item)
   );
   const open = attrs ? `<ol ${attrs}>` : "<ol>";
   return `${open}${items.map((i) => `<li>${i}</li>`).join("\n")}</ol>`;
@@ -771,11 +1458,32 @@ var getObject = (object, path6) => {
   }
   return { [finalKey]: current[finalKey] };
 };
+var options = (thisArg, locals, opts) => {
+  const result = {};
+  if (thisArg && typeof thisArg === "object" && thisArg.options) {
+    Object.assign(result, thisArg.options);
+  }
+  if (locals && typeof locals === "object") {
+    if ("hash" in locals) {
+      Object.assign(result, locals.hash);
+    } else {
+      Object.assign(result, locals);
+    }
+  }
+  if (opts && typeof opts === "object") {
+    if ("hash" in opts) {
+      Object.assign(result, opts.hash);
+    } else {
+      Object.assign(result, opts);
+    }
+  }
+  return result;
+};
 
 // src/helpers/i18n.ts
-var i18n = function(prop, locals, options) {
-  if (locals && typeof locals === "object" && "hash" in locals && options === void 0) {
-    options = locals;
+var i18n = function(prop, locals, options2) {
+  if (locals && typeof locals === "object" && "hash" in locals && options2 === void 0) {
+    options2 = locals;
     locals = {};
   }
   if (typeof prop !== "string") {
@@ -784,7 +1492,7 @@ var i18n = function(prop, locals, options) {
   const context = {
     ...this,
     ...locals,
-    ...options?.hash ?? {}
+    ...options2?.hash ?? {}
   };
   const lang = context.language || context.lang;
   if (typeof lang !== "string") {
@@ -920,9 +1628,9 @@ function _debug(...args) {
   console.error(colors.cyan(separator));
   return "";
 }
-function _inspect(context, options) {
+function _inspect(context, options2) {
   const val = JSON.stringify(context, null, 2);
-  const type = options?.hash?.type || "html";
+  const type = options2?.hash?.type || "html";
   return switchOutput(type, val);
 }
 function switchOutput(type, json) {
@@ -1015,12 +1723,12 @@ var helpers10 = [
 
 // src/helpers/match.ts
 import micromatch2 from "micromatch";
-var match = (files, patterns, options) => {
+var match = (files, patterns, options2) => {
   const pats = typeof patterns === "string" ? patterns.split(/, */) : patterns;
-  return micromatch2(files, pats, options);
+  return micromatch2(files, pats, options2);
 };
-var isMatch = (filepath, pattern, options) => {
-  return micromatch2.isMatch(filepath, pattern, options);
+var isMatch = (filepath, pattern, options2) => {
+  return micromatch2.isMatch(filepath, pattern, options2);
 };
 var mm = (...args) => {
   console.log("the {{mm}} helper is depcrecated and will be removed");
@@ -1236,14 +1944,14 @@ import process2 from "process";
 import ent from "ent";
 import Handlebars from "handlebars";
 import { Remarkable } from "remarkable";
-var renderMarkdown = function(input, options) {
+var renderMarkdown = function(input, options2) {
   if (typeof input === "object" && input && "fn" in input && typeof input.fn === "function") {
-    options = input;
+    options2 = input;
     input = input.fn(this);
   } else if (typeof input !== "string") {
     input = "";
   }
-  const options_ = { cwd: process2.cwd(), ...options };
+  const options_ = { cwd: process2.cwd(), ...options2 };
   const md = new Remarkable({
     breaks: true,
     html: true,
@@ -1277,34 +1985,33 @@ var helpers13 = [
 
 // src/helpers/misc.ts
 import Handlebars2 from "handlebars";
-import util from "handlebars-utils";
 import kindOf from "kind-of";
-function frame(context, options) {
+function frame(context, options2) {
   if (typeof context === "object" && context !== null && "hash" in context) {
-    options = context;
-    context = options.data;
+    options2 = context;
+    context = options2.data;
   }
   const data = Handlebars2.createFrame(context || {});
-  if (typeof options !== "object" || options === null) {
-    options = {};
+  if (typeof options2 !== "object" || options2 === null) {
+    options2 = {};
   }
-  if (options.hash && typeof options.hash === "object") {
-    Object.assign(data, options.hash);
+  if (options2.hash && typeof options2.hash === "object") {
+    Object.assign(data, options2.hash);
   }
-  return options.fn(this, { data });
+  return options2.fn(this, { data });
 }
-function option(prop, locals, options) {
-  return get(util.options(this, locals, options), prop);
+function option(prop, locals, opts) {
+  return get(options(this, locals, opts), prop);
 }
-function noop(options) {
-  return options.fn(this);
+function noop(options2) {
+  return options2.fn(this);
 }
 var typeOf = kindOf;
-function withHash(options) {
-  if (options.hash && Object.keys(options.hash).length) {
-    return options.fn(options.hash);
+function withHash(options2) {
+  if (options2.hash && Object.keys(options2.hash).length) {
+    return options2.fn(options2.hash);
   }
-  return options.inverse(this);
+  return options2.inverse(this);
 }
 var helpers14 = [
   {
@@ -1464,8 +2171,8 @@ var helpers15 = [
 var isOptions2 = (value) => {
   return Boolean(value && typeof value === "object" && "hash" in value);
 };
-var createFrame = (options, hash) => ({
-  ...options?.data || {},
+var createFrame = (options2, hash) => ({
+  ...options2?.data || {},
   ...hash
 });
 var extend = (...objects) => {
@@ -1482,28 +2189,28 @@ var extend = (...objects) => {
   }
   return result;
 };
-var forIn = (obj, options) => {
-  if (!isOptions2(options)) {
-    return options?.inverse?.(obj) ?? "";
+var forIn = (obj, options2) => {
+  if (!isOptions2(options2)) {
+    return options2?.inverse?.(obj) ?? "";
   }
-  const data = createFrame(options, options.hash || {});
+  const data = createFrame(options2, options2.hash || {});
   let result = "";
   for (const key in obj) {
     data.key = key;
-    result += options.fn(obj[key], { data });
+    result += options2.fn(obj[key], { data });
   }
   return result;
 };
-var forOwn = (obj, options) => {
-  if (!isOptions2(options)) {
-    return options?.inverse?.(obj) ?? "";
+var forOwn = (obj, options2) => {
+  if (!isOptions2(options2)) {
+    return options2?.inverse?.(obj) ?? "";
   }
-  const data = createFrame(options, options.hash || {});
+  const data = createFrame(options2, options2.hash || {});
   let result = "";
   for (const key in obj) {
     if (Object.hasOwn(obj, key)) {
       data.key = key;
-      result += options.fn(obj[key], { data });
+      result += options2.fn(obj[key], { data });
     }
   }
   return result;
@@ -1517,10 +2224,10 @@ var toPath = (...prop) => {
   }
   return parts.join(".");
 };
-var getHelper = (prop, context, options) => {
+var getHelper = (prop, context, options2) => {
   const val = get(context, prop);
-  if (options && typeof options.fn === "function") {
-    return val ? options.fn(val) : options.inverse?.(context);
+  if (options2 && typeof options2.fn === "function") {
+    return val ? options2.fn(val) : options2.inverse?.(context);
   }
   return val;
 };
@@ -1550,17 +2257,17 @@ var merge = (context, ...objects) => {
 };
 var parseJSON = JSONparse;
 var stringify = JSONstringify;
-var pick = (props, context, options) => {
+var pick = (props, context, options2) => {
   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 (options2 && typeof options2.fn === "function") {
     if (Object.keys(result).length) {
-      return options.fn(result);
+      return options2.fn(result);
     }
-    return options.inverse?.(context);
+    return options2.inverse?.(context);
   }
   return result;
 };
@@ -1663,9 +2370,9 @@ var assertString = (name, value) => {
   }
   return value;
 };
-var absolute = function(filepath, options) {
+var absolute = function(filepath, options2) {
   const fp = assertString("filepath", filepath);
-  const cwd = options?.data?.root?.cwd ?? this?.cwd ?? process.cwd();
+  const cwd = options2?.data?.root?.cwd ?? this?.cwd ?? process.cwd();
   return path5.resolve(cwd, fp);
 };
 var dirname = (filepath) => {
@@ -1690,12 +2397,12 @@ var extname = (filepath) => {
   return path5.extname(fp);
 };
 var resolveFn = function(filepath, ...paths) {
-  let options;
+  let options2;
   const last2 = paths[paths.length - 1];
   if (typeof last2 === "object" && last2 && "data" in last2) {
-    options = paths.pop();
+    options2 = paths.pop();
   }
-  const cwd = options?.data?.root?.cwd ?? this?.cwd ?? process.cwd();
+  const cwd = options2?.data?.root?.cwd ?? this?.cwd ?? process.cwd();
   const all2 = [
     cwd,
     assertString("filepath", filepath),
@@ -1762,10 +2469,9 @@ var helpers17 = [
 ];
 
 // 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 toRegex = (str, locals, opts) => {
+  const mergedOpts = options({}, locals, opts);
+  return new RegExp(str, mergedOpts.flags);
 };
 var test = (str, regex) => {
   if (typeof str !== "string") {
@@ -1902,7 +2608,7 @@ var replaceFirst = (str, a, b) => {
   if (typeof b !== "string") b = "";
   return str.replace(a, b);
 };
-var reverse = (str) => typeof str === "string" ? str.split("").reverse().join("") : "";
+var reverse2 = (str) => typeof str === "string" ? str.split("").reverse().join("") : "";
 var sentence = (str) => {
   if (typeof str !== "string") return "";
   return str.replace(
@@ -1938,6 +2644,29 @@ var uppercase = (str) => {
   return str.toUpperCase();
 };
 var upcase = (str) => uppercase(str);
+var split = (str, character) => {
+  if (typeof str !== "string") return "";
+  if (typeof character !== "string") character = "";
+  return str.split(character);
+};
+var startsWith = (prefix, testString, _options) => {
+  if (typeof prefix !== "string" || typeof testString !== "string") {
+    return false;
+  }
+  return testString.startsWith(prefix);
+};
+var titleize = (str) => {
+  if (typeof str !== "string") return "";
+  return str.replace(/\w\S*/g, (word) => {
+    return word.charAt(0).toUpperCase() + word.slice(1).toLowerCase();
+  });
+};
+var raw = (options2) => {
+  if (options2 && typeof options2.fn === "function") {
+    return options2.fn();
+  }
+  return "";
+};
 var helpers19 = [
   {
     name: "append",
@@ -2075,7 +2804,7 @@ var helpers19 = [
     name: "reverse",
     category: "string",
     compatibility: ["browser", "nodejs"],
-    fn: reverse
+    fn: reverse2
   },
   {
     name: "sentence",
@@ -2130,6 +2859,30 @@ var helpers19 = [
     category: "string",
     compatibility: ["browser", "nodejs"],
     fn: upcase
+  },
+  {
+    name: "split",
+    category: "string",
+    compatibility: ["browser", "nodejs"],
+    fn: split
+  },
+  {
+    name: "startsWith",
+    category: "string",
+    compatibility: ["browser", "nodejs"],
+    fn: startsWith
+  },
+  {
+    name: "titleize",
+    category: "string",
+    compatibility: ["browser", "nodejs"],
+    fn: titleize
+  },
+  {
+    name: "raw",
+    category: "string",
+    compatibility: ["browser", "nodejs"],
+    fn: raw
   }
 ];
 
@@ -2301,19 +3054,19 @@ var HelperRegistry = class {
    * @param filter The filter criteria.
    * @returns The filtered helpers.
    */
-  filter(filter) {
+  filter(filter2) {
     let result = this._helpers;
-    if (filter.names) {
-      result = result.filter((helper) => filter.names?.includes(helper.name));
+    if (filter2.names) {
+      result = result.filter((helper) => filter2.names?.includes(helper.name));
     }
-    if (filter.categories) {
+    if (filter2.categories) {
       result = result.filter(
-        (helper) => filter.categories?.includes(helper.category)
+        (helper) => filter2.categories?.includes(helper.category)
       );
     }
-    if (filter.compatibility) {
+    if (filter2.compatibility) {
       result = result.filter(
-        (helper) => helper.compatibility?.some((c) => filter.compatibility?.includes(c))
+        (helper) => helper.compatibility?.some((c) => filter2.compatibility?.includes(c))
       );
     }
     return result;
@@ -2348,9 +3101,9 @@ var HelperRegistry = class {
 // src/index.ts
 var Handlebars3 = HandlebarsLib;
 var handlebars = HandlebarsLib.create();
-function helpers21(options) {
+function helpers21(options2) {
   const registry = new HelperRegistry();
-  registry.load(options.handlebars ?? options.hbs);
+  registry.load(options2.handlebars ?? options2.hbs);
 }
 async function createHandlebars() {
   const registry = new HelperRegistry();
@@ -2366,11 +3119,11 @@ async function createHandlebars() {
   }
   return handlebars2;
 }
-function fumanchu(options) {
+function fumanchu(options2) {
   const registry = new HelperRegistry();
   let handlebars2 = HandlebarsLib.create();
-  if (options?.handlebars) {
-    handlebars2 = options.handlebars;
+  if (options2?.handlebars) {
+    handlebars2 = options2.handlebars;
   } else if (Object.keys(HandlebarsLib.partials).length > 0) {
     handlebars2.registerPartial(HandlebarsLib.partials);
   }
@@ -2385,4 +3138,5 @@ export {
   handlebars,
   helpers21 as helpers
 };
+/* v8 ignore next -- @preserve */
 /* c8 ignore next -- @preserve */