@mono-lit/helper 0.0.9 → 0.0.10

package/dist/export-ixRdCS2y.js

@@ -1,2388 +0,0 @@
-import { a as stripDirectives, i as escapeCellText, n as parseMarkdown, o as __commonJSMin, r as encodeDirective, s as __toESM } from "./markdown-uGlE_OfJ.js";
-import { n as isReadableSource, r as readAllRows } from "./data-source-read-HyBCRg1t.js";
-import { n as unwrapReactive } from "./reactive-Dtd-esHO.js";
-import { t as DEFAULT_STYLES } from "./excel-BXzr3uI1.js";
-
-//#region src/export/download.ts
-/**
-* Browser download helper. Kept separate (and DOM-guarded) so the report engine
-* can still render on a server — where `download()` is simply a no-op warning
-* rather than a crash.
-*/
-/** MIME type per output format. */
-const MIME = {
-	md: "text/markdown;charset=utf-8",
-	xlsx: "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet"
-};
-/** Save a Blob to disk via a transient `<a download>`. Browser only. */
-function downloadBlob(blob, fileName) {
-	if (typeof document === "undefined" || typeof URL?.createObjectURL !== "function") {
-		console.warn("[mono-export] download() needs a browser environment — skipped.");
-		return;
-	}
-	const url = URL.createObjectURL(blob);
-	const anchor = document.createElement("a");
-	anchor.href = url;
-	anchor.download = fileName;
-	anchor.style.display = "none";
-	document.body.appendChild(anchor);
-	anchor.click();
-	document.body.removeChild(anchor);
-	setTimeout(() => URL.revokeObjectURL(url), 0);
-}
-
-//#endregion
-//#region src/export/detail.ts
-function readPath(row, path) {
-	if (path in row) return row[path];
-	return path.split(".").reduce((acc, part) => acc == null ? acc : acc[part], row);
-}
-/**
-* Run `task` over `items` with at most `limit` in flight.
-*
-* Deliberately NOT `Promise.all` over the whole list. The implementation this
-* replaces fires every batch at once and wraps the lot in a single `.catch`, so
-* one flaky request loses a multi-minute export and discards the error with it.
-* Here a rejection is captured per item, and the rest of the workbook is still
-* produced.
-*
-* The items are CHUNKS of master rows, not single documents — see the note at
-* the top of this file.
-*/
-async function pool(items, limit, task) {
-	const out = new Array(items.length);
-	let cursor = 0;
-	const worker = async () => {
-		for (;;) {
-			const index = cursor;
-			cursor += 1;
-			if (index >= items.length) return;
-			try {
-				out[index] = {
-					status: "fulfilled",
-					value: await task(items[index])
-				};
-			} catch (error) {
-				out[index] = {
-					status: "rejected",
-					reason: error
-				};
-			}
-		}
-	};
-	const size = Math.max(1, Math.min(limit, items.length));
-	await Promise.all(Array.from({ length: size }, worker));
-	return out;
-}
-/**
-* Turn master rows into per-document detail rows.
-*
-* A document with no rows is reported in `skipped` rather than given an empty
-* sheet — an empty worksheet behind a link is worse than no link, and the
-* caller gets told which documents those were instead of having to diff the
-* tab list.
-*/
-async function resolveDetails(masterRows, detail) {
-	const rows = masterRows.filter((row) => !!row && typeof row === "object");
-	const keyOf = (row) => String(readPath(row, detail.key) ?? "");
-	const details = [];
-	const skipped = [];
-	const collect = (row, value) => {
-		const key = keyOf(row);
-		const list = Array.isArray(value) ? value : [];
-		if (!key || !list.length) {
-			skipped.push({
-				key: key || "(no key)",
-				reason: "empty"
-			});
-			return;
-		}
-		details.push({
-			row,
-			key,
-			rows: list
-		});
-	};
-	if (typeof detail.load === "function") {
-		const size = Math.max(1, Math.floor(detail.loadChunk ?? 100));
-		const chunks = [];
-		for (let i = 0; i < rows.length; i += size) chunks.push(rows.slice(i, i + size));
-		const groupBy = detail.groupBy ?? detail.key;
-		const groupOf = typeof groupBy === "function" ? groupBy : (row) => readPath(row, groupBy);
-		(await pool(chunks, detail.concurrency ?? 4, (chunk) => Promise.resolve(detail.load({
-			data: chunk,
-			keys: [...new Set(chunk.map((row) => readPath(row, detail.key)))],
-			key: detail.key
-		})))).forEach((result, index) => {
-			const chunk = chunks[index];
-			if (result.status === "rejected") {
-				for (const row of chunk) skipped.push({
-					key: keyOf(row) || "(no key)",
-					reason: "failed",
-					error: result.reason
-				});
-				return;
-			}
-			const byKey = /* @__PURE__ */ new Map();
-			for (const row of Array.isArray(result.value) ? result.value : []) {
-				if (!row || typeof row !== "object") continue;
-				const key = String(groupOf(row) ?? "");
-				if (!key) continue;
-				const bucket = byKey.get(key);
-				if (bucket) bucket.push(row);
-				else byKey.set(key, [row]);
-			}
-			for (const row of chunk) collect(row, byKey.get(keyOf(row)) ?? []);
-		});
-		return {
-			details,
-			skipped
-		};
-	}
-	if (detail.field) {
-		for (const row of rows) collect(row, readPath(row, detail.field));
-		return {
-			details,
-			skipped
-		};
-	}
-	throw new Error("[mono-export] `detail` needs either `field` or `load`.");
-}
-
-//#endregion
-//#region src/export/resolve-data.ts
-/**
-* Turning live data sources in `options.data` into plain arrays.
-*
-* A template can only loop over an array, but the thing a consumer *has* is
-* usually a devextreme DataSource. Rather than making everyone drain it by hand
-* before every export, any DataSource-shaped value in `data` is drained here
-* first — in chunks, honouring whatever filter / search / sort the source
-* already carries — so the template just sees rows:
-*
-* ```ts
-* data: { program: dataSourceProgramTransfer.value }
-* ```
-* ```hbs
-* {{#each program}}| {{NoDokumen}} | {{currency TotalBudget}} |
-* {{/each}}
-* ```
-*/
-/**
-* Replace every DataSource / store in `data`'s **top level** with its rows.
-*
-* Top-level only, deliberately: it's predictable, and a deep walk would mean
-* inspecting every record of every array already in `data` — a real cost for a
-* 10k-row export, to support a nesting nobody has asked for. A source nested
-* deeper stays the caller's job (`await table.getData()` and pass the array).
-*
-* Sources are drained concurrently — several are independent queries, and a
-* report with three of them shouldn't take three times as long.
-*/
-async function resolveExportData(data, options = {}) {
-	if (!data) return {};
-	const entries = Object.entries(data);
-	const pending = [];
-	const out = {};
-	for (const [key, raw] of entries) {
-		const value = unwrapReactive(raw);
-		if (isReadableSource(value)) pending.push(readAllRows(value, { chunkSize: options.chunkSize }).then((rows) => {
-			out[key] = rows;
-		}));
-		else out[key] = value;
-	}
-	if (pending.length) await Promise.all(pending);
-	return out;
-}
-
-//#endregion
-//#region ../../node_modules/.pnpm/@babel+runtime@7.26.10/node_modules/@babel/runtime/helpers/interopRequireDefault.js
-var require_interopRequireDefault = /* @__PURE__ */ __commonJSMin(((exports, module) => {
-	function _interopRequireDefault(e) {
-		return e && e.__esModule ? e : { "default": e };
-	}
-	module.exports = _interopRequireDefault, module.exports.__esModule = true, module.exports["default"] = module.exports;
-}));
-
-//#endregion
-//#region ../../node_modules/.pnpm/@babel+runtime@7.26.10/node_modules/@babel/runtime/helpers/typeof.js
-var require_typeof = /* @__PURE__ */ __commonJSMin(((exports, module) => {
-	function _typeof(o) {
-		"@babel/helpers - typeof";
-		return module.exports = _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function(o) {
-			return typeof o;
-		} : function(o) {
-			return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o;
-		}, module.exports.__esModule = true, module.exports["default"] = module.exports, _typeof(o);
-	}
-	module.exports = _typeof, module.exports.__esModule = true, module.exports["default"] = module.exports;
-}));
-
-//#endregion
-//#region ../../node_modules/.pnpm/@babel+runtime@7.26.10/node_modules/@babel/runtime/helpers/toPrimitive.js
-var require_toPrimitive = /* @__PURE__ */ __commonJSMin(((exports, module) => {
-	var _typeof = require_typeof()["default"];
-	function toPrimitive(t, r) {
-		if ("object" != _typeof(t) || !t) return t;
-		var e = t[Symbol.toPrimitive];
-		if (void 0 !== e) {
-			var i = e.call(t, r || "default");
-			if ("object" != _typeof(i)) return i;
-			throw new TypeError("@@toPrimitive must return a primitive value.");
-		}
-		return ("string" === r ? String : Number)(t);
-	}
-	module.exports = toPrimitive, module.exports.__esModule = true, module.exports["default"] = module.exports;
-}));
-
-//#endregion
-//#region ../../node_modules/.pnpm/@babel+runtime@7.26.10/node_modules/@babel/runtime/helpers/toPropertyKey.js
-var require_toPropertyKey = /* @__PURE__ */ __commonJSMin(((exports, module) => {
-	var _typeof = require_typeof()["default"];
-	var toPrimitive = require_toPrimitive();
-	function toPropertyKey(t) {
-		var i = toPrimitive(t, "string");
-		return "symbol" == _typeof(i) ? i : i + "";
-	}
-	module.exports = toPropertyKey, module.exports.__esModule = true, module.exports["default"] = module.exports;
-}));
-
-//#endregion
-//#region ../../node_modules/.pnpm/@babel+runtime@7.26.10/node_modules/@babel/runtime/helpers/defineProperty.js
-var require_defineProperty = /* @__PURE__ */ __commonJSMin(((exports, module) => {
-	var toPropertyKey = require_toPropertyKey();
-	function _defineProperty(e, r, t) {
-		return (r = toPropertyKey(r)) in e ? Object.defineProperty(e, r, {
-			value: t,
-			enumerable: !0,
-			configurable: !0,
-			writable: !0
-		}) : e[r] = t, e;
-	}
-	module.exports = _defineProperty, module.exports.__esModule = true, module.exports["default"] = module.exports;
-}));
-
-//#endregion
-//#region ../../node_modules/.pnpm/@babel+runtime@7.26.10/node_modules/@babel/runtime/helpers/classCallCheck.js
-var require_classCallCheck = /* @__PURE__ */ __commonJSMin(((exports, module) => {
-	function _classCallCheck(a, n) {
-		if (!(a instanceof n)) throw new TypeError("Cannot call a class as a function");
-	}
-	module.exports = _classCallCheck, module.exports.__esModule = true, module.exports["default"] = module.exports;
-}));
-
-//#endregion
-//#region ../../node_modules/.pnpm/@babel+runtime@7.26.10/node_modules/@babel/runtime/helpers/createClass.js
-var require_createClass = /* @__PURE__ */ __commonJSMin(((exports, module) => {
-	var toPropertyKey = require_toPropertyKey();
-	function _defineProperties(e, r) {
-		for (var t = 0; t < r.length; t++) {
-			var o = r[t];
-			o.enumerable = o.enumerable || !1, o.configurable = !0, "value" in o && (o.writable = !0), Object.defineProperty(e, toPropertyKey(o.key), o);
-		}
-	}
-	function _createClass(e, r, t) {
-		return r && _defineProperties(e.prototype, r), t && _defineProperties(e, t), Object.defineProperty(e, "prototype", { writable: !1 }), e;
-	}
-	module.exports = _createClass, module.exports.__esModule = true, module.exports["default"] = module.exports;
-}));
-
-//#endregion
-//#region ../../node_modules/.pnpm/@babel+runtime@7.26.10/node_modules/@babel/runtime/helpers/arrayLikeToArray.js
-var require_arrayLikeToArray = /* @__PURE__ */ __commonJSMin(((exports, module) => {
-	function _arrayLikeToArray(r, a) {
-		(null == a || a > r.length) && (a = r.length);
-		for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e];
-		return n;
-	}
-	module.exports = _arrayLikeToArray, module.exports.__esModule = true, module.exports["default"] = module.exports;
-}));
-
-//#endregion
-//#region ../../node_modules/.pnpm/@babel+runtime@7.26.10/node_modules/@babel/runtime/helpers/arrayWithoutHoles.js
-var require_arrayWithoutHoles = /* @__PURE__ */ __commonJSMin(((exports, module) => {
-	var arrayLikeToArray = require_arrayLikeToArray();
-	function _arrayWithoutHoles(r) {
-		if (Array.isArray(r)) return arrayLikeToArray(r);
-	}
-	module.exports = _arrayWithoutHoles, module.exports.__esModule = true, module.exports["default"] = module.exports;
-}));
-
-//#endregion
-//#region ../../node_modules/.pnpm/@babel+runtime@7.26.10/node_modules/@babel/runtime/helpers/iterableToArray.js
-var require_iterableToArray = /* @__PURE__ */ __commonJSMin(((exports, module) => {
-	function _iterableToArray(r) {
-		if ("undefined" != typeof Symbol && null != r[Symbol.iterator] || null != r["@@iterator"]) return Array.from(r);
-	}
-	module.exports = _iterableToArray, module.exports.__esModule = true, module.exports["default"] = module.exports;
-}));
-
-//#endregion
-//#region ../../node_modules/.pnpm/@babel+runtime@7.26.10/node_modules/@babel/runtime/helpers/unsupportedIterableToArray.js
-var require_unsupportedIterableToArray = /* @__PURE__ */ __commonJSMin(((exports, module) => {
-	var arrayLikeToArray = require_arrayLikeToArray();
-	function _unsupportedIterableToArray(r, a) {
-		if (r) {
-			if ("string" == typeof r) return arrayLikeToArray(r, a);
-			var t = {}.toString.call(r).slice(8, -1);
-			return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? arrayLikeToArray(r, a) : void 0;
-		}
-	}
-	module.exports = _unsupportedIterableToArray, module.exports.__esModule = true, module.exports["default"] = module.exports;
-}));
-
-//#endregion
-//#region ../../node_modules/.pnpm/@babel+runtime@7.26.10/node_modules/@babel/runtime/helpers/nonIterableSpread.js
-var require_nonIterableSpread = /* @__PURE__ */ __commonJSMin(((exports, module) => {
-	function _nonIterableSpread() {
-		throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
-	}
-	module.exports = _nonIterableSpread, module.exports.__esModule = true, module.exports["default"] = module.exports;
-}));
-
-//#endregion
-//#region ../../node_modules/.pnpm/@babel+runtime@7.26.10/node_modules/@babel/runtime/helpers/toConsumableArray.js
-var require_toConsumableArray = /* @__PURE__ */ __commonJSMin(((exports, module) => {
-	var arrayWithoutHoles = require_arrayWithoutHoles();
-	var iterableToArray = require_iterableToArray();
-	var unsupportedIterableToArray = require_unsupportedIterableToArray();
-	var nonIterableSpread = require_nonIterableSpread();
-	function _toConsumableArray(r) {
-		return arrayWithoutHoles(r) || iterableToArray(r) || unsupportedIterableToArray(r) || nonIterableSpread();
-	}
-	module.exports = _toConsumableArray, module.exports.__esModule = true, module.exports["default"] = module.exports;
-}));
-
-//#endregion
-//#region ../../node_modules/.pnpm/jexl@2.3.0/node_modules/jexl/dist/evaluator/handlers.js
-var require_handlers$1 = /* @__PURE__ */ __commonJSMin(((exports) => {
-	var _toConsumableArray2 = require_interopRequireDefault()(require_toConsumableArray());
-	var poolNames = {
-		functions: "Jexl Function",
-		transforms: "Transform"
-	};
-	/**
-	* Evaluates an ArrayLiteral by returning its value, with each element
-	* independently run through the evaluator.
-	* @param {{type: 'ObjectLiteral', value: <{}>}} ast An expression tree with an
-	*      ObjectLiteral as the top node
-	* @returns {Promise.<[]>} resolves to a map contained evaluated values.
-	* @private
-	*/
-	exports.ArrayLiteral = function(ast) {
-		return this.evalArray(ast.value);
-	};
-	/**
-	* Evaluates a BinaryExpression node by running the Grammar's evaluator for
-	* the given operator. Note that binary expressions support two types of
-	* evaluators: `eval` is called with the left and right operands pre-evaluated.
-	* `evalOnDemand`, if it exists, will be called with the left and right operands
-	* each individually wrapped in an object with an "eval" function that returns
-	* a promise with the resulting value. This allows the binary expression to
-	* evaluate the operands conditionally.
-	* @param {{type: 'BinaryExpression', operator: <string>, left: {},
-	*      right: {}}} ast An expression tree with a BinaryExpression as the top
-	*      node
-	* @returns {Promise<*>} resolves with the value of the BinaryExpression.
-	* @private
-	*/
-	exports.BinaryExpression = function(ast) {
-		var _this = this;
-		var grammarOp = this._grammar.elements[ast.operator];
-		if (grammarOp.evalOnDemand) {
-			var wrap = function wrap(subAst) {
-				return { eval: function _eval() {
-					return _this.eval(subAst);
-				} };
-			};
-			return grammarOp.evalOnDemand(wrap(ast.left), wrap(ast.right));
-		}
-		return this.Promise.all([this.eval(ast.left), this.eval(ast.right)]).then(function(arr) {
-			return grammarOp.eval(arr[0], arr[1]);
-		});
-	};
-	/**
-	* Evaluates a ConditionalExpression node by first evaluating its test branch,
-	* and resolving with the consequent branch if the test is truthy, or the
-	* alternate branch if it is not. If there is no consequent branch, the test
-	* result will be used instead.
-	* @param {{type: 'ConditionalExpression', test: {}, consequent: {},
-	*      alternate: {}}} ast An expression tree with a ConditionalExpression as
-	*      the top node
-	* @private
-	*/
-	exports.ConditionalExpression = function(ast) {
-		var _this2 = this;
-		return this.eval(ast.test).then(function(res) {
-			if (res) {
-				if (ast.consequent) return _this2.eval(ast.consequent);
-				return res;
-			}
-			return _this2.eval(ast.alternate);
-		});
-	};
-	/**
-	* Evaluates a FilterExpression by applying it to the subject value.
-	* @param {{type: 'FilterExpression', relative: <boolean>, expr: {},
-	*      subject: {}}} ast An expression tree with a FilterExpression as the top
-	*      node
-	* @returns {Promise<*>} resolves with the value of the FilterExpression.
-	* @private
-	*/
-	exports.FilterExpression = function(ast) {
-		var _this3 = this;
-		return this.eval(ast.subject).then(function(subject) {
-			if (ast.relative) return _this3._filterRelative(subject, ast.expr);
-			return _this3._filterStatic(subject, ast.expr);
-		});
-	};
-	/**
-	* Evaluates an Identifier by either stemming from the evaluated 'from'
-	* expression tree or accessing the context provided when this Evaluator was
-	* constructed.
-	* @param {{type: 'Identifier', value: <string>, [from]: {}}} ast An expression
-	*      tree with an Identifier as the top node
-	* @returns {Promise<*>|*} either the identifier's value, or a Promise that
-	*      will resolve with the identifier's value.
-	* @private
-	*/
-	exports.Identifier = function(ast) {
-		if (!ast.from) return ast.relative ? this._relContext[ast.value] : this._context[ast.value];
-		return this.eval(ast.from).then(function(context) {
-			if (context === void 0 || context === null) return;
-			if (Array.isArray(context)) context = context[0];
-			return context[ast.value];
-		});
-	};
-	/**
-	* Evaluates a Literal by returning its value property.
-	* @param {{type: 'Literal', value: <string|number|boolean>}} ast An expression
-	*      tree with a Literal as its only node
-	* @returns {string|number|boolean} The value of the Literal node
-	* @private
-	*/
-	exports.Literal = function(ast) {
-		return ast.value;
-	};
-	/**
-	* Evaluates an ObjectLiteral by returning its value, with each key
-	* independently run through the evaluator.
-	* @param {{type: 'ObjectLiteral', value: <{}>}} ast An expression tree with an
-	*      ObjectLiteral as the top node
-	* @returns {Promise<{}>} resolves to a map contained evaluated values.
-	* @private
-	*/
-	exports.ObjectLiteral = function(ast) {
-		return this.evalMap(ast.value);
-	};
-	/**
-	* Evaluates a FunctionCall node by applying the supplied arguments to a
-	* function defined in one of the grammar's function pools.
-	* @param {{type: 'FunctionCall', name: <string>}} ast An
-	*      expression tree with a FunctionCall as the top node
-	* @returns {Promise<*>|*} the value of the function call, or a Promise that
-	*      will resolve with the resulting value.
-	* @private
-	*/
-	exports.FunctionCall = function(ast) {
-		var poolName = poolNames[ast.pool];
-		if (!poolName) throw new Error("Corrupt AST: Pool '".concat(ast.pool, "' not found"));
-		var func = this._grammar[ast.pool][ast.name];
-		if (!func) throw new Error("".concat(poolName, " ").concat(ast.name, " is not defined."));
-		return this.evalArray(ast.args || []).then(function(args) {
-			return func.apply(void 0, (0, _toConsumableArray2.default)(args));
-		});
-	};
-	/**
-	* Evaluates a Unary expression by passing the right side through the
-	* operator's eval function.
-	* @param {{type: 'UnaryExpression', operator: <string>, right: {}}} ast An
-	*      expression tree with a UnaryExpression as the top node
-	* @returns {Promise<*>} resolves with the value of the UnaryExpression.
-	* @constructor
-	*/
-	exports.UnaryExpression = function(ast) {
-		var _this4 = this;
-		return this.eval(ast.right).then(function(right) {
-			return _this4._grammar.elements[ast.operator].eval(right);
-		});
-	};
-}));
-
-//#endregion
-//#region ../../node_modules/.pnpm/jexl@2.3.0/node_modules/jexl/dist/evaluator/Evaluator.js
-var require_Evaluator = /* @__PURE__ */ __commonJSMin(((exports, module) => {
-	var _interopRequireDefault = require_interopRequireDefault();
-	var _classCallCheck2 = _interopRequireDefault(require_classCallCheck());
-	var _createClass2 = _interopRequireDefault(require_createClass());
-	var handlers = require_handlers$1();
-	/**
-	* The Evaluator takes a Jexl expression tree as generated by the
-	* {@link Parser} and calculates its value within a given context. The
-	* collection of transforms, context, and a relative context to be used as the
-	* root for relative identifiers, are all specific to an Evaluator instance.
-	* When any of these things change, a new instance is required.  However, a
-	* single instance can be used to simultaneously evaluate many different
-	* expressions, and does not have to be reinstantiated for each.
-	* @param {{}} grammar A grammar object against which to evaluate the expression
-	*      tree
-	* @param {{}} [context] A map of variable keys to their values. This will be
-	*      accessed to resolve the value of each non-relative identifier. Any
-	*      Promise values will be passed to the expression as their resolved
-	*      value.
-	* @param {{}|Array<{}|Array>} [relativeContext] A map or array to be accessed
-	*      to resolve the value of a relative identifier.
-	* @param {function} promise A constructor for the Promise class to be used;
-	*      probably either Promise or PromiseSync.
-	*/
-	var Evaluator = /*#__PURE__*/ function() {
-		function Evaluator(grammar, context, relativeContext) {
-			var promise = arguments.length > 3 && arguments[3] !== void 0 ? arguments[3] : Promise;
-			(0, _classCallCheck2.default)(this, Evaluator);
-			this._grammar = grammar;
-			this._context = context || {};
-			this._relContext = relativeContext || this._context;
-			this.Promise = promise;
-		}
-		/**
-		* Evaluates an expression tree within the configured context.
-		* @param {{}} ast An expression tree object
-		* @returns {Promise<*>} resolves with the resulting value of the expression.
-		*/
-		(0, _createClass2.default)(Evaluator, [
-			{
-				key: "eval",
-				value: function _eval(ast) {
-					var _this = this;
-					return this.Promise.resolve().then(function() {
-						return handlers[ast.type].call(_this, ast);
-					});
-				}
-			},
-			{
-				key: "evalArray",
-				value: function evalArray(arr) {
-					var _this2 = this;
-					return this.Promise.all(arr.map(function(elem) {
-						return _this2.eval(elem);
-					}));
-				}
-			},
-			{
-				key: "evalMap",
-				value: function evalMap(map) {
-					var _this3 = this;
-					var keys = Object.keys(map);
-					var result = {};
-					var asts = keys.map(function(key) {
-						return _this3.eval(map[key]);
-					});
-					return this.Promise.all(asts).then(function(vals) {
-						vals.forEach(function(val, idx) {
-							result[keys[idx]] = val;
-						});
-						return result;
-					});
-				}
-			},
-			{
-				key: "_filterRelative",
-				value: function _filterRelative(subject, expr) {
-					var _this4 = this;
-					var promises = [];
-					if (!Array.isArray(subject)) subject = subject === void 0 ? [] : [subject];
-					subject.forEach(function(elem) {
-						var evalInst = new Evaluator(_this4._grammar, _this4._context, elem, _this4.Promise);
-						promises.push(evalInst.eval(expr));
-					});
-					return this.Promise.all(promises).then(function(values) {
-						var results = [];
-						values.forEach(function(value, idx) {
-							if (value) results.push(subject[idx]);
-						});
-						return results;
-					});
-				}
-			},
-			{
-				key: "_filterStatic",
-				value: function _filterStatic(subject, expr) {
-					return this.eval(expr).then(function(res) {
-						if (typeof res === "boolean") return res ? subject : void 0;
-						return subject[res];
-					});
-				}
-			}
-		]);
-		return Evaluator;
-	}();
-	module.exports = Evaluator;
-}));
-
-//#endregion
-//#region ../../node_modules/.pnpm/jexl@2.3.0/node_modules/jexl/dist/Lexer.js
-var require_Lexer = /* @__PURE__ */ __commonJSMin(((exports, module) => {
-	var _interopRequireDefault = require_interopRequireDefault();
-	var _classCallCheck2 = _interopRequireDefault(require_classCallCheck());
-	var _createClass2 = _interopRequireDefault(require_createClass());
-	var numericRegex = /^-?(?:(?:[0-9]*\.[0-9]+)|[0-9]+)$/;
-	var identRegex = /^[a-zA-Zа-яА-Я_\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u00FF$][a-zA-Zа-яА-Я0-9_\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u00FF$]*$/;
-	var escEscRegex = /\\\\/;
-	var whitespaceRegex = /^\s*$/;
-	var preOpRegexElems = [
-		"'(?:(?:\\\\')|[^'])*'",
-		"\"(?:(?:\\\\\")|[^\"])*\"",
-		"\\s+",
-		"\\btrue\\b",
-		"\\bfalse\\b"
-	];
-	var postOpRegexElems = ["[a-zA-Zа-яА-Я_À-ÖØ-öø-ÿ\\$][a-zA-Z0-9а-яА-Я_À-ÖØ-öø-ÿ\\$]*", "(?:(?:[0-9]*\\.[0-9]+)|[0-9]+)"];
-	var minusNegatesAfter = [
-		"binaryOp",
-		"unaryOp",
-		"openParen",
-		"openBracket",
-		"question",
-		"colon"
-	];
-	/**
-	* Lexer is a collection of stateless, statically-accessed functions for the
-	* lexical parsing of a Jexl string.  Its responsibility is to identify the
-	* "parts of speech" of a Jexl expression, and tokenize and label each, but
-	* to do only the most minimal syntax checking; the only errors the Lexer
-	* should be concerned with are if it's unable to identify the utility of
-	* any of its tokens.  Errors stemming from these tokens not being in a
-	* sensible configuration should be left for the Parser to handle.
-	* @type {{}}
-	*/
-	var Lexer = /*#__PURE__*/ function() {
-		function Lexer(grammar) {
-			(0, _classCallCheck2.default)(this, Lexer);
-			this._grammar = grammar;
-		}
-		/**
-		* Splits a Jexl expression string into an array of expression elements.
-		* @param {string} str A Jexl expression string
-		* @returns {Array<string>} An array of substrings defining the functional
-		*      elements of the expression.
-		*/
-		(0, _createClass2.default)(Lexer, [
-			{
-				key: "getElements",
-				value: function getElements(str) {
-					var regex = this._getSplitRegex();
-					return str.split(regex).filter(function(elem) {
-						return elem;
-					});
-				}
-			},
-			{
-				key: "getTokens",
-				value: function getTokens(elements) {
-					var tokens = [];
-					var negate = false;
-					for (var i = 0; i < elements.length; i++) if (this._isWhitespace(elements[i])) {
-						if (tokens.length) tokens[tokens.length - 1].raw += elements[i];
-					} else if (elements[i] === "-" && this._isNegative(tokens)) negate = true;
-					else {
-						if (negate) {
-							elements[i] = "-" + elements[i];
-							negate = false;
-						}
-						tokens.push(this._createToken(elements[i]));
-					}
-					if (negate) tokens.push(this._createToken("-"));
-					return tokens;
-				}
-			},
-			{
-				key: "tokenize",
-				value: function tokenize(str) {
-					var elements = this.getElements(str);
-					return this.getTokens(elements);
-				}
-			},
-			{
-				key: "_createToken",
-				value: function _createToken(element) {
-					var token = {
-						type: "literal",
-						value: element,
-						raw: element
-					};
-					if (element[0] === "\"" || element[0] === "'") token.value = this._unquote(element);
-					else if (element.match(numericRegex)) token.value = parseFloat(element);
-					else if (element === "true" || element === "false") token.value = element === "true";
-					else if (this._grammar.elements[element]) token.type = this._grammar.elements[element].type;
-					else if (element.match(identRegex)) token.type = "identifier";
-					else throw new Error("Invalid expression token: ".concat(element));
-					return token;
-				}
-			},
-			{
-				key: "_escapeRegExp",
-				value: function _escapeRegExp(str) {
-					str = str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-					if (str.match(identRegex)) str = "\\b" + str + "\\b";
-					return str;
-				}
-			},
-			{
-				key: "_getSplitRegex",
-				value: function _getSplitRegex() {
-					var _this = this;
-					if (!this._splitRegex) {
-						var elemArray = Object.keys(this._grammar.elements).sort(function(a, b) {
-							return b.length - a.length;
-						}).map(function(elem) {
-							return _this._escapeRegExp(elem);
-						}, this);
-						this._splitRegex = new RegExp("(" + [
-							preOpRegexElems.join("|"),
-							elemArray.join("|"),
-							postOpRegexElems.join("|")
-						].join("|") + ")");
-					}
-					return this._splitRegex;
-				}
-			},
-			{
-				key: "_isNegative",
-				value: function _isNegative(tokens) {
-					if (!tokens.length) return true;
-					return minusNegatesAfter.some(function(type) {
-						return type === tokens[tokens.length - 1].type;
-					});
-				}
-			},
-			{
-				key: "_isWhitespace",
-				value: function _isWhitespace(str) {
-					return !!str.match(whitespaceRegex);
-				}
-			},
-			{
-				key: "_unquote",
-				value: function _unquote(str) {
-					var quote = str[0];
-					var escQuoteRegex = new RegExp("\\\\" + quote, "g");
-					return str.substr(1, str.length - 2).replace(escQuoteRegex, quote).replace(escEscRegex, "\\");
-				}
-			}
-		]);
-		return Lexer;
-	}();
-	module.exports = Lexer;
-}));
-
-//#endregion
-//#region ../../node_modules/.pnpm/jexl@2.3.0/node_modules/jexl/dist/parser/handlers.js
-var require_handlers = /* @__PURE__ */ __commonJSMin(((exports) => {
-	/**
-	* Handles a subexpression that's used to define a transform argument's value.
-	* @param {{type: <string>}} ast The subexpression tree
-	*/
-	exports.argVal = function(ast) {
-		if (ast) this._cursor.args.push(ast);
-	};
-	/**
-	* Handles new array literals by adding them as a new node in the AST,
-	* initialized with an empty array.
-	*/
-	exports.arrayStart = function() {
-		this._placeAtCursor({
-			type: "ArrayLiteral",
-			value: []
-		});
-	};
-	/**
-	* Handles a subexpression representing an element of an array literal.
-	* @param {{type: <string>}} ast The subexpression tree
-	*/
-	exports.arrayVal = function(ast) {
-		if (ast) this._cursor.value.push(ast);
-	};
-	/**
-	* Handles tokens of type 'binaryOp', indicating an operation that has two
-	* inputs: a left side and a right side.
-	* @param {{type: <string>}} token A token object
-	*/
-	exports.binaryOp = function(token) {
-		var precedence = this._grammar.elements[token.value].precedence || 0;
-		var parent = this._cursor._parent;
-		while (parent && parent.operator && this._grammar.elements[parent.operator].precedence >= precedence) {
-			this._cursor = parent;
-			parent = parent._parent;
-		}
-		var node = {
-			type: "BinaryExpression",
-			operator: token.value,
-			left: this._cursor
-		};
-		this._setParent(this._cursor, node);
-		this._cursor = parent;
-		this._placeAtCursor(node);
-	};
-	/**
-	* Handles successive nodes in an identifier chain.  More specifically, it
-	* sets values that determine how the following identifier gets placed in the
-	* AST.
-	*/
-	exports.dot = function() {
-		this._nextIdentEncapsulate = this._cursor && this._cursor.type !== "UnaryExpression" && (this._cursor.type !== "BinaryExpression" || this._cursor.type === "BinaryExpression" && this._cursor.right);
-		this._nextIdentRelative = !this._cursor || this._cursor && !this._nextIdentEncapsulate;
-		if (this._nextIdentRelative) this._relative = true;
-	};
-	/**
-	* Handles a subexpression used for filtering an array returned by an
-	* identifier chain.
-	* @param {{type: <string>}} ast The subexpression tree
-	*/
-	exports.filter = function(ast) {
-		this._placeBeforeCursor({
-			type: "FilterExpression",
-			expr: ast,
-			relative: this._subParser.isRelative(),
-			subject: this._cursor
-		});
-	};
-	/**
-	* Handles identifier tokens when used to indicate the name of a function to
-	* be called.
-	* @param {{type: <string>}} token A token object
-	*/
-	exports.functionCall = function() {
-		this._placeBeforeCursor({
-			type: "FunctionCall",
-			name: this._cursor.value,
-			args: [],
-			pool: "functions"
-		});
-	};
-	/**
-	* Handles identifier tokens by adding them as a new node in the AST.
-	* @param {{type: <string>}} token A token object
-	*/
-	exports.identifier = function(token) {
-		var node = {
-			type: "Identifier",
-			value: token.value
-		};
-		if (this._nextIdentEncapsulate) {
-			node.from = this._cursor;
-			this._placeBeforeCursor(node);
-			this._nextIdentEncapsulate = false;
-		} else {
-			if (this._nextIdentRelative) {
-				node.relative = true;
-				this._nextIdentRelative = false;
-			}
-			this._placeAtCursor(node);
-		}
-	};
-	/**
-	* Handles literal values, such as strings, booleans, and numerics, by adding
-	* them as a new node in the AST.
-	* @param {{type: <string>}} token A token object
-	*/
-	exports.literal = function(token) {
-		this._placeAtCursor({
-			type: "Literal",
-			value: token.value
-		});
-	};
-	/**
-	* Queues a new object literal key to be written once a value is collected.
-	* @param {{type: <string>}} token A token object
-	*/
-	exports.objKey = function(token) {
-		this._curObjKey = token.value;
-	};
-	/**
-	* Handles new object literals by adding them as a new node in the AST,
-	* initialized with an empty object.
-	*/
-	exports.objStart = function() {
-		this._placeAtCursor({
-			type: "ObjectLiteral",
-			value: {}
-		});
-	};
-	/**
-	* Handles an object value by adding its AST to the queued key on the object
-	* literal node currently at the cursor.
-	* @param {{type: <string>}} ast The subexpression tree
-	*/
-	exports.objVal = function(ast) {
-		this._cursor.value[this._curObjKey] = ast;
-	};
-	/**
-	* Handles traditional subexpressions, delineated with the groupStart and
-	* groupEnd elements.
-	* @param {{type: <string>}} ast The subexpression tree
-	*/
-	exports.subExpression = function(ast) {
-		this._placeAtCursor(ast);
-	};
-	/**
-	* Handles a completed alternate subexpression of a ternary operator.
-	* @param {{type: <string>}} ast The subexpression tree
-	*/
-	exports.ternaryEnd = function(ast) {
-		this._cursor.alternate = ast;
-	};
-	/**
-	* Handles a completed consequent subexpression of a ternary operator.
-	* @param {{type: <string>}} ast The subexpression tree
-	*/
-	exports.ternaryMid = function(ast) {
-		this._cursor.consequent = ast;
-	};
-	/**
-	* Handles the start of a new ternary expression by encapsulating the entire
-	* AST in a ConditionalExpression node, and using the existing tree as the
-	* test element.
-	*/
-	exports.ternaryStart = function() {
-		this._tree = {
-			type: "ConditionalExpression",
-			test: this._tree
-		};
-		this._cursor = this._tree;
-	};
-	/**
-	* Handles identifier tokens when used to indicate the name of a transform to
-	* be applied.
-	* @param {{type: <string>}} token A token object
-	*/
-	exports.transform = function(token) {
-		this._placeBeforeCursor({
-			type: "FunctionCall",
-			name: token.value,
-			args: [this._cursor],
-			pool: "transforms"
-		});
-	};
-	/**
-	* Handles token of type 'unaryOp', indicating that the operation has only
-	* one input: a right side.
-	* @param {{type: <string>}} token A token object
-	*/
-	exports.unaryOp = function(token) {
-		this._placeAtCursor({
-			type: "UnaryExpression",
-			operator: token.value
-		});
-	};
-}));
-
-//#endregion
-//#region ../../node_modules/.pnpm/jexl@2.3.0/node_modules/jexl/dist/parser/states.js
-var require_states = /* @__PURE__ */ __commonJSMin(((exports) => {
-	var h = require_handlers();
-	/**
-	* A mapping of all states in the finite state machine to a set of instructions
-	* for handling or transitioning into other states. Each state can be handled
-	* in one of two schemes: a tokenType map, or a subHandler.
-	*
-	* Standard expression elements are handled through the tokenType object. This
-	* is an object map of all legal token types to encounter in this state (and
-	* any unexpected token types will generate a thrown error) to an options
-	* object that defines how they're handled.  The available options are:
-	*
-	*      {string} toState: The name of the state to which to transition
-	*          immediately after handling this token
-	*      {string} handler: The handler function to call when this token type is
-	*          encountered in this state.  If omitted, the default handler
-	*          matching the token's "type" property will be called. If the handler
-	*          function does not exist, no call will be made and no error will be
-	*          generated.  This is useful for tokens whose sole purpose is to
-	*          transition to other states.
-	*
-	* States that consume a subexpression should define a subHandler, the
-	* function to be called with an expression tree argument when the
-	* subexpression is complete. Completeness is determined through the
-	* endStates object, which maps tokens on which an expression should end to the
-	* state to which to transition once the subHandler function has been called.
-	*
-	* Additionally, any state in which it is legal to mark the AST as completed
-	* should have a 'completable' property set to boolean true.  Attempting to
-	* call {@link Parser#complete} in any state without this property will result
-	* in a thrown Error.
-	*
-	* @type {{}}
-	*/
-	exports.states = {
-		expectOperand: { tokenTypes: {
-			literal: { toState: "expectBinOp" },
-			identifier: { toState: "identifier" },
-			unaryOp: {},
-			openParen: { toState: "subExpression" },
-			openCurl: {
-				toState: "expectObjKey",
-				handler: h.objStart
-			},
-			dot: { toState: "traverse" },
-			openBracket: {
-				toState: "arrayVal",
-				handler: h.arrayStart
-			}
-		} },
-		expectBinOp: {
-			tokenTypes: {
-				binaryOp: { toState: "expectOperand" },
-				pipe: { toState: "expectTransform" },
-				dot: { toState: "traverse" },
-				question: {
-					toState: "ternaryMid",
-					handler: h.ternaryStart
-				}
-			},
-			completable: true
-		},
-		expectTransform: { tokenTypes: { identifier: {
-			toState: "postTransform",
-			handler: h.transform
-		} } },
-		expectObjKey: { tokenTypes: {
-			identifier: {
-				toState: "expectKeyValSep",
-				handler: h.objKey
-			},
-			closeCurl: { toState: "expectBinOp" }
-		} },
-		expectKeyValSep: { tokenTypes: { colon: { toState: "objVal" } } },
-		postTransform: {
-			tokenTypes: {
-				openParen: { toState: "argVal" },
-				binaryOp: { toState: "expectOperand" },
-				dot: { toState: "traverse" },
-				openBracket: { toState: "filter" },
-				pipe: { toState: "expectTransform" }
-			},
-			completable: true
-		},
-		postArgs: {
-			tokenTypes: {
-				binaryOp: { toState: "expectOperand" },
-				dot: { toState: "traverse" },
-				openBracket: { toState: "filter" },
-				pipe: { toState: "expectTransform" }
-			},
-			completable: true
-		},
-		identifier: {
-			tokenTypes: {
-				binaryOp: { toState: "expectOperand" },
-				dot: { toState: "traverse" },
-				openBracket: { toState: "filter" },
-				openParen: {
-					toState: "argVal",
-					handler: h.functionCall
-				},
-				pipe: { toState: "expectTransform" },
-				question: {
-					toState: "ternaryMid",
-					handler: h.ternaryStart
-				}
-			},
-			completable: true
-		},
-		traverse: { tokenTypes: { identifier: { toState: "identifier" } } },
-		filter: {
-			subHandler: h.filter,
-			endStates: { closeBracket: "identifier" }
-		},
-		subExpression: {
-			subHandler: h.subExpression,
-			endStates: { closeParen: "expectBinOp" }
-		},
-		argVal: {
-			subHandler: h.argVal,
-			endStates: {
-				comma: "argVal",
-				closeParen: "postArgs"
-			}
-		},
-		objVal: {
-			subHandler: h.objVal,
-			endStates: {
-				comma: "expectObjKey",
-				closeCurl: "expectBinOp"
-			}
-		},
-		arrayVal: {
-			subHandler: h.arrayVal,
-			endStates: {
-				comma: "arrayVal",
-				closeBracket: "expectBinOp"
-			}
-		},
-		ternaryMid: {
-			subHandler: h.ternaryMid,
-			endStates: { colon: "ternaryEnd" }
-		},
-		ternaryEnd: {
-			subHandler: h.ternaryEnd,
-			completable: true
-		}
-	};
-}));
-
-//#endregion
-//#region ../../node_modules/.pnpm/jexl@2.3.0/node_modules/jexl/dist/parser/Parser.js
-var require_Parser = /* @__PURE__ */ __commonJSMin(((exports, module) => {
-	var _interopRequireDefault = require_interopRequireDefault();
-	var _classCallCheck2 = _interopRequireDefault(require_classCallCheck());
-	var _createClass2 = _interopRequireDefault(require_createClass());
-	var handlers = require_handlers();
-	var states = require_states().states;
-	/**
-	* The Parser is a state machine that converts tokens from the {@link Lexer}
-	* into an Abstract Syntax Tree (AST), capable of being evaluated in any
-	* context by the {@link Evaluator}.  The Parser expects that all tokens
-	* provided to it are legal and typed properly according to the grammar, but
-	* accepts that the tokens may still be in an invalid order or in some other
-	* unparsable configuration that requires it to throw an Error.
-	* @param {{}} grammar The grammar object to use to parse Jexl strings
-	* @param {string} [prefix] A string prefix to prepend to the expression string
-	*      for error messaging purposes.  This is useful for when a new Parser is
-	*      instantiated to parse an subexpression, as the parent Parser's
-	*      expression string thus far can be passed for a more user-friendly
-	*      error message.
-	* @param {{}} [stopMap] A mapping of token types to any truthy value. When the
-	*      token type is encountered, the parser will return the mapped value
-	*      instead of boolean false.
-	*/
-	var Parser = /*#__PURE__*/ function() {
-		function Parser(grammar, prefix, stopMap) {
-			(0, _classCallCheck2.default)(this, Parser);
-			this._grammar = grammar;
-			this._state = "expectOperand";
-			this._tree = null;
-			this._exprStr = prefix || "";
-			this._relative = false;
-			this._stopMap = stopMap || {};
-		}
-		/**
-		* Processes a new token into the AST and manages the transitions of the state
-		* machine.
-		* @param {{type: <string>}} token A token object, as provided by the
-		*      {@link Lexer#tokenize} function.
-		* @throws {Error} if a token is added when the Parser has been marked as
-		*      complete by {@link #complete}, or if an unexpected token type is added.
-		* @returns {boolean|*} the stopState value if this parser encountered a token
-		*      in the stopState mapb false if tokens can continue.
-		*/
-		(0, _createClass2.default)(Parser, [
-			{
-				key: "addToken",
-				value: function addToken(token) {
-					if (this._state === "complete") throw new Error("Cannot add a new token to a completed Parser");
-					var state = states[this._state];
-					var startExpr = this._exprStr;
-					this._exprStr += token.raw;
-					if (state.subHandler) {
-						if (!this._subParser) this._startSubExpression(startExpr);
-						var stopState = this._subParser.addToken(token);
-						if (stopState) {
-							this._endSubExpression();
-							if (this._parentStop) return stopState;
-							this._state = stopState;
-						}
-					} else if (state.tokenTypes[token.type]) {
-						var typeOpts = state.tokenTypes[token.type];
-						var handleFunc = handlers[token.type];
-						if (typeOpts.handler) handleFunc = typeOpts.handler;
-						if (handleFunc) handleFunc.call(this, token);
-						if (typeOpts.toState) this._state = typeOpts.toState;
-					} else if (this._stopMap[token.type]) return this._stopMap[token.type];
-					else throw new Error("Token ".concat(token.raw, " (").concat(token.type, ") unexpected in expression: ").concat(this._exprStr));
-					return false;
-				}
-			},
-			{
-				key: "addTokens",
-				value: function addTokens(tokens) {
-					tokens.forEach(this.addToken, this);
-				}
-			},
-			{
-				key: "complete",
-				value: function complete() {
-					if (this._cursor && !states[this._state].completable) throw new Error("Unexpected end of expression: ".concat(this._exprStr));
-					if (this._subParser) this._endSubExpression();
-					this._state = "complete";
-					return this._cursor ? this._tree : null;
-				}
-			},
-			{
-				key: "isRelative",
-				value: function isRelative() {
-					return this._relative;
-				}
-			},
-			{
-				key: "_endSubExpression",
-				value: function _endSubExpression() {
-					states[this._state].subHandler.call(this, this._subParser.complete());
-					this._subParser = null;
-				}
-			},
-			{
-				key: "_placeAtCursor",
-				value: function _placeAtCursor(node) {
-					if (!this._cursor) this._tree = node;
-					else {
-						this._cursor.right = node;
-						this._setParent(node, this._cursor);
-					}
-					this._cursor = node;
-				}
-			},
-			{
-				key: "_placeBeforeCursor",
-				value: function _placeBeforeCursor(node) {
-					this._cursor = this._cursor._parent;
-					this._placeAtCursor(node);
-				}
-			},
-			{
-				key: "_setParent",
-				value: function _setParent(node, parent) {
-					Object.defineProperty(node, "_parent", {
-						value: parent,
-						writable: true
-					});
-				}
-			},
-			{
-				key: "_startSubExpression",
-				value: function _startSubExpression(exprStr) {
-					var endStates = states[this._state].endStates;
-					if (!endStates) {
-						this._parentStop = true;
-						endStates = this._stopMap;
-					}
-					this._subParser = new Parser(this._grammar, exprStr, endStates);
-				}
-			}
-		]);
-		return Parser;
-	}();
-	module.exports = Parser;
-}));
-
-//#endregion
-//#region ../../node_modules/.pnpm/jexl@2.3.0/node_modules/jexl/dist/PromiseSync.js
-var require_PromiseSync = /* @__PURE__ */ __commonJSMin(((exports, module) => {
-	var _interopRequireDefault = require_interopRequireDefault();
-	var _classCallCheck2 = _interopRequireDefault(require_classCallCheck());
-	var _createClass2 = _interopRequireDefault(require_createClass());
-	var PromiseSync = /*#__PURE__*/ function() {
-		function PromiseSync(fn) {
-			(0, _classCallCheck2.default)(this, PromiseSync);
-			fn(this._resolve.bind(this), this._reject.bind(this));
-		}
-		(0, _createClass2.default)(PromiseSync, [
-			{
-				key: "catch",
-				value: function _catch(rejected) {
-					if (this.error) try {
-						this._resolve(rejected(this.error));
-					} catch (e) {
-						this._reject(e);
-					}
-					return this;
-				}
-			},
-			{
-				key: "then",
-				value: function then(resolved, rejected) {
-					if (!this.error) try {
-						this._resolve(resolved(this.value));
-					} catch (e) {
-						this._reject(e);
-					}
-					if (rejected) this.catch(rejected);
-					return this;
-				}
-			},
-			{
-				key: "_reject",
-				value: function _reject(error) {
-					this.value = void 0;
-					this.error = error;
-				}
-			},
-			{
-				key: "_resolve",
-				value: function _resolve(val) {
-					if (val instanceof PromiseSync) {
-						if (val.error) this._reject(val.error);
-						else this._resolve(val.value);
-					} else {
-						this.value = val;
-						this.error = void 0;
-					}
-				}
-			}
-		]);
-		return PromiseSync;
-	}();
-	PromiseSync.all = function(vals) {
-		return new PromiseSync(function(resolve) {
-			resolve(vals.map(function(val) {
-				while (val instanceof PromiseSync) {
-					if (val.error) throw Error(val.error);
-					val = val.value;
-				}
-				return val;
-			}));
-		});
-	};
-	PromiseSync.resolve = function(val) {
-		return new PromiseSync(function(resolve) {
-			return resolve(val);
-		});
-	};
-	PromiseSync.reject = function(error) {
-		return new PromiseSync(function(resolve, reject) {
-			return reject(error);
-		});
-	};
-	module.exports = PromiseSync;
-}));
-
-//#endregion
-//#region ../../node_modules/.pnpm/jexl@2.3.0/node_modules/jexl/dist/Expression.js
-var require_Expression = /* @__PURE__ */ __commonJSMin(((exports, module) => {
-	var _interopRequireDefault = require_interopRequireDefault();
-	var _classCallCheck2 = _interopRequireDefault(require_classCallCheck());
-	var _createClass2 = _interopRequireDefault(require_createClass());
-	var Evaluator = require_Evaluator();
-	var Lexer = require_Lexer();
-	var Parser = require_Parser();
-	var PromiseSync = require_PromiseSync();
-	var Expression = /*#__PURE__*/ function() {
-		function Expression(grammar, exprStr) {
-			(0, _classCallCheck2.default)(this, Expression);
-			this._grammar = grammar;
-			this._exprStr = exprStr;
-			this._ast = null;
-		}
-		/**
-		* Forces a compilation of the expression string that this Expression object
-		* was constructed with. This function can be called multiple times; useful
-		* if the language elements of the associated Jexl instance change.
-		* @returns {Expression} this Expression instance, for convenience
-		*/
-		(0, _createClass2.default)(Expression, [
-			{
-				key: "compile",
-				value: function compile() {
-					var lexer = new Lexer(this._grammar);
-					var parser = new Parser(this._grammar);
-					var tokens = lexer.tokenize(this._exprStr);
-					parser.addTokens(tokens);
-					this._ast = parser.complete();
-					return this;
-				}
-			},
-			{
-				key: "eval",
-				value: function _eval() {
-					var context = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {};
-					return this._eval(context, Promise);
-				}
-			},
-			{
-				key: "evalSync",
-				value: function evalSync() {
-					var context = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {};
-					var res = this._eval(context, PromiseSync);
-					if (res.error) throw res.error;
-					return res.value;
-				}
-			},
-			{
-				key: "_eval",
-				value: function _eval(context, promise) {
-					var _this = this;
-					return promise.resolve().then(function() {
-						var ast = _this._getAst();
-						return new Evaluator(_this._grammar, context, void 0, promise).eval(ast);
-					});
-				}
-			},
-			{
-				key: "_getAst",
-				value: function _getAst() {
-					if (!this._ast) this.compile();
-					return this._ast;
-				}
-			}
-		]);
-		return Expression;
-	}();
-	module.exports = Expression;
-}));
-
-//#endregion
-//#region ../../node_modules/.pnpm/jexl@2.3.0/node_modules/jexl/dist/grammar.js
-var require_grammar = /* @__PURE__ */ __commonJSMin(((exports) => {
-	exports.getGrammar = function() {
-		return {
-			/**
-			* A map of all expression elements to their properties. Note that changes
-			* here may require changes in the Lexer or Parser.
-			* @type {{}}
-			*/
-			elements: {
-				".": { type: "dot" },
-				"[": { type: "openBracket" },
-				"]": { type: "closeBracket" },
-				"|": { type: "pipe" },
-				"{": { type: "openCurl" },
-				"}": { type: "closeCurl" },
-				":": { type: "colon" },
-				",": { type: "comma" },
-				"(": { type: "openParen" },
-				")": { type: "closeParen" },
-				"?": { type: "question" },
-				"+": {
-					type: "binaryOp",
-					precedence: 30,
-					eval: function _eval(left, right) {
-						return left + right;
-					}
-				},
-				"-": {
-					type: "binaryOp",
-					precedence: 30,
-					eval: function _eval(left, right) {
-						return left - right;
-					}
-				},
-				"*": {
-					type: "binaryOp",
-					precedence: 40,
-					eval: function _eval(left, right) {
-						return left * right;
-					}
-				},
-				"/": {
-					type: "binaryOp",
-					precedence: 40,
-					eval: function _eval(left, right) {
-						return left / right;
-					}
-				},
-				"//": {
-					type: "binaryOp",
-					precedence: 40,
-					eval: function _eval(left, right) {
-						return Math.floor(left / right);
-					}
-				},
-				"%": {
-					type: "binaryOp",
-					precedence: 50,
-					eval: function _eval(left, right) {
-						return left % right;
-					}
-				},
-				"^": {
-					type: "binaryOp",
-					precedence: 50,
-					eval: function _eval(left, right) {
-						return Math.pow(left, right);
-					}
-				},
-				"==": {
-					type: "binaryOp",
-					precedence: 20,
-					eval: function _eval(left, right) {
-						return left == right;
-					}
-				},
-				"!=": {
-					type: "binaryOp",
-					precedence: 20,
-					eval: function _eval(left, right) {
-						return left != right;
-					}
-				},
-				">": {
-					type: "binaryOp",
-					precedence: 20,
-					eval: function _eval(left, right) {
-						return left > right;
-					}
-				},
-				">=": {
-					type: "binaryOp",
-					precedence: 20,
-					eval: function _eval(left, right) {
-						return left >= right;
-					}
-				},
-				"<": {
-					type: "binaryOp",
-					precedence: 20,
-					eval: function _eval(left, right) {
-						return left < right;
-					}
-				},
-				"<=": {
-					type: "binaryOp",
-					precedence: 20,
-					eval: function _eval(left, right) {
-						return left <= right;
-					}
-				},
-				"&&": {
-					type: "binaryOp",
-					precedence: 10,
-					evalOnDemand: function evalOnDemand(left, right) {
-						return left.eval().then(function(leftVal) {
-							if (!leftVal) return leftVal;
-							return right.eval();
-						});
-					}
-				},
-				"||": {
-					type: "binaryOp",
-					precedence: 10,
-					evalOnDemand: function evalOnDemand(left, right) {
-						return left.eval().then(function(leftVal) {
-							if (leftVal) return leftVal;
-							return right.eval();
-						});
-					}
-				},
-				in: {
-					type: "binaryOp",
-					precedence: 20,
-					eval: function _eval(left, right) {
-						if (typeof right === "string") return right.indexOf(left) !== -1;
-						if (Array.isArray(right)) return right.some(function(elem) {
-							return elem === left;
-						});
-						return false;
-					}
-				},
-				"!": {
-					type: "unaryOp",
-					precedence: Infinity,
-					eval: function _eval(right) {
-						return !right;
-					}
-				}
-			},
-			/**
-			* A map of function names to javascript functions. A Jexl function
-			* takes zero ore more arguemnts:
-			*
-			*     - {*} ...args: A variable number of arguments passed to this function.
-			*       All of these are pre-evaluated to their actual values before calling
-			*       the function.
-			*
-			* The Jexl function should return either the transformed value, or
-			* a Promises/A+ Promise object that resolves with the value and rejects
-			* or throws only when an unrecoverable error occurs. Functions should
-			* generally return undefined when they don't make sense to be used on the
-			* given value type, rather than throw/reject. An error is only
-			* appropriate when the function would normally return a value, but
-			* cannot due to some other failure.
-			*/
-			functions: {},
-			/**
-			* A map of transform names to transform functions. A transform function
-			* takes one ore more arguemnts:
-			*
-			*     - {*} val: A value to be transformed
-			*     - {*} ...args: A variable number of arguments passed to this transform.
-			*       All of these are pre-evaluated to their actual values before calling
-			*       the function.
-			*
-			* The transform function should return either the transformed value, or
-			* a Promises/A+ Promise object that resolves with the value and rejects
-			* or throws only when an unrecoverable error occurs. Transforms should
-			* generally return undefined when they don't make sense to be used on the
-			* given value type, rather than throw/reject. An error is only
-			* appropriate when the transform would normally return a value, but
-			* cannot due to some other failure.
-			*/
-			transforms: {}
-		};
-	};
-}));
-
-//#endregion
-//#region ../../node_modules/.pnpm/jexl@2.3.0/node_modules/jexl/dist/Jexl.js
-var require_Jexl = /* @__PURE__ */ __commonJSMin(((exports, module) => {
-	var _interopRequireDefault = require_interopRequireDefault();
-	var _defineProperty2 = _interopRequireDefault(require_defineProperty());
-	var _classCallCheck2 = _interopRequireDefault(require_classCallCheck());
-	var _createClass2 = _interopRequireDefault(require_createClass());
-	var Expression = require_Expression();
-	var getGrammar = require_grammar().getGrammar;
-	/**
-	* Jexl is the Javascript Expression Language, capable of parsing and
-	* evaluating basic to complex expression strings, combined with advanced
-	* xpath-like drilldown into native Javascript objects.
-	* @constructor
-	*/
-	var Jexl = /*#__PURE__*/ function() {
-		function Jexl() {
-			(0, _classCallCheck2.default)(this, Jexl);
-			this.expr = this.expr.bind(this);
-			this._grammar = getGrammar();
-		}
-		/**
-		* Adds a binary operator to Jexl at the specified precedence. The higher the
-		* precedence, the earlier the operator is applied in the order of operations.
-		* For example, * has a higher precedence than +, because multiplication comes
-		* before division.
-		*
-		* Please see grammar.js for a listing of all default operators and their
-		* precedence values in order to choose the appropriate precedence for the
-		* new operator.
-		* @param {string} operator The operator string to be added
-		* @param {number} precedence The operator's precedence
-		* @param {function} fn A function to run to calculate the result. The function
-		*      will be called with two arguments: left and right, denoting the values
-		*      on either side of the operator. It should return either the resulting
-		*      value, or a Promise that resolves with the resulting value.
-		* @param {boolean} [manualEval] If true, the `left` and `right` arguments
-		*      will be wrapped in objects with an `eval` function. Calling
-		*      left.eval() or right.eval() will return a promise that resolves to
-		*      that operand's actual value. This is useful to conditionally evaluate
-		*      operands.
-		*/
-		(0, _createClass2.default)(Jexl, [
-			{
-				key: "addBinaryOp",
-				value: function addBinaryOp(operator, precedence, fn, manualEval) {
-					this._addGrammarElement(operator, (0, _defineProperty2.default)({
-						type: "binaryOp",
-						precedence
-					}, manualEval ? "evalOnDemand" : "eval", fn));
-				}
-			},
-			{
-				key: "addFunction",
-				value: function addFunction(name, fn) {
-					this._grammar.functions[name] = fn;
-				}
-			},
-			{
-				key: "addFunctions",
-				value: function addFunctions(map) {
-					for (var key in map) this._grammar.functions[key] = map[key];
-				}
-			},
-			{
-				key: "addUnaryOp",
-				value: function addUnaryOp(operator, fn) {
-					this._addGrammarElement(operator, {
-						type: "unaryOp",
-						weight: Infinity,
-						eval: fn
-					});
-				}
-			},
-			{
-				key: "addTransform",
-				value: function addTransform(name, fn) {
-					this._grammar.transforms[name] = fn;
-				}
-			},
-			{
-				key: "addTransforms",
-				value: function addTransforms(map) {
-					for (var key in map) this._grammar.transforms[key] = map[key];
-				}
-			},
-			{
-				key: "compile",
-				value: function compile(expression) {
-					return this.createExpression(expression).compile();
-				}
-			},
-			{
-				key: "createExpression",
-				value: function createExpression(expression) {
-					return new Expression(this._grammar, expression);
-				}
-			},
-			{
-				key: "getFunction",
-				value: function getFunction(name) {
-					return this._grammar.functions[name];
-				}
-			},
-			{
-				key: "getTransform",
-				value: function getTransform(name) {
-					return this._grammar.transforms[name];
-				}
-			},
-			{
-				key: "eval",
-				value: function _eval(expression) {
-					var context = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {};
-					return this.createExpression(expression).eval(context);
-				}
-			},
-			{
-				key: "evalSync",
-				value: function evalSync(expression) {
-					var context = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {};
-					return this.createExpression(expression).evalSync(context);
-				}
-			},
-			{
-				key: "expr",
-				value: function expr(strs) {
-					for (var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) args[_key - 1] = arguments[_key];
-					var exprStr = strs.reduce(function(acc, str, idx) {
-						var arg = idx < args.length ? args[idx] : "";
-						acc += str + arg;
-						return acc;
-					}, "");
-					return this.createExpression(exprStr);
-				}
-			},
-			{
-				key: "removeOp",
-				value: function removeOp(operator) {
-					if (this._grammar.elements[operator] && (this._grammar.elements[operator].type === "binaryOp" || this._grammar.elements[operator].type === "unaryOp")) delete this._grammar.elements[operator];
-				}
-			},
-			{
-				key: "_addGrammarElement",
-				value: function _addGrammarElement(str, obj) {
-					this._grammar.elements[str] = obj;
-				}
-			}
-		]);
-		return Jexl;
-	}();
-	module.exports = new Jexl();
-	module.exports.Jexl = Jexl;
-}));
-
-//#endregion
-//#region src/export/expression.ts
-var import_Jexl = /* @__PURE__ */ __toESM(require_Jexl(), 1);
-/** jexl ships a UMD bundle whose `module.exports` is the ready-made instance. */
-const jexl = import_Jexl.default?.default ?? import_Jexl.default;
-/** Handlebars sub-expressions/blocks — never wrap these in `{{esc}}`. */
-const NON_VALUE_MUSTACHE = /^[#/!>^&]|^\s*else\b/;
-/**
-* Evaluate one Jexl expression.
-*
-* Jexl is used instead of `eval()` so a template can never reach globals, the
-* DOM, or `fetch` — the worst a malicious template can do is compute a wrong
-* number.
-*/
-function evaluateExpression(expression, context) {
-	try {
-		return jexl.evalSync(expression, context);
-	} catch (err) {
-		const reason = err instanceof Error ? err.message : String(err);
-		throw new Error(`[mono-export] cannot evaluate {{= ${expression} }} — ${reason}`);
-	}
-}
-/**
-* Normalise JS habits that Jexl's grammar doesn't share. Everyone types `===`;
-* Jexl only knows `==`, and would otherwise throw a bare "Token = unexpected".
-*/
-function normalizeExpression(expression) {
-	return expression.replace(/===/g, "==").replace(/!==/g, "!=");
-}
-/** Escape a string for embedding in a Handlebars double-quoted literal. */
-function toHandlebarsLiteral(value) {
-	return `"${value.replace(/\\/g, "\\\\").replace(/"/g, "\\\"")}"`;
-}
-/**
-* Find the `}}` that closes a mustache opened at `start`, ignoring any that
-* appear inside a quoted string (`{{= name == "a}}b" }}` is one expression).
-* Returns the index of the `}}`, or `-1` when unterminated.
-*/
-function findMustacheEnd(src, start) {
-	let quote = null;
-	for (let i = start; i < src.length - 1; i += 1) {
-		const ch = src[i];
-		if (quote) {
-			if (ch === "\\") i += 1;
-			else if (ch === quote) quote = null;
-			continue;
-		}
-		if (ch === "\"" || ch === "'") {
-			quote = ch;
-			continue;
-		}
-		if (ch === "}" && src[i + 1] === "}") return i;
-	}
-	return -1;
-}
-/** Whether `line` is a GFM table row (`| a | b |`), ignoring indentation. */
-function isTableRow(line) {
-	return /^\s{0,3}\|/.test(line);
-}
-/**
-* Rewrite a template's mustaches. Single pass, line-aware (for table rows) and
-* code-aware (fenced blocks + inline spans are copied verbatim).
-*/
-function preprocessTemplate(src, opts = {}) {
-	const escapeCells = opts.escapeTableCells !== false;
-	const lines = src.split("\n");
-	const state = {
-		fence: null,
-		inCode: false
-	};
-	const out = [];
-	for (const line of lines) {
-		const fenceMatch = /^\s{0,3}(`{3,}|~{3,})/.exec(line);
-		if (fenceMatch) {
-			const marker = fenceMatch[1][0].repeat(3);
-			if (state.fence === null) state.fence = marker;
-			else if (state.fence === marker) state.fence = null;
-			out.push(line);
-			continue;
-		}
-		if (state.fence) {
-			out.push(line);
-			continue;
-		}
-		out.push(rewriteLine(line, escapeCells && isTableRow(line), state));
-	}
-	return out.join("\n");
-}
-/** Rewrite the mustaches on one non-fenced line. */
-function rewriteLine(line, wrapCells, state) {
-	let out = "";
-	let i = 0;
-	while (i < line.length) {
-		const ch = line[i];
-		if (ch === "`") {
-			state.inCode = !state.inCode;
-			out += ch;
-			i += 1;
-			continue;
-		}
-		if (state.inCode || ch !== "{" || line[i + 1] !== "{") {
-			out += ch;
-			i += 1;
-			continue;
-		}
-		const isTriple = line[i + 2] === "{";
-		const open = isTriple ? i + 3 : i + 2;
-		const end = findMustacheEnd(line, open);
-		if (end === -1) {
-			out += line.slice(i);
-			break;
-		}
-		const closeLength = isTriple && line[end + 2] === "}" ? 3 : 2;
-		const inner = line.slice(open, end);
-		out += renderMustache(inner, {
-			isTriple,
-			wrapCells
-		});
-		i = end + closeLength;
-	}
-	return out;
-}
-/**
-* Split a mustache body into its Handlebars whitespace-control markers and the
-* expression between them, so `{{~ foo ~}}` keeps its `~`s after rewriting.
-*/
-function splitWhitespaceControl(inner) {
-	let body = inner;
-	let open = "";
-	let close = "";
-	if (body.startsWith("~")) {
-		open = "~";
-		body = body.slice(1);
-	}
-	if (body.endsWith("~")) {
-		close = "~";
-		body = body.slice(0, -1);
-	}
-	return {
-		open,
-		body: body.trim(),
-		close
-	};
-}
-/**
-* Whether `body` is a bare path (`Name.Full`, `[my field]`, `@index`) rather
-* than a helper call (`currency salary`).
-*
-* This distinction decides how the value is handed to `esc`: a path is passed
-* as an **argument** (`{{esc Name.Full}}`), while a helper call must become a
-* **sub-expression** (`{{esc (currency salary)}}`). Getting it backwards breaks
-* at runtime — `(Name.Full)` compiles to a helper invocation, and Handlebars
-* then tries to *call* the string it resolved.
-*/
-function isBarePath(body) {
-	return (body.startsWith("[") ? body.slice(body.indexOf("]") + 1) : body.replace(/^\S+/, "")).trim() === "";
-}
-/** Turn one mustache body into its rewritten `{{…}}` form. */
-function renderMustache(inner, { isTriple, wrapCells }) {
-	const { open, body, close } = splitWhitespaceControl(inner);
-	const wrap = (expr) => `{{${open}${expr}${close}}}`;
-	if (body.startsWith("=")) {
-		const call = `__jexl ${toHandlebarsLiteral(normalizeExpression(body.slice(1).trim()))}`;
-		return wrap(wrapCells ? `esc (${call})` : call);
-	}
-	if (isTriple) return `{{{${inner}}}}`;
-	if (NON_VALUE_MUSTACHE.test(body)) return wrap(body);
-	if (wrapCells) return wrap(isBarePath(body) ? `esc ${body}` : `esc (${body})`);
-	return wrap(body);
-}
-/**
-* Escape an interpolated value for a GFM table cell. Registered as the `esc`
-* helper and applied automatically to table-row mustaches by
-* {@link preprocessTemplate}; also callable by hand.
-*/
-function escapeForCell(value) {
-	if (value == null) return "";
-	return escapeCellText(String(value));
-}
-
-//#endregion
-//#region src/export/helpers.ts
-/**
-* Built-in Handlebars helpers for report templates.
-*
-* Three families:
-*
-* - **Formatting** (`currency`, `number`, `date`, `percent`) — emit pretty
-*   display text *plus* a hidden {@link ValueDirective} carrying the raw value
-*   and an Excel number format. That's what keeps `SUM()` working: Markdown
-*   shows `Rp 1.000.000`, the spreadsheet stores `1000000`.
-* - **Aggregation / logic** (`sum`, `avg`, `count`, `eq`, `gt`, …) — plain
-*   values, so they nest as sub-expressions: `{{currency (sum rows "Salary")}}`.
-* - **Excel-only** (`style`, `rowStyle`, `merge`, `formula`, `image`) — emit a
-*   directive and no visible text, so they vanish from Markdown output.
-*/
-/** Drop Handlebars' trailing options object, returning it alongside the args. */
-function splitArgs(args) {
-	const last = args[args.length - 1];
-	const isOptions = !!last && typeof last === "object" && "hash" in last;
-	return {
-		args: isOptions ? args.slice(0, -1) : args,
-		hash: (isOptions ? last.hash : void 0) ?? {}
-	};
-}
-/** Coerce to a finite number, or `null` when the value isn't numeric. */
-function toNumber(value) {
-	if (typeof value === "number") return Number.isFinite(value) ? value : null;
-	if (typeof value === "string" && value.trim() !== "") {
-		const n = Number(value);
-		return Number.isFinite(n) ? n : null;
-	}
-	return null;
-}
-/** Coerce to a Date, or `null`. Accepts a Date, an ISO string, or epoch ms. */
-function toDate(value) {
-	if (value instanceof Date) return Number.isNaN(value.getTime()) ? null : value;
-	if (typeof value === "number" || typeof value === "string") {
-		const d = new Date(value);
-		return Number.isNaN(d.getTime()) ? null : d;
-	}
-	return null;
-}
-/** Pull `field` off each item (or the item itself when no field is given). */
-function pluck(list, field) {
-	if (!Array.isArray(list)) return [];
-	if (typeof field !== "string" || !field) return list;
-	return list.map((item) => item?.[field]);
-}
-/** The numeric values of `list[field]`, skipping anything non-numeric. */
-function numbersOf(list, field) {
-	return pluck(list, field).map(toNumber).filter((n) => n !== null);
-}
-/**
-* Derive an Excel number format from a currency code by asking `Intl` where the
-* symbol goes and how many decimals it uses — so IDR renders `"Rp"#,##0` and
-* EUR-in-German renders `#,##0.00" €"` without a hard-coded lookup table.
-*/
-function deriveCurrencyFormat(locale, currency) {
-	try {
-		const parts = new Intl.NumberFormat(locale, {
-			style: "currency",
-			currency
-		}).formatToParts(1);
-		const symbol = parts.find((p) => p.type === "currency")?.value ?? currency;
-		const fraction = parts.find((p) => p.type === "fraction")?.value ?? "";
-		const digits = fraction.length ? `.${"0".repeat(fraction.length)}` : "";
-		const symbolFirst = parts.findIndex((p) => p.type === "currency") === 0;
-		const quoted = `"${symbol}"`;
-		return symbolFirst ? `${quoted}#,##0${digits}` : `#,##0${digits}${quoted}`;
-	} catch {
-		return "#,##0.00";
-	}
-}
-/**
-* Display text + the raw value/format directive that Excel will pick up. The
-* display text is echoed back into the directive (`t`) so the renderer can tell
-* "this cell *is* the value" from "this value is mentioned mid-sentence".
-*/
-function formatted(display, directive) {
-	return display + encodeDirective({
-		k: "val",
-		...directive,
-		t: display
-	});
-}
-/**
-* Build the built-in helper map for one render. Bound to `formatting` so
-* locale/currency choices apply consistently across every helper.
-*/
-function createHelpers(formatting = {}) {
-	const locale = formatting.locale;
-	const currencyCode = formatting.currency ?? "USD";
-	const currencyFormat = formatting.currencyFormat ?? deriveCurrencyFormat(locale, currencyCode);
-	const numberFormat = formatting.numberFormat ?? "#,##0";
-	const dateFormat = formatting.dateFormat ?? "yyyy-mm-dd";
-	const percentFormat = formatting.percentFormat ?? "0.00%";
-	return {
-		/** `{{currency salary}}` → `$1,234.00` in Markdown, `1234` + format in Excel. */
-		currency(...raw) {
-			const { args, hash } = splitArgs(raw);
-			const n = toNumber(args[0]);
-			if (n === null) return "";
-			const code = hash.code ?? currencyCode;
-			return formatted(new Intl.NumberFormat(locale, {
-				style: "currency",
-				currency: code
-			}).format(n), {
-				n,
-				f: hash.fmt ?? (code === currencyCode ? currencyFormat : deriveCurrencyFormat(locale, code))
-			});
-		},
-		/** `{{number qty}}` / `{{number rate decimals=2}}`. */
-		number(...raw) {
-			const { args, hash } = splitArgs(raw);
-			const n = toNumber(args[0]);
-			if (n === null) return "";
-			const decimals = toNumber(hash.decimals);
-			return formatted(new Intl.NumberFormat(locale, {
-				minimumFractionDigits: decimals ?? void 0,
-				maximumFractionDigits: decimals ?? void 0
-			}).format(n), {
-				n,
-				f: hash.fmt ?? (decimals ? `#,##0.${"0".repeat(decimals)}` : numberFormat)
-			});
-		},
-		/** `{{date createdAt}}` — Markdown gets the locale date, Excel a real Date. */
-		date(...raw) {
-			const { args, hash } = splitArgs(raw);
-			const d = toDate(args[0]);
-			if (!d) return "";
-			return formatted(new Intl.DateTimeFormat(locale, {
-				year: "numeric",
-				month: "2-digit",
-				day: "2-digit"
-			}).format(d), {
-				d: d.toISOString(),
-				f: hash.fmt ?? dateFormat
-			});
-		},
-		/** `{{percent 0.155}}` → `15.50%`; Excel stores the fraction with a % format. */
-		percent(...raw) {
-			const { args, hash } = splitArgs(raw);
-			const n = toNumber(args[0]);
-			if (n === null) return "";
-			return formatted(new Intl.NumberFormat(locale, {
-				style: "percent",
-				minimumFractionDigits: 2
-			}).format(n), {
-				n,
-				f: hash.fmt ?? percentFormat
-			});
-		},
-		/** `{{sum employees "salary"}}` — or `{{sum numbers}}` for a bare array. */
-		sum: (...raw) => {
-			const { args } = splitArgs(raw);
-			return numbersOf(args[0], args[1]).reduce((total, n) => total + n, 0);
-		},
-		avg: (...raw) => {
-			const { args } = splitArgs(raw);
-			const values = numbersOf(args[0], args[1]);
-			return values.length ? values.reduce((t, n) => t + n, 0) / values.length : 0;
-		},
-		/** `{{count employees}}` — length, or how many have a truthy `field`. */
-		count: (...raw) => {
-			const { args } = splitArgs(raw);
-			const list = args[0];
-			if (!Array.isArray(list)) return 0;
-			return typeof args[1] === "string" ? pluck(list, args[1]).filter((v) => v != null && v !== "").length : list.length;
-		},
-		max: (...raw) => {
-			const { args } = splitArgs(raw);
-			const values = numbersOf(args[0], args[1]);
-			return values.length ? Math.max(...values) : 0;
-		},
-		min: (...raw) => {
-			const { args } = splitArgs(raw);
-			const values = numbersOf(args[0], args[1]);
-			return values.length ? Math.min(...values) : 0;
-		},
-		eq: (...raw) => {
-			const { args } = splitArgs(raw);
-			return args[0] === args[1];
-		},
-		ne: (...raw) => {
-			const { args } = splitArgs(raw);
-			return args[0] !== args[1];
-		},
-		gt: (...raw) => compare(raw, (a, b) => a > b),
-		gte: (...raw) => compare(raw, (a, b) => a >= b),
-		lt: (...raw) => compare(raw, (a, b) => a < b),
-		lte: (...raw) => compare(raw, (a, b) => a <= b),
-		and: (...raw) => splitArgs(raw).args.every(Boolean),
-		or: (...raw) => splitArgs(raw).args.some(Boolean),
-		not: (...raw) => !splitArgs(raw).args[0],
-		/** `{{default value "-"}}` — fall back when null / undefined / empty. */
-		default: (...raw) => {
-			const { args } = splitArgs(raw);
-			const value = args[0];
-			return value == null || value === "" ? args[1] ?? "" : value;
-		},
-		/**
-		* Escape a value for a GFM table cell. Applied automatically to mustaches on
-		* table rows by the preprocessor; call it by hand elsewhere if needed.
-		*/
-		esc: (...raw) => escapeForCell(splitArgs(raw).args[0]),
-		/** `{{style "header"}}` — apply a named style to this cell. */
-		style: (...raw) => {
-			const { args } = splitArgs(raw);
-			const name = args[0];
-			return typeof name === "string" && name ? encodeDirective({
-				k: "style",
-				v: name
-			}) : "";
-		},
-		/** `{{rowStyle "groupHeader"}}` — apply a named style to the whole row. */
-		rowStyle: (...raw) => {
-			const { args } = splitArgs(raw);
-			const name = args[0];
-			return typeof name === "string" && name ? encodeDirective({
-				k: "rowStyle",
-				v: name
-			}) : "";
-		},
-		/** `{{merge cols=4}}` — merge this cell across columns and/or rows. */
-		merge: (...raw) => {
-			const { hash } = splitArgs(raw);
-			const cols = toNumber(hash.cols);
-			const rows = toNumber(hash.rows);
-			if (!cols && !rows) return "";
-			return encodeDirective({
-				k: "merge",
-				...cols ? { cols: Math.max(1, Math.floor(cols)) } : {},
-				...rows ? { rows: Math.max(1, Math.floor(rows)) } : {}
-			});
-		},
-		/**
-		* `{{formula "SUM(C{row}:D{row})"}}` — an Excel formula for this cell.
-		* `{row}`, `{firstRow}`, `{lastRow}` and `{col:Field}` are resolved when the
-		* cell is written, since a template can't know its own row number.
-		*/
-		formula: (...raw) => {
-			const { args } = splitArgs(raw);
-			const expr = args[0];
-			return typeof expr === "string" && expr ? encodeDirective({
-				k: "formula",
-				v: expr
-			}) : "";
-		},
-		/** `{{image logo width=120 height=40}}` — anchor an image at this cell. */
-		image: (...raw) => {
-			const { args, hash } = splitArgs(raw);
-			const src = args[0];
-			if (typeof src !== "string" || !src) return "";
-			const width = toNumber(hash.width);
-			const height = toNumber(hash.height);
-			return encodeDirective({
-				k: "image",
-				v: src,
-				...width ? { width } : {},
-				...height ? { height } : {}
-			});
-		}
-	};
-}
-/** Numeric-aware comparison shared by `gt` / `gte` / `lt` / `lte`. */
-function compare(raw, test) {
-	const { args } = splitArgs(raw);
-	const a = toNumber(args[0]);
-	const b = toNumber(args[1]);
-	if (a !== null && b !== null) return test(a, b);
-	return test(args[0], args[1]);
-}
-
-//#endregion
-//#region src/export/template.ts
-/** Load the optional `handlebars` peer, with an actionable error when it's absent. */
-async function loadHandlebars() {
-	try {
-		const mod = await import("handlebars");
-		return mod?.default ?? mod;
-	} catch (err) {
-		throw new Error("[mono-export] rendering a report needs the optional peer dependency \"handlebars\". Install it in your app: pnpm add handlebars" + (err instanceof Error ? `\n  (resolution failed: ${err.message})` : ""));
-	}
-}
-/**
-* Render a report template to Markdown (still carrying directive tokens).
-*
-* `noEscape` is deliberate: Handlebars' default escaping is *HTML* escaping,
-* which would turn `&` into `&amp;` and `"` into `&quot;` inside a spreadsheet
-* cell. Table cells are protected instead by the `esc` helper, which the
-* preprocessor injects only where it matters (see `expression.ts`).
-*/
-async function renderTemplate(options) {
-	const env = (await loadHandlebars()).create();
-	env.registerHelper(createHelpers(options.formatting));
-	/**
-	* The bridge to Jexl. `this` is the current block context (inside `{{#each}}`
-	* it's the item), `options.data.root` is the whole report context — merging
-	* them lets an expression name a loop-local field *and* a top-level one.
-	*/
-	env.registerHelper("__jexl", function(...args) {
-		const helperOptions = args[args.length - 1];
-		const expression = String(args[0] ?? "");
-		const root = helperOptions?.data?.root ?? {};
-		const local = typeof this === "object" && this !== null ? this : {};
-		const value = evaluateExpression(expression, {
-			...root,
-			...local,
-			this: local
-		});
-		return value == null ? "" : value;
-	});
-	if (options.helpers) env.registerHelper(options.helpers);
-	if (options.partials) for (const [name, source] of Object.entries(options.partials)) env.registerPartial(name, preprocessTemplate(source));
-	return env.compile(preprocessTemplate(options.md ?? ""), { noEscape: true })(options.data ?? {});
-}
-
-//#endregion
-//#region src/export/index.ts
-/**
-* `@mono-lit/helper/export` — render a Markdown template into a report.
-*
-* The pipeline: **Handlebars** fills the template from your data, **Jexl**
-* evaluates any `{{= … }}` expressions, **remark** parses the result into an
-* AST, and a renderer walks that AST. Markdown is the template language, so the
-* layout stays readable and diffable, and the data stays separate from the
-* presentation.
-*
-* @example
-* import { exportTable } from '@mono-lit/helper/export'
-* import md from './payroll.md?raw'
-*
-* const report = await exportTable({ md, data: { employees }, fileName: 'payroll.xlsx' })
-* report.markdown // the rendered markdown, for a preview pane
-*
-* Bound to a grid, `monoDataGrid(...).export({ md, … })` does the same thing
-* with the table's rows, groups and columns already in the context.
-*/
-/** Pick the renderer from a file name's extension. */
-function formatFromFileName(fileName) {
-	if (!fileName) return null;
-	const ext = fileName.slice(fileName.lastIndexOf(".") + 1).toLowerCase();
-	if (ext === "xlsx" || ext === "xls") return "xlsx";
-	if (ext === "md" || ext === "markdown") return "md";
-	return null;
-}
-/** Give a file name the extension its format implies. */
-function withExtension(fileName, format) {
-	return formatFromFileName(fileName) === format ? fileName : `${fileName}.${format}`;
-}
-/**
-* Render a Markdown report template.
-*
-* When `fileName` is given its extension selects the renderer and the file
-* downloads automatically (pass `download: false` to suppress that). Without
-* one, nothing is written — you just get the result object.
-*/
-async function exportTable(options) {
-	const data = await resolveExportData(options.data, { chunkSize: options.chunkSize });
-	const rendered = await renderTemplate({
-		...options,
-		data
-	});
-	const markdown = stripDirectives(rendered);
-	const resolvedFormat = options.format ?? formatFromFileName(options.fileName);
-	const detailSheets = [];
-	const skipped = [];
-	if (options.detail) {
-		const detail = options.detail;
-		const masterRows = data[detail.from ?? "rows"];
-		const { details, skipped: dropped } = await resolveDetails(Array.isArray(masterRows) ? masterRows : [], detail);
-		skipped.push(...dropped);
-		for (const item of details) detailSheets.push({
-			key: item.key,
-			name: detail.sheetName?.(item.row) ?? item.key,
-			markdown: await renderTemplate({
-				...options,
-				md: detail.md,
-				data: {
-					row: item.row,
-					rows: item.rows
-				}
-			})
-		});
-	}
-	let workbookPromise = null;
-	const workbook = () => {
-		workbookPromise ??= import("./excel-BXzr3uI1.js").then(({ renderExcel }) => renderExcel(parseMarkdown(rendered), {
-			...options,
-			back: options.detail?.back,
-			sheets: detailSheets.map((s) => ({
-				key: s.key,
-				name: s.name,
-				ast: parseMarkdown(s.markdown)
-			}))
-		})).then(async (book) => {
-			await options.onWorkbook?.(book);
-			return book;
-		});
-		return workbookPromise;
-	};
-	const toBuffer = async (format) => {
-		if ((format ?? resolvedFormat ?? "md") === "md") return new TextEncoder().encode(markdown).buffer;
-		return await (await workbook()).xlsx.writeBuffer();
-	};
-	const toBlob = async (format) => {
-		const target = format ?? resolvedFormat ?? "md";
-		return new Blob([await toBuffer(target)], { type: MIME[target] });
-	};
-	const download = async (fileName) => {
-		const target = resolvedFormat ?? formatFromFileName(fileName) ?? "md";
-		const name = withExtension(fileName ?? options.fileName ?? "export", target);
-		downloadBlob(await toBlob(target), name);
-	};
-	const result = {
-		markdown,
-		format: resolvedFormat,
-		fileName: options.fileName ?? null,
-		sheets: [options.sheetName ?? "Sheet1", ...detailSheets.map((s) => s.name)],
-		skipped,
-		toBlob,
-		toBuffer,
-		workbook,
-		download
-	};
-	if (options.fileName && options.download !== false) await download();
-	return result;
-}
-
-//#endregion
-export { exportTable };