@jaredwray/fumanchu 4.6.0 → 4.7.0

package/dist/index.node.mjs

@@ -0,0 +1,3023 @@
+import { CacheableMemory } from "@cacheable/memory";
+import HandlebarsLib from "handlebars";
+import fs from "node:fs";
+import path from "node:path";
+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";
+import micromatch from "micromatch";
+import process$1 from "node:process";
+import ent from "ent";
+import MarkdownIt from "markdown-it";
+import { escape } from "node:querystring";
+import { format, parse, resolve } from "node:url";
+//#region src/helper-registry-base.ts
+/**
+* Base class for helper registries. Holds all state-management logic and
+* leaves `init()` empty so environment-specific subclasses decide which
+* helper sets to register. This lets the browser registry avoid importing
+* any Node-only helper files.
+*/
+var HelperRegistryBase = class {
+	_helpers = [];
+	constructor() {
+		this.init();
+	}
+	/**
+	* Get all registered helpers.
+	*/
+	get helpers() {
+		return this._helpers;
+	}
+	/**
+	* Initialize the helper registry. Overridden by subclasses.
+	*/
+	init() {}
+	/**
+	* Register a helper. Returns true if the helper was added, false if a
+	* helper with the same name was already present.
+	*/
+	register(helper) {
+		if (this.has(helper.name)) return false;
+		this._helpers.push(helper);
+		return true;
+	}
+	/**
+	* Register multiple helpers.
+	*/
+	registerHelpers(helpers) {
+		for (const helper of helpers) this.register(helper);
+	}
+	/**
+	* Check if a helper is registered.
+	*/
+	has(name) {
+		return this._helpers.some((helper) => helper.name === name);
+	}
+	/**
+	* Filter helpers by the given criteria.
+	*/
+	filter(filter) {
+		let result = this._helpers;
+		if (filter.names) {
+			const names = filter.names;
+			result = result.filter((helper) => names.includes(helper.name));
+		}
+		if (filter.categories) {
+			const categories = filter.categories;
+			result = result.filter((helper) => categories.includes(helper.category));
+		}
+		if (filter.compatibility) {
+			const compatibility = filter.compatibility;
+			result = result.filter((helper) => helper.compatibility?.some((c) => compatibility.includes(c)));
+		}
+		return result;
+	}
+	/**
+	* Load Handlebars helpers.
+	*/
+	load(handlebars, filters) {
+		let helpers = this._helpers;
+		if (filters) helpers = this.filter(filters);
+		for (const helper of helpers) handlebars.registerHelper(helper.name, helper.fn);
+	}
+	/**
+	* Swap Handlebars helpers. This is used when you want to swap out legacy
+	* helpers for fumanchu helpers.
+	*/
+	swap(handlebars) {
+		for (const helper of this._helpers) handlebars.registerHelper(helper.name, helper.fn);
+	}
+};
+//#endregion
+//#region src/helpers/array.ts
+const after = (array, n) => {
+	if (!Array.isArray(array)) return [];
+	return array.slice(n);
+};
+const before = (array, n) => {
+	if (!Array.isArray(array)) return [];
+	return array.slice(0, -n);
+};
+const arrayify = (value) => {
+	if (value == null) return [];
+	return Array.isArray(value) ? value : [value];
+};
+const first = (array, n) => {
+	if (!Array.isArray(array)) return void 0;
+	if (typeof n !== "number") return array[0];
+	return array.slice(0, n);
+};
+const last = (value, n) => {
+	if (!Array.isArray(value) && typeof value !== "string") return;
+	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);
+};
+const 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;
+};
+const join = (array, separator = ", ") => {
+	if (typeof array === "string") return array;
+	if (!Array.isArray(array)) return "";
+	return array.join(separator);
+};
+const forEach = function(collection, options) {
+	if (!Array.isArray(collection) || !options || typeof options.fn !== "function") return options?.inverse ? options.inverse(this) ?? "" : "";
+	if (collection.length === 0) return options.inverse ? options.inverse(this) ?? "" : "";
+	const total = collection.length;
+	const hash = options.hash ?? {};
+	const baseData = options.data ? { ...options.data } : void 0;
+	let result = "";
+	for (let index = 0; index < total; index++) {
+		const value = collection[index];
+		const meta = {
+			index,
+			total,
+			isFirst: index === 0,
+			isLast: index === total - 1
+		};
+		const data = {
+			...baseData ? { ...baseData } : {},
+			...hash,
+			...meta
+		};
+		let context;
+		if (value != null && typeof value === "object") context = {
+			...value,
+			...hash,
+			...meta
+		};
+		else context = {
+			value,
+			...hash,
+			...meta
+		};
+		result += options.fn(context, { data });
+	}
+	return result;
+};
+const inArray = function(array, value, options) {
+	if (!Array.isArray(array) || !options) return "";
+	const found = array.includes(value);
+	if (found && options.fn) return options.fn(this);
+	if (!found && options.inverse) return options.inverse(this);
+	return "";
+};
+const isArray = (value) => {
+	return Array.isArray(value);
+};
+const itemAt = (array, idx) => {
+	if (!Array.isArray(array)) return void 0;
+	return array[idx];
+};
+const equalsLength = function(value, targetLength, options) {
+	const isEqual = length(value) === targetLength;
+	if (options && (options.fn || options.inverse)) {
+		if (isEqual && options.fn) return options.fn(this);
+		if (!isEqual && options.inverse) return options.inverse(this);
+		return "";
+	}
+	return isEqual;
+};
+const some = function(array, iter, options) {
+	/* v8 ignore next -- @preserve */
+	if (!Array.isArray(array) || typeof iter !== "function" || !options) return options?.inverse ? options.inverse(this) ?? "" : "";
+	const hasSome = array.some(iter);
+	if (hasSome && options.fn) return options.fn(this);
+	if (!hasSome && options.inverse) return options.inverse(this);
+	return "";
+};
+const eachIndex = function(array, options) {
+	if (!Array.isArray(array) || !options || typeof options.fn !== "function") return options?.inverse ? options.inverse(this) ?? "" : "";
+	/* v8 ignore next -- @preserve */
+	if (array.length === 0) return options.inverse ? options.inverse(this) ?? "" : "";
+	let result = "";
+	for (let index = 0; index < array.length; index++) {
+		const context = {
+			item: array[index],
+			index
+		};
+		result += options.fn(context);
+	}
+	return result;
+};
+const withAfter = function(array, idx, options) {
+	if (!Array.isArray(array) || !options || typeof options.fn !== "function") return "";
+	const sliced = array.slice(idx + 1);
+	/* v8 ignore next -- @preserve */
+	if (sliced.length === 0) return options.inverse ? options.inverse(this) ?? "" : "";
+	let result = "";
+	for (const item of sliced) result += options.fn(item);
+	return result;
+};
+const withBefore = function(array, idx, options) {
+	if (!Array.isArray(array) || !options || typeof options.fn !== "function") return "";
+	const sliced = array.slice(0, idx);
+	/* v8 ignore next -- @preserve */
+	if (sliced.length === 0) return options.inverse ? options.inverse(this) ?? "" : "";
+	let result = "";
+	for (const item of sliced) result += options.fn(item);
+	return result;
+};
+const withFirst = function(array, n, options) {
+	let count = 1;
+	let opts = options;
+	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 "";
+	/* v8 ignore next -- @preserve */
+	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;
+};
+const withLast = function(array, n, options) {
+	let count = 1;
+	let opts = options;
+	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 "";
+	/* v8 ignore next -- @preserve */
+	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;
+};
+const withGroup = function(array, size, options) {
+	if (!Array.isArray(array) || typeof size !== "number" || size <= 0 || !options || typeof options.fn !== "function") return "";
+	/* v8 ignore next -- @preserve */
+	if (array.length === 0) return options.inverse ? options.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 += options.fn(group);
+	return result;
+};
+const withSort = function(array, prop, options) {
+	let sortProp;
+	let opts = options;
+	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 "";
+	/* v8 ignore next -- @preserve */
+	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];
+		/* v8 ignore next -- @preserve */
+		if (aVal === bVal) return 0;
+		if (aVal == null) return 1;
+		if (bVal == null) return -1;
+		/* v8 ignore next -- @preserve */
+		if (typeof aVal === "string" && typeof bVal === "string") return aVal.localeCompare(bVal);
+		/* v8 ignore next -- @preserve */
+		return aVal < bVal ? -1 : 1;
+	});
+	else sorted.sort((a, b) => {
+		/* v8 ignore next -- @preserve */
+		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;
+	});
+	if (opts.hash?.reverse === true || opts.hash?.reverse === "true") sorted.reverse();
+	let result = "";
+	for (const item of sorted) result += opts.fn(item);
+	return result;
+};
+const filter = function(array, value, options) {
+	/* v8 ignore next -- @preserve */
+	if (!Array.isArray(array) || !options) return options?.inverse ? options.inverse(this) ?? "" : "";
+	const filtered = array.filter((item) => item === value);
+	if (filtered.length > 0 && options.fn) return options.fn(this);
+	/* v8 ignore next -- @preserve */
+	if (filtered.length === 0 && options.inverse) return options.inverse(this);
+	/* v8 ignore next -- @preserve */
+	return "";
+};
+const map = (array, fn) => {
+	if (!Array.isArray(array) || typeof fn !== "function") return [];
+	return array.map(fn);
+};
+const pluck = (collection, prop) => {
+	if (!Array.isArray(collection) || typeof prop !== "string") return [];
+	return collection.map((item) => {
+		if (item == null || typeof item !== "object") return;
+		const parts = prop.split(".");
+		let value = item;
+		for (const part of parts) {
+			/* v8 ignore next -- @preserve */
+			if (value == null || typeof value !== "object") return;
+			value = value[part];
+		}
+		return value;
+	});
+};
+const reverse$1 = (value) => {
+	if (typeof value === "string") return value.split("").reverse().join("");
+	if (Array.isArray(value)) return [...value].reverse();
+};
+const sort = (array, key) => {
+	if (!Array.isArray(array)) return [];
+	const sorted = [...array];
+	if (typeof key === "function") sorted.sort(key);
+	else if (typeof key === "string")
+ /* v8 ignore next -- @preserve */
+	sorted.sort((a, b) => {
+		const aVal = a?.[key];
+		const bVal = b?.[key];
+		/* v8 ignore next -- @preserve */
+		if (aVal === bVal) return 0;
+		/* v8 ignore next -- @preserve */
+		if (aVal == null) return 1;
+		if (bVal == null) return -1;
+		if (typeof aVal === "string" && typeof bVal === "string") return aVal.localeCompare(bVal);
+		/* v8 ignore next -- @preserve */
+		return aVal < bVal ? -1 : 1;
+	});
+	else sorted.sort((a, b) => {
+		/* v8 ignore next -- @preserve */
+		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;
+};
+const 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);
+				/* v8 ignore next -- @preserve */
+				if (result !== 0) return result;
+			} else return aVal < bVal ? -1 : 1;
+		}
+		/* v8 ignore next -- @preserve */
+		return 0;
+	});
+	return sorted;
+};
+const unique = function(array, options) {
+	if (!Array.isArray(array)) {
+		/* v8 ignore next -- @preserve */
+		if (!options) return [];
+		/* v8 ignore next -- @preserve */
+		return options.inverse ? options.inverse(this) ?? "" : "";
+	}
+	const uniqueArray = [...new Set(array)];
+	if (!options) return uniqueArray;
+	if (uniqueArray.length === 0 && options.inverse) return options.inverse(this);
+	if (uniqueArray.length > 0 && options.fn) {
+		let result = "";
+		for (const item of uniqueArray) result += options.fn(item);
+		return result;
+	}
+	return "";
+};
+const helpers$23 = [
+	{
+		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
+	},
+	{
+		name: "forEach",
+		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$1
+	},
+	{
+		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
+	}
+];
+//#endregion
+//#region src/helpers/html.ts
+const isTagStart = (ch) => ch !== void 0 && (ch === "/" || ch === "!" || ch === "?" || /[a-zA-Z]/.test(ch));
+const stripTags = (str) => {
+	let result = "";
+	let inTag = false;
+	let inComment = false;
+	let quote = null;
+	for (let i = 0; i < str.length; i++) {
+		const ch = str[i];
+		if (inComment) {
+			if (ch === "-" && str[i + 1] === "-" && str[i + 2] === ">") {
+				inComment = false;
+				i += 2;
+			}
+			continue;
+		}
+		if (inTag) {
+			if (quote) {
+				if (ch === quote) quote = null;
+			} else if (ch === "\"" || ch === "'") quote = ch;
+			else if (ch === ">") inTag = false;
+			continue;
+		}
+		if (ch === "<") {
+			if (str[i + 1] === "!" && str[i + 2] === "-" && str[i + 3] === "-") {
+				inComment = true;
+				i += 3;
+				continue;
+			}
+			if (isTagStart(str[i + 1])) {
+				inTag = true;
+				continue;
+			}
+		}
+		result += ch;
+	}
+	return result;
+};
+const VOID_ELEMENTS = new Set([
+	"area",
+	"base",
+	"br",
+	"col",
+	"command",
+	"embed",
+	"hr",
+	"img",
+	"input",
+	"keygen",
+	"link",
+	"meta",
+	"param",
+	"source",
+	"track",
+	"wbr",
+	"circle",
+	"ellipse",
+	"line",
+	"path",
+	"polygon",
+	"polyline",
+	"rect",
+	"stop",
+	"use"
+]);
+const tag = (name, attribs = {}, text = "") => {
+	let html = `<${name}`;
+	for (const [key, val] of Object.entries(attribs)) if (val === true) html += ` ${key}`;
+	else if (typeof val === "string" || typeof val === "number") html += ` ${key}="${escapeAttr(String(val))}"`;
+	if (VOID_ELEMENTS.has(name.toLowerCase())) return `${html}>`;
+	return `${html}>${escapeText(text)}</${name}>`;
+};
+const escapeAttr = (str) => str.replace(/&/g, "&amp;").replace(/"/g, "&quot;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+const escapeText = (str) => str.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+const parseAttributes = (hash = {}) => Object.keys(hash).map((key) => `${key}="${String(hash[key]).replace(/^['"]|["']$/g, "")}"`).join(" ");
+const attr = (options) => {
+	const val = parseAttributes(options?.hash ?? {});
+	return val.trim() ? ` ${val}` : "";
+};
+const sanitize = (str) => {
+	if (typeof str !== "string") return "";
+	return stripTags(str).trim();
+};
+const ul = (context, options) => {
+	const attrs = parseAttributes(options.hash ?? {});
+	const items = context.map((item) => typeof item === "string" ? item : options.fn(item));
+	return `${attrs ? `<ul ${attrs}>` : "<ul>"}${items.map((i) => `<li>${i}</li>`).join("\n")}</ul>`;
+};
+const ol = (context, options) => {
+	const attrs = parseAttributes(options.hash ?? {});
+	const items = context.map((item) => typeof item === "string" ? item : options.fn(item));
+	return `${attrs ? `<ol ${attrs}>` : "<ol>"}${items.map((i) => `<li>${i}</li>`).join("\n")}</ol>`;
+};
+const 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"
+	};
+	/* c8 ignore next -- @preserve */
+	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)}>\n`;
+	image += `<img ${parseAttributes(imageAttributes)}>\n`;
+	if (link) figure += `<a ${parseAttributes(linkAttributes)}>\n${image}</a>\n`;
+	else figure += image;
+	/* c8 ignore next -- @preserve */
+	if (context.caption) figure += `<figcaption>${context.caption}</figcaption>\n`;
+	figure += "</figure>";
+	return figure;
+};
+const helpers$22 = [
+	{
+		name: "attr",
+		category: "html",
+		compatibility: ["browser", "nodejs"],
+		fn: attr
+	},
+	{
+		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
+	}
+];
+//#endregion
+//#region src/helpers/code.ts
+const gist = (id) => {
+	return tag("script", { src: `https://gist.github.com/${id}.js` });
+};
+const jsfiddle = (options) => {
+	if (!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;
+	return tag("iframe", {
+		width,
+		height,
+		src: `http://jsfiddle.net/${id}/embedded/${tabs}${skin}`,
+		allowfullscreen,
+		frameborder
+	});
+};
+const helpers$21 = [{
+	name: "gist",
+	category: "code",
+	compatibility: ["browser", "nodejs"],
+	fn: gist
+}, {
+	name: "jsfiddle",
+	category: "code",
+	compatibility: ["browser", "nodejs"],
+	fn: jsfiddle
+}];
+//#endregion
+//#region src/helpers/code.node.ts
+const codeBlock = (code, lang) => {
+	return `\`\`\`${lang}\n${code}\n\`\`\`\n`;
+};
+const 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()}\n`;
+};
+const helpers$20 = [{
+	name: "embed",
+	category: "code",
+	compatibility: ["nodejs"],
+	fn: embed
+}];
+//#endregion
+//#region src/helpers/collection.ts
+const 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;
+};
+const iterate = (collection, fn, inverse) => {
+	if (Array.isArray(collection)) {
+		let result = "";
+		for (let i = 0; i < collection.length; i++) result += fn(collection[i], i);
+		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() : "";
+};
+const helpers$19 = [{
+	name: "isEmpty",
+	category: "collection",
+	compatibility: ["browser", "nodejs"],
+	fn: isEmpty
+}, {
+	name: "iterate",
+	category: "collection",
+	compatibility: ["browser", "nodejs"],
+	fn: iterate
+}];
+//#endregion
+//#region src/helpers/comparison.ts
+const and = (...values) => values.every(Boolean);
+const compare = (a, operator, b) => {
+	switch (operator) {
+		case "==": return a == b;
+		case "===": return a === b;
+		case "!=": return a != b;
+		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}'`);
+	}
+};
+const 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;
+};
+const defaultHelper = (...values) => {
+	for (const val of values) if (val != null) return val;
+	return "";
+};
+const eq = (a, b) => a === b;
+const gt = (a, b) => a > b;
+const gte = (a, b) => a >= b;
+const 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;
+};
+const 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;
+};
+const isFalsey = (val) => falsey(val);
+const isTruthy = (val) => !falsey(val);
+const ifEven = (num) => typeof num === "number" && num % 2 === 0;
+const ifNth = (a, b) => typeof a === "number" && typeof b === "number" && b % a === 0;
+const ifOdd = (val) => typeof val === "number" && Math.abs(val % 2) === 1;
+const is = (a, b) => a == b;
+const isnt = (a, b) => a != b;
+const lt = (a, b) => a < b;
+const lte = (a, b) => a <= b;
+const neither = (a, b) => !a && !b;
+const not = (val) => !val;
+const or = (...values) => values.some(Boolean);
+const unlessEq = (a, b) => a !== b;
+const unlessGt = (a, b) => a <= b;
+const unlessLt = (a, b) => a >= b;
+const unlessGteq = (a, b) => a < b;
+const unlessLteq = (a, b) => a > b;
+const helpers$18 = [
+	{
+		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
+	}
+];
+//#endregion
+//#region src/helpers/date.ts
+dayjs.extend(relativeTime);
+dayjs.extend(isBetween);
+dayjs.extend(utc);
+dayjs.extend(timezone);
+const 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);
+};
+const year = () => (/* @__PURE__ */ new Date()).getFullYear().toString();
+const convertFormatString = (format) => {
+	return format.replace(/yyyy/g, "YYYY").replace(/yy/g, "YY").replace(/dd/g, "DD").replace(/mm/g, "MM").replace(/hh/g, "HH");
+};
+const date = (humanReadableDate, formatString) => {
+	const format = formatString || "YYYY-MM-DD";
+	const parsedDate = parseDateInput(humanReadableDate);
+	/* v8 ignore next -- @preserve */
+	if (!parsedDate.isValid()) throw new Error(`Unable to parse date: ${humanReadableDate}`);
+	const convertedFormat = convertFormatString(format);
+	return parsedDate.format(convertedFormat);
+};
+const timestamp = () => {
+	return Date.now().toString();
+};
+const now = (formatString) => {
+	const convertedFormat = convertFormatString(formatString || "YYYY-MM-DD HH:mm:ss");
+	return dayjs().format(convertedFormat);
+};
+const fromNow = (dateInput) => {
+	const parsed = parseDateInput(dateInput);
+	/* v8 ignore next -- @preserve */
+	if (!parsed.isValid()) throw new Error(`Unable to parse date: ${dateInput}`);
+	return parsed.fromNow();
+};
+const toNow = (dateInput) => {
+	const parsed = parseDateInput(dateInput);
+	/* v8 ignore next -- @preserve */
+	if (!parsed.isValid()) throw new Error(`Unable to parse date: ${dateInput}`);
+	return parsed.toNow();
+};
+const ago = (dateInput) => {
+	return fromNow(dateInput);
+};
+const dateAdd = (dateInput, amount, unit) => {
+	const parsed = parseDateInput(dateInput);
+	/* v8 ignore next -- @preserve */
+	if (!parsed.isValid()) throw new Error(`Unable to parse date: ${dateInput}`);
+	return parsed.add(amount, unit).format("YYYY-MM-DD HH:mm:ss");
+};
+const dateSubtract = (dateInput, amount, unit) => {
+	const parsed = parseDateInput(dateInput);
+	/* v8 ignore next -- @preserve */
+	if (!parsed.isValid()) throw new Error(`Unable to parse date: ${dateInput}`);
+	return parsed.subtract(amount, unit).format("YYYY-MM-DD HH:mm:ss");
+};
+const startOf = (dateInput, unit) => {
+	const parsed = parseDateInput(dateInput);
+	/* v8 ignore next -- @preserve */
+	if (!parsed.isValid()) throw new Error(`Unable to parse date: ${dateInput}`);
+	return parsed.startOf(unit).format("YYYY-MM-DD HH:mm:ss");
+};
+const endOf = (dateInput, unit) => {
+	const parsed = parseDateInput(dateInput);
+	/* v8 ignore next -- @preserve */
+	if (!parsed.isValid()) throw new Error(`Unable to parse date: ${dateInput}`);
+	return parsed.endOf(unit).format("YYYY-MM-DD HH:mm:ss");
+};
+const isBefore = (date1, date2) => {
+	const parsed1 = parseDateInput(date1);
+	const parsed2 = parseDateInput(date2);
+	/* v8 ignore next -- @preserve */
+	if (!parsed1.isValid() || !parsed2.isValid()) throw new Error(`Unable to parse dates: ${date1}, ${date2}`);
+	return parsed1.isBefore(parsed2);
+};
+const isAfter = (date1, date2) => {
+	const parsed1 = parseDateInput(date1);
+	const parsed2 = parseDateInput(date2);
+	/* v8 ignore next -- @preserve */
+	if (!parsed1.isValid() || !parsed2.isValid()) throw new Error(`Unable to parse dates: ${date1}, ${date2}`);
+	return parsed1.isAfter(parsed2);
+};
+const isSame = (date1, date2, unit) => {
+	const parsed1 = parseDateInput(date1);
+	const parsed2 = parseDateInput(date2);
+	/* v8 ignore next -- @preserve */
+	if (!parsed1.isValid() || !parsed2.isValid()) throw new Error(`Unable to parse dates: ${date1}, ${date2}`);
+	return parsed1.isSame(parsed2, unit);
+};
+const isBetweenDates = (dateInput, startDate, endDate) => {
+	const parsed = parseDateInput(dateInput);
+	const parsedStart = parseDateInput(startDate);
+	const parsedEnd = parseDateInput(endDate);
+	/* v8 ignore next -- @preserve */
+	if (!parsed.isValid() || !parsedStart.isValid() || !parsedEnd.isValid()) throw new Error(`Unable to parse dates: ${dateInput}, ${startDate}, ${endDate}`);
+	return parsed.isBetween(parsedStart, parsedEnd, null, "[]");
+};
+const diff = (date1, date2, unit) => {
+	const parsed1 = parseDateInput(date1);
+	const parsed2 = parseDateInput(date2);
+	/* v8 ignore next -- @preserve */
+	if (!parsed1.isValid() || !parsed2.isValid()) throw new Error(`Unable to parse dates: ${date1}, ${date2}`);
+	return parsed1.diff(parsed2, unit);
+};
+const toISOString = (dateInput) => {
+	const parsed = parseDateInput(dateInput);
+	/* v8 ignore next -- @preserve */
+	if (!parsed.isValid()) throw new Error(`Unable to parse date: ${dateInput}`);
+	return parsed.toISOString();
+};
+const dateTimezone = (dateInput, timezoneStr, formatString) => {
+	const convertedFormat = convertFormatString(formatString || "YYYY-MM-DD HH:mm:ss");
+	const parsed = parseDateInput(dateInput);
+	/* v8 ignore next -- @preserve */
+	if (!parsed.isValid()) throw new Error(`Unable to parse date: ${dateInput}`);
+	return parsed.tz(timezoneStr).format(convertedFormat);
+};
+const dateLocale = (dateInput, locale, formatString) => {
+	const convertedFormat = convertFormatString(formatString || "YYYY-MM-DD HH:mm:ss");
+	const parsed = parseDateInput(dateInput);
+	/* v8 ignore next -- @preserve */
+	if (!parsed.isValid()) throw new Error(`Unable to parse date: ${dateInput}`);
+	return parsed.locale(locale).format(convertedFormat);
+};
+const helpers$17 = [
+	{
+		name: "year",
+		category: "date",
+		compatibility: ["browser", "nodejs"],
+		fn: year
+	},
+	{
+		name: "date",
+		category: "date",
+		compatibility: ["browser", "nodejs"],
+		fn: date
+	},
+	{
+		name: "moment",
+		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
+	}
+];
+//#endregion
+//#region src/helpers/fs.ts
+const ESCAPE_SEQUENCE = /\\[\s\S]/g;
+const GLOB_PATTERN = /^!|[*?]|\[[^\]]+\]|\{[^}]+\}|[@?!+*]\([^)]*\)|\([^)]*\|[^)]*\)/;
+const isGlob = (value) => GLOB_PATTERN.test(value.replace(ESCAPE_SEQUENCE, ""));
+const 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) return `${Math.round(number * factor / size) / factor} ${abbr[i]}`;
+	} while (--i >= 0);
+	/* c8 ignore next -- @preserve */
+	return `${number} B`;
+};
+const read = (filepath) => {
+	return fs.readFileSync(filepath, "utf8");
+};
+const isOptions$1 = (value) => {
+	return Boolean(value && typeof value === "object" && "hash" in value);
+};
+const readdir = (dir, filter) => {
+	const files = fs.readdirSync(dir).map((fp) => path.join(dir, fp));
+	const filterArg = isOptions$1(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 = fs.statSync(fp);
+			return filterArg === "isFile" ? stat.isFile() : stat.isDirectory();
+		});
+	}
+	return files;
+};
+const helpers$16 = [
+	{
+		name: "fileSize",
+		category: "fs",
+		compatibility: ["nodejs"],
+		fn: fileSize
+	},
+	{
+		name: "read",
+		category: "fs",
+		compatibility: ["nodejs"],
+		fn: read
+	},
+	{
+		name: "readdir",
+		category: "fs",
+		compatibility: ["nodejs"],
+		fn: readdir
+	}
+];
+//#endregion
+//#region src/helpers/html.node.ts
+const 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 = path.extname(item);
+		let fp = item;
+		/* c8 ignore next -- @preserve */
+		if (!/(^\/\/)|(:\/\/)/.test(item)) fp = path.posix.join(assets, item);
+		if (ext === ".less") return `<link type="text/css" rel="stylesheet/less" href="${fp}">`;
+		return `<link type="text/css" rel="stylesheet" href="${fp}">`;
+	}).join("\n");
+};
+const 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>`;
+	return arrayify(context).map((fp) => path.extname(fp) === ".coffee" ? tag("script", {
+		type: "text/coffeescript",
+		src: fp
+	}) : tag("script", { src: fp })).join("\n");
+};
+const helpers$15 = [{
+	name: "css",
+	category: "html",
+	compatibility: ["nodejs"],
+	fn: css
+}, {
+	name: "js",
+	category: "html",
+	compatibility: ["nodejs"],
+	fn: js
+}];
+//#endregion
+//#region src/utils.ts
+/**
+* Native implementation to replace get-value module
+* Safely gets nested object properties using dot notation or array paths
+* @param object - The object to traverse
+* @param path - Dot notation string or array of keys
+* @returns The value at the path or undefined if not found
+*/
+const get = (object, path) => {
+	if (!object || typeof object !== "object") return void 0;
+	const keys = Array.isArray(path) ? path : path.split(".");
+	let result = object;
+	for (const key of keys) {
+		if (result == null || typeof result !== "object") return void 0;
+		result = result[key];
+	}
+	return result;
+};
+/**
+* Native implementation to replace get-object module
+* Returns an object containing the key-value pair at the specified path
+* @param object - The object to traverse
+* @param path - Dot notation string or array of keys
+* @returns An object containing the key-value pair, or undefined if not found
+*/
+const getObject = (object, path) => {
+	if (!object || typeof object !== "object") return void 0;
+	const keys = Array.isArray(path) ? path : path.split(".");
+	if (keys.length === 0) return void 0;
+	let current = object;
+	for (let i = 0; i < keys.length - 1; i++) {
+		if (current == null || typeof current !== "object") return void 0;
+		current = current[keys[i]];
+	}
+	const finalKey = keys[keys.length - 1];
+	if (current == null || typeof current !== "object" || !(finalKey in current)) return;
+	return { [finalKey]: current[finalKey] };
+};
+/**
+* Merges options from multiple sources for Handlebars helpers
+* Replaces handlebars-utils util.options()
+* @param thisArg - The context (this) from the helper, may have an options property
+* @param locals - Local options or a Handlebars options object with hash
+* @param opts - Additional options or a Handlebars options object with hash
+* @returns Merged options object
+*/
+const 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;
+};
+//#endregion
+//#region src/helpers/i18n.ts
+const 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);
+};
+const helpers$14 = [{
+	name: "i18n",
+	category: "i18n",
+	compatibility: ["browser", "nodejs"],
+	fn: i18n
+}];
+//#endregion
+//#region src/helpers/inflection.ts
+const inflect = (count, singular, plural, includeCount) => {
+	const word = count > 1 || count === 0 ? plural : singular;
+	return includeCount ? `${count} ${word}` : word;
+};
+const 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`;
+	}
+};
+const helpers$13 = [{
+	name: "inflect",
+	category: "inflection",
+	compatibility: ["browser", "nodejs"],
+	fn: inflect
+}, {
+	name: "ordinalize",
+	category: "inflection",
+	compatibility: ["browser", "nodejs"],
+	fn: ordinalize
+}];
+//#endregion
+//#region src/helpers/logging.ts
+/**
+* ANSI color codes for terminal output
+*/
+const colors = {
+	green: (str) => `\x1b[32m${str}\x1b[0m`,
+	cyan: (str) => `\x1b[36m${str}\x1b[0m`,
+	yellow: (str) => `\x1b[33m${str}\x1b[0m`,
+	red: (str) => `\x1b[31m${str}\x1b[0m`,
+	bold: (str) => `\x1b[1m${str}\x1b[0m`
+};
+/**
+* Remove handlebars options from arguments if present
+*/
+function cleanArgs(args) {
+	const last = args[args.length - 1];
+	if (args.length > 1 && typeof last === "object" && last !== null && "hash" in last) return args.slice(0, -1);
+	return args;
+}
+/**
+* Helper for logging an unstyled message to the terminal.
+*/
+function log(...args) {
+	const cleanedArgs = cleanArgs(args);
+	console.log(...cleanedArgs);
+	return "";
+}
+/**
+* Helper for logging a green colored "ok" message preceded by a checkmark
+* to the terminal.
+*/
+function ok(...args) {
+	const message = cleanArgs(args).join(" ");
+	console.log(colors.green(`✓ ${message}`));
+	return "";
+}
+/**
+* Helper for logging a green colored "success" message to the terminal.
+*/
+function success(...args) {
+	const message = cleanArgs(args).map((arg) => String(arg)).join(" ");
+	console.log(colors.green(message));
+	return "";
+}
+/**
+* Helper for logging a cyan colored "informational" message to the terminal.
+*/
+function info(...args) {
+	const message = cleanArgs(args).map((arg) => String(arg)).join(" ");
+	console.log(colors.cyan(message));
+	return "";
+}
+/**
+* Helper for logging a yellow colored "warning" message to the terminal.
+*/
+function warning(...args) {
+	const message = cleanArgs(args).map((arg) => String(arg)).join(" ");
+	console.error(colors.yellow(message));
+	return "";
+}
+/**
+* Alias for warning helper.
+*/
+const warn = warning;
+/**
+* Helper for logging a red colored "error" message to the terminal.
+*/
+function error(...args) {
+	const message = cleanArgs(args).map((arg) => String(arg)).join(" ");
+	console.error(colors.red(message));
+	return "";
+}
+/**
+* Alias for error helper.
+*/
+const danger = error;
+/**
+* Helper for logging a bold formatted message to the terminal.
+*/
+function bold(...args) {
+	const message = cleanArgs(args).map((arg) => String(arg)).join(" ");
+	console.error(colors.bold(message));
+	return "";
+}
+/**
+* Helper for outputting a debug statement with the current context
+*/
+function _debug(...args) {
+	const separator = "─".repeat(50);
+	console.error(colors.cyan(separator));
+	if (args.length > 0) {
+		const cleanedArgs = cleanArgs(args);
+		console.error(colors.cyan("VALUE:"), cleanedArgs[0]);
+	}
+	if (this && Object.keys(this).length > 0) console.error(colors.cyan("CONTEXT:"), this);
+	console.error(colors.cyan(separator));
+	return "";
+}
+/**
+* Helper for inspecting and formatting values as JSON
+*/
+function _inspect(context, options) {
+	const val = JSON.stringify(context, null, 2);
+	return switchOutput(options?.hash?.type || "html", val);
+}
+/**
+* Generate output based on the given type
+*/
+function switchOutput(type, json) {
+	if (type[0] === ".") type = type.slice(1);
+	switch (type) {
+		case "md": return `\n\`\`\`json\n${json}\n\`\`\`\n`;
+		case "html": return `<div class="highlight highlight-json">\n<pre><code>\n${json}</code></pre></div>`;
+		default: return json;
+	}
+}
+const helpers$12 = [
+	{
+		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
+	}
+];
+//#endregion
+//#region src/helpers/match.ts
+const match = (files, patterns, options) => {
+	const pats = typeof patterns === "string" ? patterns.split(/, */) : patterns;
+	return micromatch(typeof files === "string" ? [files] : files, pats, options);
+};
+const isMatch = (filepath, pattern, options) => {
+	return micromatch.isMatch(filepath, pattern, options);
+};
+const 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);
+};
+const helpers$11 = [
+	{
+		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
+	}
+];
+//#endregion
+//#region src/helpers/math.ts
+const isNumeric$1 = (value) => typeof value === "number" && !Number.isNaN(value) || typeof value === "string" && value.trim() !== "" && !Number.isNaN(Number(value));
+const toNumber = (value, message = "expected a number") => {
+	if (isNumeric$1(value)) return Number(value);
+	throw new TypeError(message);
+};
+const abs = (value) => {
+	const num = toNumber(value);
+	return Math.abs(num);
+};
+const add = (a, b) => {
+	if (isNumeric$1(a) && isNumeric$1(b)) return Number(a) + Number(b);
+	return "";
+};
+const avg = (...values) => {
+	const flat = values.flat().map((n) => Number(n));
+	return sum(flat) / flat.length;
+};
+const ceil = (value) => {
+	const num = toNumber(value);
+	return Math.ceil(num);
+};
+const divide = (a, b) => {
+	return toNumber(a, "expected the first argument to be a number") / toNumber(b, "expected the second argument to be a number");
+};
+const floor = (value) => {
+	const num = toNumber(value);
+	return Math.floor(num);
+};
+const minus = (a, b) => {
+	return toNumber(a, "expected the first argument to be a number") - toNumber(b, "expected the second argument to be a number");
+};
+const modulo = (a, b) => {
+	return toNumber(a, "expected the first argument to be a number") % toNumber(b, "expected the second argument to be a number");
+};
+const multiply = (a, b) => {
+	return toNumber(a, "expected the first argument to be a number") * toNumber(b, "expected the second argument to be a number");
+};
+const plus = (a, b) => {
+	return toNumber(a, "expected the first argument to be a number") + toNumber(b, "expected the second argument to be a number");
+};
+const 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));
+};
+const remainder = (a, b) => a % b;
+const round = (value) => {
+	const num = toNumber(value);
+	return Math.round(num);
+};
+const subtract = (a, b) => {
+	return toNumber(a, "expected the first argument to be a number") - toNumber(b, "expected the second argument to be a number");
+};
+const sum = (...values) => {
+	const flat = values.flat();
+	let total = 0;
+	for (const value of flat) if (isNumeric$1(value)) total += Number(value);
+	return total;
+};
+const times = (a, b) => multiply(a, b);
+const helpers$10 = [
+	{
+		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
+	}
+];
+//#endregion
+//#region src/helpers/md.ts
+const md = new MarkdownIt({
+	breaks: true,
+	html: true,
+	langPrefix: "lang-",
+	typographer: false,
+	xhtmlOut: false
+});
+function renderString(input) {
+	return new HandlebarsLib.SafeString(ent.decode(md.render(input)));
+}
+//#endregion
+//#region src/helpers/md.node.ts
+const renderMarkdown = function(input, options) {
+	if (typeof input === "object" && input && "fn" in input && typeof input.fn === "function") {
+		options = input;
+		input = input.fn(this);
+	} else if (typeof input !== "string") input = "";
+	const options_ = {
+		cwd: process$1.cwd(),
+		...options
+	};
+	let string_ = input;
+	if (string_.length > 0) {
+		const filepath = path.resolve(options_.cwd, string_);
+		if (fs.existsSync(filepath) && fs.statSync(filepath).isFile()) string_ = fs.readFileSync(filepath, "utf8");
+	}
+	return renderString(string_);
+};
+const helpers$9 = [{
+	name: "md",
+	category: "markdown",
+	compatibility: ["nodejs"],
+	fn: renderMarkdown
+}, {
+	name: "markdown",
+	category: "markdown",
+	compatibility: ["nodejs"],
+	fn: renderMarkdown
+}];
+//#endregion
+//#region src/helpers/misc.ts
+const objectToString = Object.prototype.toString;
+function ctorName(val) {
+	return typeof val.constructor === "function" ? val.constructor.name : null;
+}
+function isGeneratorFn(val) {
+	return ctorName(val) === "GeneratorFunction";
+}
+function isGeneratorObj(val) {
+	return typeof val.throw === "function" && typeof val.return === "function" && typeof val.next === "function";
+}
+function isDateLike(val) {
+	return typeof val.toDateString === "function" && typeof val.getDate === "function" && typeof val.setDate === "function";
+}
+function isErrorLike(val) {
+	return typeof val.message === "string" && val.constructor && typeof val.constructor.stackTraceLimit === "number";
+}
+function isRegexpLike(val) {
+	return typeof val.flags === "string" && typeof val.ignoreCase === "boolean" && typeof val.multiline === "boolean" && typeof val.global === "boolean";
+}
+function kindOf(val) {
+	if (val === void 0) return "undefined";
+	if (val === null) return "null";
+	const type = typeof val;
+	if (type === "boolean") return "boolean";
+	if (type === "string") return "string";
+	if (type === "number") return "number";
+	if (type === "symbol") return "symbol";
+	if (type === "bigint") return "bigint";
+	if (type === "function") return isGeneratorFn(val) ? "generatorfunction" : "function";
+	if (Array.isArray(val)) return "array";
+	if (typeof Buffer !== "undefined" && Buffer.isBuffer?.(val)) return "buffer";
+	if (typeof val.length === "number" && objectToString.call(val) === "[object Arguments]") return "arguments";
+	if (val instanceof Date || isDateLike(val)) return "date";
+	if (val instanceof Error || isErrorLike(val)) return "error";
+	if (val instanceof RegExp || isRegexpLike(val)) return "regexp";
+	switch (ctorName(val)) {
+		case "Promise": return "promise";
+		case "WeakMap": return "weakmap";
+		case "WeakSet": return "weakset";
+		case "Map": return "map";
+		case "Set": return "set";
+		case "Int8Array": return "int8array";
+		case "Uint8Array": return "uint8array";
+		case "Uint8ClampedArray": return "uint8clampedarray";
+		case "Int16Array": return "int16array";
+		case "Uint16Array": return "uint16array";
+		case "Int32Array": return "int32array";
+		case "Uint32Array": return "uint32array";
+		case "Float32Array": return "float32array";
+		case "Float64Array": return "float64array";
+	}
+	if (isGeneratorObj(val)) return "generator";
+	const tag = objectToString.call(val);
+	switch (tag) {
+		case "[object Object]": return "object";
+		case "[object Map Iterator]": return "mapiterator";
+		case "[object Set Iterator]": return "setiterator";
+		case "[object String Iterator]": return "stringiterator";
+		case "[object Array Iterator]": return "arrayiterator";
+	}
+	return tag.slice(8, -1).toLowerCase().replace(/\s/g, "");
+}
+/**
+* Block helper for exposing private `@` variables on the context
+* Replaces the external handlebars-helper-create-frame package
+*/
+function frame(context, options) {
+	if (typeof context === "object" && context !== null && "hash" in context) {
+		options = context;
+		context = options.data;
+	}
+	const data = HandlebarsLib.createFrame(context || {});
+	if (typeof options !== "object" || options === null) options = {};
+	if (options.hash && typeof options.hash === "object") Object.assign(data, options.hash);
+	return options.fn(this, { data });
+}
+function option(prop, locals, opts) {
+	return get(options(this, locals, opts), prop);
+}
+function noop(options) {
+	return options.fn(this);
+}
+const typeOf = kindOf;
+function withHash(options) {
+	if (options.hash && Object.keys(options.hash).length) return options.fn(options.hash);
+	return options.inverse(this);
+}
+const helpers$8 = [
+	{
+		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
+	}
+];
+//#endregion
+//#region src/helpers/number.ts
+const isNumeric = (value) => typeof value === "number" && !Number.isNaN(value);
+const 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 (isNumeric(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) return `${Math.round(num * factor / size) / factor} ${abbr[i]}`;
+	}
+	return `${num}`;
+};
+const addCommas = (num) => num.toString().replace(/(\d)(?=(\d\d\d)+(?!\d))/g, "$1,");
+const phoneNumber = (num) => {
+	const str = num.toString();
+	return `(${str.substr(0, 3)}) ${str.substr(3, 3)}-${str.substr(6, 4)}`;
+};
+const toAbbr = (value, precision) => {
+	const num = isNumeric(value) ? Number(value) : 0;
+	const factor = 10 ** (typeof precision === "number" && !Number.isNaN(precision) ? precision : 2);
+	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) return `${Math.round(num * factor / size) / factor}${abbr[i]}`;
+	}
+	return `${num}`;
+};
+const toExponential = (value, digits) => {
+	const num = isNumeric(value) ? Number(value) : 0;
+	const d = typeof digits === "number" && !Number.isNaN(digits) ? digits : 0;
+	return Number(num).toExponential(d);
+};
+const toFixed = (value, digits) => {
+	const num = isNumeric(value) ? Number(value) : 0;
+	const d = typeof digits === "number" && !Number.isNaN(digits) ? digits : 0;
+	return Number(num).toFixed(d);
+};
+const toFloat = (value) => parseFloat(String(value));
+const toInt = (value) => parseInt(String(value), 10);
+const toPrecision = (value, precision) => {
+	const num = isNumeric(value) ? Number(value) : 0;
+	const prec = typeof precision === "number" && !Number.isNaN(precision) ? precision : 1;
+	return Number(num).toPrecision(prec);
+};
+const helpers$7 = [
+	{
+		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
+	}
+];
+//#endregion
+//#region src/helpers/object.ts
+const isOptions = (value) => {
+	return Boolean(value && typeof value === "object" && "hash" in value);
+};
+const createFrame = (options, hash) => ({
+	...options?.data || {},
+	...hash
+});
+const extend = (...objects) => {
+	const args = [...objects];
+	if (args.length && isOptions(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;
+};
+const forIn = (obj, options) => {
+	if (!isOptions(options)) return options?.inverse?.(obj) ?? "";
+	const data = createFrame(options, options.hash || {});
+	let result = "";
+	for (const key in obj) {
+		data.key = key;
+		result += options.fn(obj[key], { data });
+	}
+	return result;
+};
+const forOwn = (obj, options) => {
+	if (!isOptions(options)) return options?.inverse?.(obj) ?? "";
+	const data = createFrame(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;
+};
+const toPath = (...prop) => {
+	const parts = [];
+	for (const p of prop) if (typeof p === "string" || typeof p === "number") parts.push(p);
+	return parts.join(".");
+};
+const getHelper = (prop, context, options) => {
+	const val = get(context, prop);
+	if (options && typeof options.fn === "function") return val ? options.fn(val) : options.inverse?.(context);
+	return val;
+};
+const getObjectHelper = (prop, context) => {
+	return getObject(context, prop);
+};
+const hasOwn = (context, key) => {
+	return Object.hasOwn(context, key);
+};
+const isObject = (value) => {
+	return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+};
+const JSONparse = (str) => {
+	return JSON.parse(str);
+};
+const JSONstringify = (obj, indent) => {
+	return JSON.stringify(obj, null, typeof indent === "number" ? indent : 0);
+};
+const merge = (context, ...objects) => {
+	const args = [context, ...objects];
+	if (args.length && isOptions(args[args.length - 1])) {
+		const opts = args.pop();
+		args.push(opts.hash);
+	}
+	return Object.assign(args[0], ...args.slice(1));
+};
+const parseJSON = JSONparse;
+const stringify = JSONstringify;
+const 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;
+};
+const helpers$6 = [
+	{
+		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
+	}
+];
+//#endregion
+//#region src/helpers/path.ts
+const expectedType = (variableName, expectedType, variableValue) => {
+	return `Expected ${variableName} to be of type ${expectedType}, but got ${Object.prototype.toString.call(variableValue).slice(8, -1).toLowerCase()}`;
+};
+const assertString = (name, value) => {
+	if (typeof value !== "string") throw new TypeError(expectedType(name, "string", value));
+	return value;
+};
+const absolute = function(filepath, options) {
+	const fp = assertString("filepath", filepath);
+	const cwd = options?.data?.root?.cwd ?? this?.cwd ?? process.cwd();
+	return path.resolve(cwd, fp);
+};
+const dirname = (filepath) => {
+	const fp = assertString("filepath", filepath);
+	return path.dirname(fp);
+};
+const relative = (a, b) => {
+	const from = assertString("first path", a);
+	const to = assertString("second path", b);
+	return path.relative(path.dirname(from), to);
+};
+const basename = (filepath) => {
+	const fp = assertString("filepath", filepath);
+	return path.basename(fp);
+};
+const stem = (filepath) => {
+	const fp = assertString("filepath", filepath);
+	return path.basename(fp, path.extname(fp));
+};
+const extname = (filepath) => {
+	const fp = assertString("filepath", filepath);
+	return path.extname(fp);
+};
+const resolveFn = function(filepath, ...paths) {
+	let options;
+	const last = paths[paths.length - 1];
+	if (typeof last === "object" && last && "data" in last) options = paths.pop();
+	const all = [
+		options?.data?.root?.cwd ?? this?.cwd ?? process.cwd(),
+		assertString("filepath", filepath),
+		...paths.map((p, i) => assertString(`path${i}`, p))
+	];
+	return path.resolve(...all);
+};
+const segments = (filepath, a, b) => {
+	const fp = assertString("filepath", filepath);
+	const start = Number(a);
+	const end = Number(b);
+	return fp.split(/[\\/]+/).slice(start, end).join("/");
+};
+const helpers$5 = [
+	{
+		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
+	}
+];
+//#endregion
+//#region src/helpers/regex.ts
+const toRegex = (str, locals, opts) => {
+	const mergedOpts = options({}, locals, opts);
+	return new RegExp(str, mergedOpts.flags);
+};
+const test = (str, regex) => {
+	if (typeof str !== "string") return false;
+	if (!(regex instanceof RegExp)) throw new TypeError("expected a regular expression");
+	return regex.test(str);
+};
+const helpers$4 = [{
+	name: "toRegex",
+	category: "regex",
+	compatibility: ["browser", "nodejs"],
+	fn: toRegex
+}, {
+	name: "test",
+	category: "regex",
+	compatibility: ["browser", "nodejs"],
+	fn: test
+}];
+//#endregion
+//#region src/helpers/string.ts
+const chop = (str) => str.trim().replace(/^[-_.\W\s]+|[-_.\W\s]+$/g, "");
+const changecase = (str, fn) => {
+	if (str.length === 1) return str.toLowerCase();
+	return chop(str).toLowerCase().replace(/[-_.\W\s]+(\w|$)/g, (_, ch) => fn(ch));
+};
+const append = (str, suffix) => {
+	if (typeof str === "string" && typeof suffix === "string") return str + suffix;
+	return str;
+};
+const camelcase = (str) => typeof str === "string" ? changecase(str, (ch) => ch.toUpperCase()) : "";
+const capitalize = (str) => {
+	if (typeof str !== "string" || str.length === 0) return "";
+	return str.charAt(0).toUpperCase() + str.slice(1);
+};
+const capitalizeAll = (str) => {
+	if (typeof str !== "string") return "";
+	return str.replace(/\w\S*/g, (word) => capitalize(word));
+};
+const center = (str, spaces) => {
+	if (typeof str !== "string") return "";
+	let space = "";
+	for (let i = 0; i < spaces; i++) space += "&nbsp;";
+	return space + str + space;
+};
+const chopStr = (str) => typeof str === "string" ? chop(str) : "";
+const dashcase = (str) => typeof str === "string" ? changecase(str, (ch) => `-${ch}`) : "";
+const dotcase = (str) => typeof str === "string" ? changecase(str, (ch) => `.${ch}`) : "";
+const 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;
+	}
+	return "";
+};
+const ellipsis = (str, limit) => {
+	if (typeof str === "string") {
+		if (str.length <= limit) return str;
+		return `${truncate(str, limit)}…`;
+	}
+	return "";
+};
+const hyphenate = (str) => typeof str === "string" ? str.split(" ").join("-") : "";
+const isString = (value) => typeof value === "string";
+const lowercase = (str) => {
+	if (typeof str === "object" && str !== null && "fn" in str && typeof str.fn === "function") return String(str.fn()).toLowerCase();
+	if (typeof str !== "string") return "";
+	return str.toLowerCase();
+};
+const downcase = (str) => lowercase(str);
+const 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);
+	}
+	return n;
+};
+const pascalcase = (str) => {
+	if (typeof str !== "string") return "";
+	const res = changecase(str, (ch) => ch.toUpperCase());
+	return res.charAt(0).toUpperCase() + res.slice(1);
+};
+const pathcase = (str) => typeof str === "string" ? changecase(str, (ch) => `/${ch}`) : "";
+const plusify = (str, ch) => {
+	if (typeof str !== "string") return "";
+	if (typeof ch !== "string") ch = " ";
+	return str.split(ch).join("+");
+};
+const prepend = (str, prefix) => {
+	return typeof str === "string" && typeof prefix === "string" ? prefix + str : str;
+};
+const remove = (str, ch) => {
+	if (typeof str !== "string") return "";
+	if (typeof ch !== "string") return str;
+	return str.split(ch).join("");
+};
+const removeFirst = (str, ch) => {
+	if (typeof str !== "string") return "";
+	if (typeof ch !== "string") return str;
+	return str.replace(ch, "");
+};
+const 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);
+};
+const 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);
+};
+const reverse = (str) => typeof str === "string" ? str.split("").reverse().join("") : "";
+const sentence = (str) => {
+	if (typeof str !== "string") return "";
+	return str.replace(/((?:\S[^.?!]*)[.?!]*)/g, (txt) => txt.charAt(0).toUpperCase() + txt.substr(1).toLowerCase());
+};
+const snakecase = (str) => typeof str === "string" ? changecase(str, (ch) => `_${ch}`) : "";
+const trim = (str) => typeof str === "string" ? str.trim() : "";
+const trimLeft = (str) => typeof str === "string" ? str.replace(/^\s+/, "") : "";
+const trimRight = (str) => typeof str === "string" ? str.replace(/\s+$/, "") : "";
+const truncateWords = (str, count, suffix) => {
+	if (typeof str === "string" && typeof count === "number" && Number.isFinite(count)) {
+		/* c8 ignore next -- @preserve */
+		if (typeof suffix !== "string") suffix = "...";
+		const num = Math.trunc(count);
+		let arr = str.split(" ");
+		/* c8 ignore next -- @preserve */
+		if (num < arr.length) arr = arr.slice(0, num);
+		return arr.join(" ").trim() + suffix;
+	}
+	return "";
+};
+const truncateWordsAlias = truncateWords;
+const uppercase = (str) => {
+	if (typeof str === "object" && str !== null && "fn" in str && typeof str.fn === "function") return String(str.fn()).toUpperCase();
+	if (typeof str !== "string") return "";
+	return str.toUpperCase();
+};
+const upcase = (str) => uppercase(str);
+const split = (str, character) => {
+	if (typeof str !== "string") return "";
+	if (typeof character !== "string") character = "";
+	return str.split(character);
+};
+const startsWith = (prefix, testString, _options) => {
+	if (typeof prefix !== "string" || typeof testString !== "string") return false;
+	return testString.startsWith(prefix);
+};
+const titleize = (str) => {
+	if (typeof str !== "string") return "";
+	return str.replace(/\w\S*/g, (word) => {
+		return word.charAt(0).toUpperCase() + word.slice(1).toLowerCase();
+	});
+};
+const raw = (options) => {
+	if (options && typeof options.fn === "function") return options.fn();
+	return "";
+};
+const helpers$3 = [
+	{
+		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
+	},
+	{
+		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
+	}
+];
+//#endregion
+//#region src/helpers/url.ts
+const all = ["browser", "nodejs"];
+const encodeUri = (str) => {
+	if (typeof str === "string") return encodeURIComponent(str);
+};
+const decodeUri = (str) => {
+	if (typeof str === "string") return decodeURIComponent(str);
+};
+function urlEncode(...args) {
+	return encodeUri.apply(this, args);
+}
+function urlDecode(...args) {
+	return decodeUri.apply(this, args);
+}
+const stripQuerystring = (str) => {
+	if (typeof str === "string") return str.split("?")[0];
+};
+const helpers$2 = [
+	{
+		name: "encodeURI",
+		category: "url",
+		compatibility: all,
+		fn: encodeUri
+	},
+	{
+		name: "decodeURI",
+		category: "url",
+		compatibility: all,
+		fn: decodeUri
+	},
+	{
+		name: "url_encode",
+		category: "url",
+		compatibility: all,
+		fn: urlEncode
+	},
+	{
+		name: "url_decode",
+		category: "url",
+		compatibility: all,
+		fn: urlDecode
+	},
+	{
+		name: "stripQuerystring",
+		category: "url",
+		compatibility: all,
+		fn: stripQuerystring
+	}
+];
+//#endregion
+//#region src/helpers/url.node.ts
+const escapeFn = (str) => {
+	if (typeof str === "string") return escape(str);
+};
+const urlResolve = (base, href) => resolve(String(base), String(href));
+const urlParse = (str) => parse(String(str));
+const stripProtocol = (str) => {
+	if (typeof str === "string") {
+		const parsed = parse(str);
+		parsed.protocol = "";
+		return format(parsed);
+	}
+};
+const helpers$1 = [
+	{
+		name: "escape",
+		category: "url",
+		compatibility: ["nodejs"],
+		fn: escapeFn
+	},
+	{
+		name: "urlResolve",
+		category: "url",
+		compatibility: ["nodejs"],
+		fn: urlResolve
+	},
+	{
+		name: "urlParse",
+		category: "url",
+		compatibility: ["nodejs"],
+		fn: urlParse
+	},
+	{
+		name: "stripProtocol",
+		category: "url",
+		compatibility: ["nodejs"],
+		fn: stripProtocol
+	}
+];
+//#endregion
+//#region src/helper-registry.ts
+var HelperRegistry = class extends HelperRegistryBase {
+	init() {
+		this.registerHelpers(helpers$23);
+		this.registerHelpers(helpers$19);
+		this.registerHelpers(helpers$17);
+		this.registerHelpers(helpers$16);
+		this.registerHelpers(helpers$21);
+		this.registerHelpers(helpers$20);
+		this.registerHelpers(helpers$9);
+		this.registerHelpers(helpers$22);
+		this.registerHelpers(helpers$15);
+		this.registerHelpers(helpers$18);
+		this.registerHelpers(helpers$14);
+		this.registerHelpers(helpers$13);
+		this.registerHelpers(helpers$12);
+		this.registerHelpers(helpers$11);
+		this.registerHelpers(helpers$10);
+		this.registerHelpers(helpers$8);
+		this.registerHelpers(helpers$7);
+		this.registerHelpers(helpers$5);
+		this.registerHelpers(helpers$4);
+		this.registerHelpers(helpers$3);
+		this.registerHelpers(helpers$2);
+		this.registerHelpers(helpers$1);
+		this.registerHelpers(helpers$6);
+	}
+};
+//#endregion
+//#region src/index.node.ts
+/**
+* Handlebars library not initiated with helpers
+* @type {Handlebars}
+*/
+const Handlebars = HandlebarsLib;
+/**
+* Fumanchu Handlebars instance not initiated with helpers
+* @type {Handlebars}
+*/
+const handlebars = HandlebarsLib.create();
+/**
+* Register Handlebars helpers
+* @param {HelpersOptions} options - Options for Fumanchu helpers
+*/
+function helpers(options) {
+	new HelperRegistry().load(options.handlebars ?? options.hbs);
+}
+/**
+* Create a new Handlebars instance with Fumanchu helpers
+* @returns {Promise<Handlebars>}
+* @deprecated Will be deprecated in future versions, use `fumanchu()` instead.
+*/
+async function createHandlebars() {
+	const registry = new HelperRegistry();
+	const handlebars = HandlebarsLib.create();
+	if (Object.keys(HandlebarsLib.partials).length > 0) handlebars.registerPartial(HandlebarsLib.partials);
+	registry.load(handlebars);
+	/* c8 ignore next -- @preserve */
+	if (process.env.NODE_ENV === "development") console.warn("createHandlebars will be deprecated in future versions, use `fumanchu` instead.");
+	return handlebars;
+}
+/**
+* Will return a Handlebars instance with Fumanchu helpers (experimental)
+* @param {FumanchuOptions} [options] - Options for Fumanchu
+* @returns {Handlebars} Handlebars instance with helpers
+*/
+function fumanchu(options) {
+	const registry = new HelperRegistry();
+	let handlebars = HandlebarsLib.create();
+	/* c8 ignore next -- @preserve */
+	if (options?.handlebars) handlebars = options.handlebars;
+	else if (Object.keys(HandlebarsLib.partials).length > 0) handlebars.registerPartial(HandlebarsLib.partials);
+	registry.load(handlebars);
+	if (options?.caching) {
+		let cache;
+		if (options.caching instanceof CacheableMemory) cache = options.caching;
+		else if (typeof options.caching === "object") cache = new CacheableMemory({
+			useClone: false,
+			...options.caching
+		});
+		else cache = new CacheableMemory({ useClone: false });
+		const originalCompile = handlebars.compile.bind(handlebars);
+		handlebars.compile = (input, compileOptions) => {
+			const key = compileOptions ? `${input}\0${JSON.stringify(compileOptions)}` : input;
+			const cached = cache.get(key);
+			if (cached) return cached;
+			const compiled = originalCompile(input, compileOptions);
+			cache.set(key, compiled);
+			return compiled;
+		};
+	}
+	return handlebars;
+}
+//#endregion
+export { CacheableMemory, Handlebars, HelperRegistry, createHandlebars, fumanchu, handlebars, helpers };