@olenbetong/appframe-core 2.11.9 → 2.12.0

package/dist/esm/af.common.js

@@ -1,515 +1,1915 @@
-// ../../node_modules/.pnpm/mitt@3.0.1/node_modules/mitt/dist/mitt.mjs
+//#region ../../node_modules/.pnpm/mitt@3.0.1/node_modules/mitt/dist/mitt.mjs
 function mitt_default(n) {
-  return { all: n = n || /* @__PURE__ */ new Map(), on: function(t, e) {
-    var i = n.get(t);
-    i ? i.push(e) : n.set(t, [e]);
-  }, off: function(t, e) {
-    var i = n.get(t);
-    i && (e ? i.splice(i.indexOf(e) >>> 0, 1) : n.set(t, []));
-  }, emit: function(t, e) {
-    var i = n.get(t);
-    i && i.slice().map(function(n2) {
-      n2(e);
-    }), (i = n.get("*")) && i.slice().map(function(n2) {
-      n2(t, e);
-    });
-  } };
-}
-
-// src/SessionHandler.ts
+	return {
+		all: n = n || /* @__PURE__ */ new Map(),
+		on: function(t, e) {
+			var i = n.get(t);
+			i ? i.push(e) : n.set(t, [e]);
+		},
+		off: function(t, e) {
+			var i = n.get(t);
+			i && (e ? i.splice(i.indexOf(e) >>> 0, 1) : n.set(t, []));
+		},
+		emit: function(t, e) {
+			var i = n.get(t);
+			i && i.slice().map(function(n) {
+				n(e);
+			}), (i = n.get("*")) && i.slice().map(function(n) {
+				n(t, e);
+			});
+		}
+	};
+}
+
+//#endregion
+//#region \0@oxc-project+runtime@0.143.0/helpers/esm/typeof.js
+function _typeof(o) {
+	"@babel/helpers - typeof";
+	return _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;
+	}, _typeof(o);
+}
+
+//#endregion
+//#region \0@oxc-project+runtime@0.143.0/helpers/esm/toPrimitive.js
+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);
+}
+
+//#endregion
+//#region \0@oxc-project+runtime@0.143.0/helpers/esm/toPropertyKey.js
+function toPropertyKey(t) {
+	var i = toPrimitive(t, "string");
+	return "symbol" == _typeof(i) ? i : i + "";
+}
+
+//#endregion
+//#region \0@oxc-project+runtime@0.143.0/helpers/esm/defineProperty.js
+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;
+}
+
+//#endregion
+//#region src/SessionHandler.ts
 var SessionHandler = class {
-  eventHandler = mitt_default();
-  authenticated() {
-    this.eventHandler.emit("onAuthenticated");
-  }
-  async expired(callback, type) {
-    try {
-      let authPromise = new Promise((resolve) => {
-        let eventHandler = () => {
-          this.eventHandler.off("onAuthenticated", eventHandler);
-          callback?.();
-          resolve();
-        };
-        this.eventHandler.on("onAuthenticated", eventHandler);
-      });
-      let dialog = document.querySelector("dialog.session-expired-dialog");
-      if (!dialog) {
-        dialog = document.createElement("dialog");
-        dialog.className = "session-expired-dialog";
-        dialog.style.display = "flex";
-        dialog.style.padding = "0";
-        dialog.style.left = "50%";
-        dialog.style.transform = "translateX(-50%)";
-        let link = "/login?ReturnUrl=%2fapi/sessionexpired/remove";
-        if (type !== "RequireTwoFactor") {
-          await fetch("/logout", { method: "POST" });
-        } else {
-          link = "/login?RequireTwoFactor=1&ReturnUrl=%2fapi/sessionexpired/remove";
-        }
-        dialog.innerHTML = `<iframe sandbox="allow-same-origin allow-scripts allow-modals allow-top-navigation-by-user-activation allow-forms" src="${link}" style="border:0;width:min(500px,100vw);height:min(700px, 100vh);"></iframe>`;
-        document.body.append(dialog);
-        dialog.showModal();
-        await authPromise;
-        dialog.remove();
-      } else {
-        await authPromise;
-      }
-    } catch (_) {
-      window.location.href = `/login?ReturnUrl=${encodeURIComponent(window.location.pathname)}${encodeURIComponent(
-        window.location.search
-      )}`;
-    }
-  }
-  attachEvent(eventName, handler) {
-    return this.eventHandler.on(eventName, handler);
-  }
-  detachEvent(eventName, handler) {
-    return this.eventHandler.off(eventName, handler);
-  }
+	constructor() {
+		_defineProperty(this, "eventHandler", mitt_default());
+	}
+	authenticated() {
+		this.eventHandler.emit("onAuthenticated");
+	}
+	async expired(callback, type) {
+		try {
+			let authPromise = new Promise((resolve) => {
+				let eventHandler = () => {
+					this.eventHandler.off("onAuthenticated", eventHandler);
+					callback?.();
+					resolve();
+				};
+				this.eventHandler.on("onAuthenticated", eventHandler);
+			});
+			let dialog = document.querySelector("dialog.session-expired-dialog");
+			if (!dialog) {
+				dialog = document.createElement("dialog");
+				dialog.className = "session-expired-dialog";
+				dialog.style.display = "flex";
+				dialog.style.padding = "0";
+				dialog.style.left = "50%";
+				dialog.style.transform = "translateX(-50%)";
+				let link = "/login?ReturnUrl=%2fapi/sessionexpired/remove";
+				if (type !== "RequireTwoFactor") await fetch("/logout", { method: "POST" });
+				else link = "/login?RequireTwoFactor=1&ReturnUrl=%2fapi/sessionexpired/remove";
+				dialog.innerHTML = `<iframe sandbox="allow-same-origin allow-scripts allow-modals allow-top-navigation-by-user-activation allow-forms" src="${link}" style="border:0;width:min(500px,100vw);height:min(700px, 100vh);"></iframe>`;
+				document.body.append(dialog);
+				dialog.showModal();
+				await authPromise;
+				dialog.remove();
+			} else await authPromise;
+		} catch (_) {
+			window.location.href = `/login?ReturnUrl=${encodeURIComponent(window.location.pathname)}${encodeURIComponent(window.location.search)}`;
+		}
+	}
+	attachEvent(eventName, handler) {
+		return this.eventHandler.on(eventName, handler);
+	}
+	detachEvent(eventName, handler) {
+		return this.eventHandler.off(eventName, handler);
+	}
 };
 
-// src/UserSession.ts
+//#endregion
+//#region src/UserSession.ts
 var UserSession = class extends SessionHandler {
-  amDesignator = "a.m.";
-  dayNames = ["sunday", "monday", "tuesday", "wednesday", "thursday", "friday", "saturday"];
-  dayNamesShort = ["sun", "mon", "tue", "wed", "thu", "fri", "sat"];
-  decimalSeparator = ".";
-  domain = "OB";
-  email;
-  formats;
-  groupSeparator = null;
-  integratedSecurity = false;
-  isDeveloper = false;
-  login = "";
-  loginType;
-  monthNames = [
-    "january",
-    "february",
-    "march",
-    "april",
-    "may",
-    "june",
-    "july",
-    "august",
-    "september",
-    "october",
-    "november",
-    "december",
-    ""
-  ];
-  monthNamesShort = ["jan", "feb", "mar", "apr", "may", "jun", "jul", "augt", "sep", "oct", "nov", "dec", ""];
-  name;
-  pmDesignator = "p.m.";
-  shortDateFormat = "dd.MM.yyyy";
-  culture = "en-GB";
-  uiculture = "en-GB";
-  constructor(userData) {
-    super();
-    this.formats = {};
-    Object.assign(this, userData);
-  }
+	constructor(userData) {
+		super();
+		_defineProperty(this, "amDesignator", "a.m.");
+		_defineProperty(this, "dayNames", [
+			"sunday",
+			"monday",
+			"tuesday",
+			"wednesday",
+			"thursday",
+			"friday",
+			"saturday"
+		]);
+		_defineProperty(this, "dayNamesShort", [
+			"sun",
+			"mon",
+			"tue",
+			"wed",
+			"thu",
+			"fri",
+			"sat"
+		]);
+		_defineProperty(this, "decimalSeparator", ".");
+		_defineProperty(this, "domain", "OB");
+		_defineProperty(this, "email", void 0);
+		_defineProperty(this, "formats", void 0);
+		_defineProperty(this, "groupSeparator", null);
+		_defineProperty(this, "integratedSecurity", false);
+		_defineProperty(this, "isDeveloper", false);
+		_defineProperty(this, "login", "");
+		_defineProperty(this, "loginType", void 0);
+		_defineProperty(this, "monthNames", [
+			"january",
+			"february",
+			"march",
+			"april",
+			"may",
+			"june",
+			"july",
+			"august",
+			"september",
+			"october",
+			"november",
+			"december",
+			""
+		]);
+		_defineProperty(this, "monthNamesShort", [
+			"jan",
+			"feb",
+			"mar",
+			"apr",
+			"may",
+			"jun",
+			"jul",
+			"augt",
+			"sep",
+			"oct",
+			"nov",
+			"dec",
+			""
+		]);
+		_defineProperty(this, "name", void 0);
+		_defineProperty(this, "pmDesignator", "p.m.");
+		_defineProperty(this, "shortDateFormat", "dd.MM.yyyy");
+		_defineProperty(this, "culture", "en-GB");
+		_defineProperty(this, "uiculture", "en-GB");
+		this.formats = {};
+		Object.assign(this, userData);
+	}
 };
 
-// src/log.ts
-var article = window.af?.article?.id ?? window.window?.location.pathname.substring(1).split("/")[0];
+//#endregion
+//#region src/log.ts
+const article = window.af?.article?.id ?? window.window?.location.pathname.substring(1).split("/")[0];
+/**
+* Logs an activity to the website activity log
+*
+* @param activity name of the activity we are logging
+* @param parameters A dictionary of parameters used when doing the activity
+* @param timeElapsed Number of milliseconds elapsed while executing
+*/
 async function logActivity(activity, parameters = {}, timeElapsed = 0) {
-  try {
-    let response = await fetch("/api/logging/log-activity", {
-      method: "POST",
-      body: JSON.stringify({
-        article,
-        timeElapsed,
-        action: activity,
-        parameters: {
-          ...parameters,
-          _session: getSessionData()
-        }
-      }),
-      headers: { "Content-Type": "application/json", Accept: "application/json" }
-    });
-    if (!response.ok) {
-      if (response.headers.get("Content-Type")?.includes("application/json")) {
-        let data = await response.json();
-        console.error(data.error);
-      } else {
-        console.error(`${response.status} ${response.statusText}`);
-      }
-    }
-  } catch {
-  }
+	try {
+		let response = await fetch("/api/logging/log-activity", {
+			method: "POST",
+			body: JSON.stringify({
+				article,
+				timeElapsed,
+				action: activity,
+				parameters: {
+					...parameters,
+					_session: getSessionData()
+				}
+			}),
+			headers: {
+				"Content-Type": "application/json",
+				Accept: "application/json"
+			}
+		});
+		if (!response.ok) {
+			if (response.headers.get("Content-Type")?.includes("application/json")) {
+				let data = await response.json();
+				console.error(data.error);
+			} else console.error(`${response.status} ${response.statusText}`);
+		}
+	} catch {}
 }
+/**
+* Records the current time, and returns a function that logs the activity with the
+* time elapsed when it is called.
+*
+* @param activity  Name of the activity we are logging
+* @param parameters A dictionary of parameters used when doing the activity
+* @returns A function that should be called when the activity is completed to log it to the website log
+*/
 function startActivity(activity, startParameters = {}) {
-  let start = performance.now();
-  return (endParameters = {}) => logActivity(activity, { ...startParameters, ...endParameters }, performance.now() - start);
+	let start = performance.now();
+	return (endParameters = {}) => logActivity(activity, {
+		...startParameters,
+		...endParameters
+	}, performance.now() - start);
 }
+/**
+* Records the time used to execute an operation and returns the value of the operation and the time
+* in milliseconds
+*/
 async function time(callback) {
-  let start = performance.now();
-  let returnValue = await callback();
-  return [returnValue, performance.now() - start];
+	let start = performance.now();
+	return [await callback(), performance.now() - start];
 }
 async function logError(error) {
-  try {
-    if (!error) return;
-    let data = typeof error === "string" ? { error } : typeof error === "object" ? "message" in error ? {
-      error: error.message,
-      stack: error.stack ?? null
-    } : { error: error.toString() } : { error: "Unspecified error" };
-    console.error(error);
-    let result = await fetch("/data/Logger/LogError", {
-      method: "POST",
-      body: JSON.stringify(data),
-      headers: {
-        "Content-Type": "application/json; charset=utf-8"
-      }
-    });
-    if (result.ok) {
-      return await result.json();
-    }
-    console.error(Error("Failed to log error"));
-  } catch {
-  }
+	try {
+		if (!error) return;
+		let data = typeof error === "string" ? { error } : typeof error === "object" ? "message" in error ? {
+			error: error.message,
+			stack: error.stack ?? null
+		} : { error: error.toString() } : { error: "Unspecified error" };
+		console.error(error);
+		let result = await fetch("/data/Logger/LogError", {
+			method: "POST",
+			body: JSON.stringify(data),
+			headers: { "Content-Type": "application/json; charset=utf-8" }
+		});
+		if (result.ok) return await result.json();
+		console.error(Error("Failed to log error"));
+	} catch {}
 }
 function getSessionId() {
-  return crypto.randomUUID?.();
+	return crypto.randomUUID?.();
 }
-var sessionStart = Date.now();
-var sessionId = getSessionId();
-var deviceId = "";
-var browserSessionId = "";
+let sessionStart = Date.now();
+let sessionId = getSessionId();
+let deviceId = "";
+let browserSessionId = "";
 if ("document" in window) {
-  let startSession = () => logActivity("AfSessionInit", {
-    "appframe-core": window.af?.common?.version,
-    "appframe-data": window.af?.data?.version,
-    "app-version": window.af?.article?.version
-  });
-  document.addEventListener("DOMContentLoaded", () => {
-    deviceId = localStorage.getItem("_afDeviceId");
-    browserSessionId = sessionStorage.getItem("_afSessionId");
-    if (!deviceId) {
-      deviceId = getSessionId();
-      localStorage.setItem("_afDeviceId", deviceId);
-    }
-    if (!browserSessionId) {
-      browserSessionId = sessionId;
-      sessionStorage.setItem("_afSessionId", browserSessionId);
-    }
-    startSession();
-  });
-  document.addEventListener("visibilitychange", function logData() {
-    if (document.visibilityState === "hidden") {
-      navigator.sendBeacon(
-        "/api/logging/log-activity",
-        JSON.stringify({
-          article,
-          action: "AfSessionEnd",
-          parameters: {
-            _session: getSessionData()
-          }
-        })
-      );
-    } else {
-      startSession();
-    }
-  });
+	let startSession = () => logActivity("AfSessionInit", {
+		"appframe-core": window.af?.common?.version,
+		"appframe-data": window.af?.data?.version,
+		"app-version": window.af?.article?.version
+	});
+	document.addEventListener("DOMContentLoaded", () => {
+		deviceId = localStorage.getItem("_afDeviceId");
+		browserSessionId = sessionStorage.getItem("_afSessionId");
+		if (!deviceId) {
+			deviceId = getSessionId();
+			localStorage.setItem("_afDeviceId", deviceId);
+		}
+		if (!browserSessionId) {
+			browserSessionId = sessionId;
+			sessionStorage.setItem("_afSessionId", browserSessionId);
+		}
+		startSession();
+	});
+	document.addEventListener("visibilitychange", function logData() {
+		if (document.visibilityState === "hidden") navigator.sendBeacon("/api/logging/log-activity", JSON.stringify({
+			article,
+			action: "AfSessionEnd",
+			parameters: { _session: getSessionData() }
+		}));
+		else startSession();
+	});
 }
 function getSessionData() {
-  return {
-    browserSessionId,
-    sessionStart,
-    sessionLength: Date.now() - sessionStart,
-    sessionId,
-    deviceId
-  };
-}
-
-// src/errorHandler.ts
-if (true) {
-  window.window?.addEventListener("error", (event) => {
-    if (typeof event === "object" && "error" in event) {
-      logError(event.error);
-    } else if (typeof event === "object" && "message" in event) {
-      logError(event);
-    }
-  });
-}
-
-// src/localStorage.ts
+	return {
+		browserSessionId,
+		sessionStart,
+		sessionLength: Date.now() - sessionStart,
+		sessionId,
+		deviceId
+	};
+}
+
+//#endregion
+//#region src/errorHandler.ts
+window.window?.addEventListener("error", (event) => {
+	if (typeof event === "object" && "error" in event) logError(event.error);
+	else if (typeof event === "object" && "message" in event) logError(event);
+});
+
+//#endregion
+//#region src/localStorage.ts
 function getLocalKey(key) {
-  return [af?.article?.id || "", "common", key].join(".");
+	return [
+		af?.article?.id || "",
+		"common",
+		key
+	].join(".");
 }
 var LocalStorage = class {
-  isPersisted = () => true;
-  getLocalStorageKey(key, global) {
-    return global ? ["common", key].join(".") : getLocalKey(key);
-  }
-  get(key, defaultValue, global) {
-    const lsKey = this.getLocalStorageKey(key, global);
-    const value = localStorage.getItem(lsKey);
-    return value !== null ? JSON.parse(value) : defaultValue;
-  }
-  set(key, value, global) {
-    localStorage.setItem(this.getLocalStorageKey(key, global), JSON.stringify(value));
-  }
-  remove(key, global) {
-    const lsKey = this.getLocalStorageKey(key, global);
-    if (localStorage.getItem(lsKey) !== null) {
-      localStorage.removeItem(lsKey);
-      return true;
-    } else {
-      return false;
-    }
-  }
-  clear() {
-    const baseKey = getLocalKey("");
-    for (let key in localStorage) {
-      if (key.slice(0, baseKey.length) === baseKey) {
-        localStorage.removeItem(key);
-      }
-    }
-  }
+	constructor() {
+		_defineProperty(this, "isPersisted", () => true);
+	}
+	getLocalStorageKey(key, global) {
+		return global ? ["common", key].join(".") : getLocalKey(key);
+	}
+	get(key, defaultValue, global) {
+		const lsKey = this.getLocalStorageKey(key, global);
+		const value = localStorage.getItem(lsKey);
+		return value !== null ? JSON.parse(value) : defaultValue;
+	}
+	set(key, value, global) {
+		localStorage.setItem(this.getLocalStorageKey(key, global), JSON.stringify(value));
+	}
+	remove(key, global) {
+		const lsKey = this.getLocalStorageKey(key, global);
+		if (localStorage.getItem(lsKey) !== null) {
+			localStorage.removeItem(lsKey);
+			return true;
+		} else return false;
+	}
+	clear() {
+		const baseKey = getLocalKey("");
+		for (let key in localStorage) if (key.slice(0, baseKey.length) === baseKey) localStorage.removeItem(key);
+	}
 };
 var localStorage_default = new LocalStorage();
 
-// src/date.ts
+//#endregion
+//#region src/date.ts
 function toLocalISODate(date) {
-  return date ? toLocalISODateTime(date).substring(0, 10) : null;
+	return date ? toLocalISODateTime(date).substring(0, 10) : null;
 }
 function pad(num, digits = 2) {
-  return String(num).padStart(digits, "0");
+	return String(num).padStart(digits, "0");
 }
 function toLocalISODateTime(date) {
-  return date ? `${date.getFullYear()}-${pad(date.getMonth() + 1)}-${pad(date.getDate())}T${pad(date.getHours())}:${pad(
-    date.getMinutes()
-  )}:${pad(date.getSeconds())}.${pad(date.getMilliseconds(), 3)}` : null;
+	return date ? `${date.getFullYear()}-${pad(date.getMonth() + 1)}-${pad(date.getDate())}T${pad(date.getHours())}:${pad(date.getMinutes())}:${pad(date.getSeconds())}.${pad(date.getMilliseconds(), 3)}` : null;
 }
+/**
+* Converts a date object to a string compatible with input type datetime-local.
+* Will handle the UTC value of the date as if it was local, to be compatible with
+* data objects.
+*
+* If null or undefined is passed, returns an empty string.
+*
+* @param date
+*/
 function toLocalDateTime(date) {
-  return date ? date.toISOString().substring(0, 16) : "";
+	return date ? date.toISOString().substring(0, 16) : "";
 }
 
-// src/downloadBlob.ts
+//#endregion
+//#region src/downloadBlob.ts
 function downloadBlob(blob, fileName) {
-  return new Promise((resolve, reject) => {
-    try {
-      const url = URL.createObjectURL(blob);
-      const parent = document.body;
-      const anchor = document.createElement("a");
-      anchor.setAttribute("download", fileName);
-      anchor.href = url;
-      parent.append(anchor);
-      anchor.click();
-      parent.removeChild(anchor);
-      setTimeout(() => {
-        URL.revokeObjectURL(url);
-        resolve();
-      }, 250);
-    } catch (ex) {
-      reject(ex);
-    }
-  });
-}
-
-// src/invariant.ts
+	return new Promise((resolve, reject) => {
+		try {
+			const url = URL.createObjectURL(blob);
+			const parent = document.body;
+			const anchor = document.createElement("a");
+			anchor.setAttribute("download", fileName);
+			anchor.href = url;
+			parent.append(anchor);
+			anchor.click();
+			parent.removeChild(anchor);
+			setTimeout(() => {
+				URL.revokeObjectURL(url);
+				resolve();
+			}, 250);
+		} catch (ex) {
+			reject(ex);
+		}
+	});
+}
+
+//#endregion
+//#region src/invariant.ts
+/**
+* Throws an error if the condition is falsy. The provided message is used as the error message.
+* A function can be provided to lazily generate the message.
+*
+* @param {any} condition
+* @param {string | (() => string)} [message]
+* @returns {void}
+*/
 function invariant(condition, message) {
-  if (condition) {
-    return;
-  }
-  const provided = typeof message === "function" ? message() : message;
-  throw new Error(provided ?? "Invariant failed");
+	if (condition) return;
+	const provided = typeof message === "function" ? message() : message;
+	throw new Error(provided ?? "Invariant failed");
 }
 
-// src/downloadRequest.ts
+//#endregion
+//#region src/downloadRequest.ts
 async function downloadRequest(request, { fileName, signal, onProgress }) {
-  let bytesReceived = 0;
-  onProgress?.({ status: "requested" });
-  try {
-    let response = await fetch(request);
-    if (!response.ok || !response.body) {
-      if (response.headers.get("content-type")?.includes("application/json")) {
-        let data = await response.json();
-        invariant(!data.error, data.error);
-      }
-      throw new Error(`${response.status} ${response.statusText}`);
-    }
-    try {
-      const reader = response.body.getReader();
-      const stream = new ReadableStream({
-        start: (controller) => {
-          function pump() {
-            return reader.read().then((read) => {
-              if (read.done) {
-                controller.close();
-                return;
-              }
-              bytesReceived += read.value.length;
-              onProgress?.({ bytesReceived, status: "downloading" });
-              controller.enqueue(read.value);
-              return pump();
-            });
-          }
-          return pump();
-        }
-      });
-      response = new Response(stream);
-    } catch {
-    }
-    const blob = await response.blob();
-    onProgress?.({ bytesReceived, status: "downloaded" });
-    await downloadBlob(blob, fileName);
-    onProgress?.({ bytesReceived, status: "completed" });
-  } catch (err) {
-    if (signal?.aborted) {
-      onProgress?.({ status: "cancelled" });
-    } else {
-      onProgress?.({ error: err.message, status: "error" });
-    }
-  }
-}
-
-// src/parseFunc.ts
-var funcRegex = /^function(?:\s+([a-zA-Z$_][a-zA-Z0-9$_]*))?\s*\(((?:(?:\s*[a-zA-Z$_][a-zA-Z0-9$_]*)(?:\s*,\s*[a-zA-Z$_][a-zA-Z0-9$_]*)*)?)\s*\)\s*\{((?:.|\n|\r)*)\}$/;
-function parseFunc(func) {
-  const match = func.toString().match(funcRegex);
-  invariant(match, "Unable to parse function!");
-  return { name: func.name ?? match[1], args: match[2].split(",").map((a) => a.trim()), body: match[3] };
+	let bytesReceived = 0;
+	onProgress?.({ status: "requested" });
+	try {
+		let response = await fetch(request);
+		if (!response.ok || !response.body) {
+			if (response.headers.get("content-type")?.includes("application/json")) {
+				let data = await response.json();
+				invariant(!data.error, data.error);
+			}
+			throw new Error(`${response.status} ${response.statusText}`);
+		}
+		try {
+			const reader = response.body.getReader();
+			const stream = new ReadableStream({ start: (controller) => {
+				function pump() {
+					return reader.read().then((read) => {
+						if (read.done) {
+							controller.close();
+							return;
+						}
+						bytesReceived += read.value.length;
+						onProgress?.({
+							bytesReceived,
+							status: "downloading"
+						});
+						controller.enqueue(read.value);
+						return pump();
+					});
+				}
+				return pump();
+			} });
+			response = new Response(stream);
+		} catch {}
+		const blob = await response.blob();
+		onProgress?.({
+			bytesReceived,
+			status: "downloaded"
+		});
+		await downloadBlob(blob, fileName);
+		onProgress?.({
+			bytesReceived,
+			status: "completed"
+		});
+	} catch (err) {
+		if (signal?.aborted) onProgress?.({ status: "cancelled" });
+		else onProgress?.({
+			error: err.message,
+			status: "error"
+		});
+	}
 }
 
-// src/Namespace.ts
-function Namespace() {
+//#endregion
+//#region src/parseFunc.ts
+const funcRegex = /^function(?:\s+([a-zA-Z$_][a-zA-Z0-9$_]*))?\s*\(((?:(?:\s*[a-zA-Z$_][a-zA-Z0-9$_]*)(?:\s*,\s*[a-zA-Z$_][a-zA-Z0-9$_]*)*)?)\s*\)\s*\{((?:.|\n|\r)*)\}$/;
+const arrowBlockRegex = /^(?:\(([^)]*)\)|([a-zA-Z$_][a-zA-Z0-9$_]*))\s*=>\s*\{([\s\S]*)\}$/;
+const arrowExpressionRegex = /^(?:\(([^)]*)\)|([a-zA-Z$_][a-zA-Z0-9$_]*))\s*=>\s*([\s\S]+)$/;
+const parseArguments = (args) => args.split(",").map((a) => a.trim()).filter(Boolean);
+function parseFunc(func) {
+	const funcString = func.toString();
+	const arrowBlockMatch = funcString.match(arrowBlockRegex);
+	if (arrowBlockMatch) {
+		const args = parseArguments(arrowBlockMatch[1] ?? arrowBlockMatch[2] ?? "");
+		return {
+			name: func.name,
+			args,
+			body: arrowBlockMatch[3]
+		};
+	}
+	const arrowExpressionMatch = funcString.match(arrowExpressionRegex);
+	if (arrowExpressionMatch) {
+		const args = parseArguments(arrowExpressionMatch[1] ?? arrowExpressionMatch[2] ?? "");
+		return {
+			name: func.name,
+			args,
+			body: arrowExpressionMatch[3]
+		};
+	}
+	const match = funcString.match(funcRegex);
+	invariant(match, "Unable to parse function!");
+	return {
+		name: func.name ?? match[1],
+		args: parseArguments(match[2]),
+		body: match[3]
+	};
 }
-Namespace.prototype = /* @__PURE__ */ Object.create(null);
-var Namespace_default = Namespace;
 
-// src/requireNamespace.ts
+//#endregion
+//#region src/Namespace.ts
+function Namespace() {}
+Namespace.prototype = Object.create(null);
+
+//#endregion
+//#region src/requireNamespace.ts
 function requireNamespace(root, namespace) {
-  if (typeof root === "object") {
-    if (typeof namespace === "string") {
-      let path = namespace.split(".");
-      return requireNamespace(root, path);
-    } else if (Array.isArray(namespace)) {
-      let current = root;
-      for (let i = 0; i < namespace.length; i++) {
-        current = current[namespace[i]] = current[namespace[i]] || new Namespace_default();
-      }
-      return current;
-    }
-  }
-}
-
-// src/expose.ts
+	if (typeof root === "object") {
+		if (typeof namespace === "string") return requireNamespace(root, namespace.split("."));
+		else if (Array.isArray(namespace)) {
+			let current = root;
+			for (let i = 0; i < namespace.length; i++) current = current[namespace[i]] = current[namespace[i]] || new Namespace();
+			return current;
+		}
+	}
+}
+
+//#endregion
+//#region src/expose.ts
+/**
+* Expose a value to a potentially deeply nested global variable
+* @param name {string | object} Either a dot-separated path to the global variable, or an object to expose the value on
+* @param value {object | Function | Function[]} The value(s) to expose
+*/
 function expose(name, value, options = {}) {
-  if (Array.isArray(value)) {
-    for (let func of value) {
-      const { name: funcName } = parseFunc(func);
-      invariant(
-        funcName,
-        "Unable to detect name of function! Name it, or only supply one function and include name in first parameter."
-      );
-      expose(name, func);
-    }
-  } else {
-    let keyName;
-    let namespace;
-    if (typeof value === "function") {
-      keyName = parseFunc(value).name;
-    }
-    if (typeof name === "string") {
-      let pathParts = name.split(".");
-      if (!keyName) {
-        keyName = pathParts[pathParts.length - 1];
-        pathParts = pathParts.slice(0, pathParts.length - 1);
-      }
-      namespace = requireNamespace(window, pathParts);
-    } else if (keyName && (typeof name === "object" || typeof name === "function")) {
-      namespace = name;
-    } else {
-      invariant(false, "Invalid typeof parameter 'name', or unable to parse pValue!");
-    }
-    if (Object.hasOwn(namespace, keyName) && options?.overwrite !== true) {
-      console.warn(`${[name, keyName].join(".")} is already defined!`);
-    } else {
-      namespace[keyName] = value;
-    }
-  }
-}
-
-// src/getLocalizedString.ts
+	if (Array.isArray(value)) for (let func of value) {
+		const { name: funcName } = parseFunc(func);
+		invariant(funcName, "Unable to detect name of function! Name it, or only supply one function and include name in first parameter.");
+		expose(name, func);
+	}
+	else {
+		let keyName;
+		let namespace;
+		if (typeof value === "function") keyName = parseFunc(value).name;
+		if (typeof name === "string") {
+			let pathParts = name.split(".");
+			if (!keyName) {
+				keyName = pathParts[pathParts.length - 1];
+				pathParts = pathParts.slice(0, pathParts.length - 1);
+			}
+			namespace = requireNamespace(window, pathParts);
+		} else if (keyName && (typeof name === "object" || typeof name === "function")) namespace = name;
+		else invariant(false, "Invalid typeof parameter 'name', or unable to parse pValue!");
+		if (Object.hasOwn(namespace, keyName) && options?.overwrite !== true) console.warn(`${[name, keyName].join(".")} is already defined!`);
+		else namespace[keyName] = value;
+	}
+}
+
+//#endregion
+//#region src/getLocalizedString.ts
 async function fetchLocalizedString(text) {
-  try {
-    let response = await fetch(`/api/user/localize/new/${af.article.id}`, {
-      body: JSON.stringify({ text }),
-      headers: {
-        Accept: "application/json; */*",
-        "Content-Type": "application/json",
-        "X-Requested-With": "XMLHttpRequest"
-      },
-      method: "POST"
-    });
-    if (response.ok) {
-      return await response.json();
-    }
-  } catch {
-  }
-  return text;
+	try {
+		let response = await fetch(`/api/user/localize/new/${af.article.id}`, {
+			body: JSON.stringify({ text }),
+			headers: {
+				Accept: "application/json; */*",
+				"Content-Type": "application/json",
+				"X-Requested-With": "XMLHttpRequest"
+			},
+			method: "POST"
+		});
+		if (response.ok) return await response.json();
+	} catch {}
+	return text;
 }
 function getLocalizedString(string, wait) {
-  if (typeof string === "string" && string.trim().length === 0) {
-    return string;
-  }
-  if (string === void 0 || string === "" || string === null) {
-    return;
-  }
-  if (window.af?.article?.i18n !== void 0) {
-    if (!Object.hasOwn(af.article.i18n, string)) {
-      af.article.i18n[string] = string;
-      let promise = fetchLocalizedString(string).then((text) => {
-        af.article.i18n[string] = text;
-        return text;
-      });
-      if (wait) {
-        return promise;
-      }
-    }
-    return af.article.i18n[string];
-  } else {
-    return string;
-  }
-}
-
-// src/getUserImage.ts
-var sizeMap = {
-  xs: 64,
-  sm: 128,
-  md: 256,
-  lg: 512,
-  xl: void 0
+	if (typeof string === "string" && string.trim().length === 0) return string;
+	if (string === void 0 || string === "" || string === null) return;
+	if (window.af?.article?.i18n !== void 0) {
+		if (!Object.hasOwn(af.article.i18n, string)) {
+			af.article.i18n[string] = string;
+			let promise = fetchLocalizedString(string).then((text) => {
+				af.article.i18n[string] = text;
+				return text;
+			});
+			if (wait) return promise;
+		}
+		return af.article.i18n[string];
+	} else return string;
+}
+
+//#endregion
+//#region src/filter/operators.ts
+/**
+* Operators that take no value at all.
+*
+* `eOperators.ParameterLessChecks` plus the blank checks.
+*/
+const PARAMETERLESS_OPERATORS = [
+	"isnull",
+	"isnotnull",
+	"istrue",
+	"isfalse",
+	"isblank",
+	"isnotblank"
+];
+/** Operators whose value is a two element `[from, to]` array. */
+const PAIR_OPERATORS = [
+	"between",
+	"notbetween",
+	"datebetween",
+	"datenotbetween"
+];
+/** Operators whose value is an array of values. */
+const LIST_OPERATORS = ["inlist", "notinlist"];
+function getOperatorArity(operator) {
+	if (PARAMETERLESS_OPERATORS.includes(operator)) return "none";
+	if (PAIR_OPERATORS.includes(operator)) return "pair";
+	if (LIST_OPERATORS.includes(operator)) return "list";
+	return "single";
+}
+/**
+* Operator labels, keyed by operator. Comparison operators have a different
+* label for dates than for numbers, matching the Windows filter editor.
+*
+* @see `appframe/Appframe3.Win/Controls/afFilterEditor/Utils/FilterLineControlUtils.vb`
+*/
+const OPERATOR_LABELS = {
+	equals: "Equal to",
+	notequals: "Not equal to",
+	greaterthan: "Greater than",
+	greaterthanorequal: "Greater than or equal to",
+	lessthan: "Less than",
+	lessthanorequal: "Less than or equal to",
+	beginswith: "Begins with",
+	notbeginswith: "Does not begin with",
+	endswith: "Ends with",
+	notendswith: "Does not end with",
+	contains: "Contains",
+	notcontains: "Does not contain",
+	like: "Like",
+	notlike: "Not like",
+	isnull: "Is null",
+	isnotnull: "Is not null",
+	isblank: "Is empty",
+	isnotblank: "Is not empty",
+	istrue: "Is true",
+	isfalse: "Is false",
+	inlist: "In list",
+	notinlist: "Not in list",
+	between: "Between",
+	notbetween: "Not between",
+	dateequals: "Equal to",
+	notdatequals: "Not equal to",
+	dategreaterthan: "After",
+	dategreaterthanorequal: "On or after",
+	datelessthan: "Before",
+	datelessthanorequal: "Up to",
+	datebetween: "Between",
+	datenotbetween: "Not between"
+};
+/** Comparison operator labels used for date and time fields. */
+const DATE_OPERATOR_LABELS = {
+	greaterthan: "After",
+	greaterthanorequal: "On or after",
+	lessthan: "Before",
+	lessthanorequal: "Up to"
+};
+/**
+* Returns the localized label for an operator. Date fields get the
+* "After"/"Before" wording instead of "Greater than"/"Less than".
+*/
+function getOperatorLabel(operator, fieldType) {
+	let label = (fieldType === "date" || fieldType === "datetime" ? DATE_OPERATOR_LABELS[operator] : void 0) ?? OPERATOR_LABELS[operator];
+	return getLocalizedString(label ?? operator);
+}
+const EQUALITY = ["equals", "notequals"];
+const LIST_CHECKS = ["inlist", "notinlist"];
+const RANGE = ["between", "notbetween"];
+const COMPARISONS = [
+	"greaterthan",
+	"greaterthanorequal",
+	"lessthan",
+	"lessthanorequal"
+];
+const STRING_CHECKS = [
+	"contains",
+	"notcontains",
+	"beginswith",
+	"notbeginswith",
+	"endswith",
+	"notendswith",
+	"isblank",
+	"isnotblank"
+];
+/**
+* Operators offered per field type, in the order the Windows filter editor
+* presents them.
+*/
+const OPERATORS_BY_TYPE = {
+	date: [
+		...EQUALITY,
+		...LIST_CHECKS,
+		...RANGE,
+		...COMPARISONS
+	],
+	datetime: [
+		...EQUALITY,
+		...LIST_CHECKS,
+		...RANGE,
+		...COMPARISONS
+	],
+	number: [
+		...EQUALITY,
+		...LIST_CHECKS,
+		...RANGE,
+		...COMPARISONS
+	],
+	boolean: ["istrue", "isfalse"],
+	string: [
+		...EQUALITY,
+		...STRING_CHECKS,
+		...LIST_CHECKS,
+		...RANGE,
+		...COMPARISONS
+	],
+	uniqueidentifier: [
+		...EQUALITY,
+		...STRING_CHECKS,
+		...LIST_CHECKS,
+		...RANGE,
+		...COMPARISONS
+	]
+};
+/** Default operator per field type. */
+const DEFAULT_OPERATOR_BY_TYPE = {
+	date: "equals",
+	datetime: "equals",
+	number: "equals",
+	boolean: "istrue",
+	string: "beginswith",
+	uniqueidentifier: "beginswith"
+};
+/**
+* Returns the operators available for a field. Nullable fields additionally get
+* the null checks. Boolean fields never get null checks, since `istrue` and
+* `isfalse` already cover the parameterless cases.
+*/
+function getOperatorsForField(field) {
+	let operators = [...OPERATORS_BY_TYPE[field.type] ?? OPERATORS_BY_TYPE.string];
+	if (field.nullable && field.type !== "boolean") operators.push("isnull", "isnotnull");
+	return operators;
+}
+function getDefaultOperator(field) {
+	return DEFAULT_OPERATOR_BY_TYPE[field.type] ?? "equals";
+}
+/**
+* The `valueType` to send for a field/operator combination.
+*
+* Parameterless operators send `"null"`, list and range operators send
+* `"array"`, everything else sends the field's own value type.
+*/
+function getValueType(field, operator) {
+	if (getOperatorArity(operator) === "none") return "null";
+	switch (field.type) {
+		case "number": return "number";
+		case "boolean": return "boolean";
+		case "date":
+		case "datetime": return "datetime";
+		case "uniqueidentifier": return "uniqueidentifier";
+		default: return "string";
+	}
+}
+/** Relative date values offered in the date value editor, in menu order. */
+const RELATIVE_DATE_VALUES = [
+	"Yesterday",
+	"Today",
+	"Tomorrow",
+	"ThisWeek",
+	"ThisMonth",
+	"ThisYear",
+	"LastWeek",
+	"LastMonth",
+	"LastYear",
+	"NextWeek",
+	"NextMonth",
+	"NextYear"
+];
+const DYNAMIC_VALUE_LABELS = {
+	CurrentUser: "Current user",
+	Yesterday: "Yesterday",
+	Today: "Today",
+	Tomorrow: "Tomorrow",
+	ThisWeek: "This week",
+	ThisMonth: "This month",
+	ThisYear: "This year",
+	LastWeek: "Last week",
+	LastMonth: "Last month",
+	LastYear: "Last year",
+	NextWeek: "Next week",
+	NextMonth: "Next month",
+	NextYear: "Next year",
+	UserYesterday: "Yesterday",
+	UserToday: "Today",
+	UserTomorrow: "Tomorrow",
+	UserThisWeek: "This week",
+	UserThisMonth: "This month",
+	UserThisYear: "This year",
+	UserLastWeek: "Last week",
+	UserLastMonth: "Last month",
+	UserLastYear: "Last year",
+	UserNextWeek: "Next week",
+	UserNextMonth: "Next month",
+	UserNextYear: "Next year"
+};
+function getDynamicValueLabel(value) {
+	return getLocalizedString(DYNAMIC_VALUE_LABELS[value] ?? value);
+}
+/**
+* Returns the dynamic ("special") values that can be used with a field. Date
+* fields get the relative dates; string fields can be compared to the current
+* user name.
+*/
+function getDynamicValuesForField(field) {
+	if (field.type === "date" || field.type === "datetime") return [...RELATIVE_DATE_VALUES];
+	if (field.type === "string") return ["CurrentUser"];
+	return [];
+}
+/**
+* Aliases for names `eOperators.ToString()` can produce that are not operators
+* in their own right. `Not` is the bare negation flag (i.e. "not equal to"),
+* `Tweens` shares its numeric value with `NotBetween`, and combined flags are
+* rendered as a comma separated list.
+*
+* @see `FilterElementConverter.FilterExpressionToDictionary`
+*/
+const OPERATOR_ALIASES = {
+	not: "notequals",
+	tweens: "notbetween",
+	notdate: "notdatequals",
+	notdateequals: "notdatequals"
+};
+/**
+* Normalizes an operator string coming from the server or from another filter
+* producer (`AfGrid` emits PascalCase names) to the canonical lower-case form.
+*/
+function normalizeOperator(operator) {
+	let normalized = operator.toLowerCase().replace(/[\s,]/g, "");
+	return OPERATOR_ALIASES[normalized] ?? normalized;
+}
+
+//#endregion
+//#region src/filter/tree.ts
+/**
+* Creates the default empty filter: a single `and` group with no conditions.
+*/
+function createEmptyFilter() {
+	return createEmptyGroup("and");
+}
+function createEmptyGroup(mode = "and") {
+	return {
+		type: "group",
+		mode,
+		items: []
+	};
+}
+function isGroup(item) {
+	return item.type === "group";
+}
+function isExpression(item) {
+	return item.type === "expression";
+}
+/**
+* Normalizes any filter value into a tree the editor can render, without
+* changing its structure. An expression is wrapped in a group; a missing filter
+* becomes the default layout.
+*/
+function toFilterTree(filter) {
+	if (!filter) return createEmptyFilter();
+	if (isExpression(filter)) return {
+		type: "group",
+		mode: "and",
+		items: [filter]
+	};
+	return filter;
+}
+/**
+* True when the filter contains no expressions. An empty filter must not be
+* saved or applied.
+*/
+function isEmptyFilter(filter) {
+	return countExpressions(filter) === 0;
+}
+function countExpressions(filter) {
+	if (!filter) return 0;
+	if (isExpression(filter)) return 1;
+	return filter.items.reduce((total, item) => total + countExpressions(item), 0);
+}
+/**
+* Removes incomplete expressions and empty groups from the whole tree. Returns
+* null when nothing is left. Use before applying a filter to a data object so
+* incomplete rows are not sent.
+*/
+function pruneFilter(filter) {
+	if (!filter) return null;
+	if (isExpression(filter)) return isCompleteExpression(filter) ? {
+		type: "group",
+		mode: "and",
+		items: [filter]
+	} : null;
+	let items = filter.items.map((item) => isGroup(item) ? pruneFilter(item) : isCompleteExpression(item) ? item : null).filter((item) => item !== null);
+	if (items.length === 0) return null;
+	return {
+		...filter,
+		items
+	};
+}
+/**
+* True when an expression has everything it needs to be sent to the server.
+*/
+function isCompleteExpression(item) {
+	if (isGroup(item)) return item.items.some(isCompleteExpression);
+	if (!item.column || !item.operator) return false;
+	let arity = getOperatorArity(normalizeOperator(item.operator));
+	if (arity === "none") return true;
+	if (item.value === null || item.value === void 0 || item.value === "") return false;
+	if (arity === "pair") return Array.isArray(item.value) && item.value.length === 2 && item.value.every((v) => v !== "" && v != null);
+	if (arity === "list") return Array.isArray(item.value) && item.value.length > 0;
+	return true;
+}
+/**
+* Creates an expression for a field, using the field's default operator and an
+* empty value of the right shape.
+*/
+function createExpression(field, operator) {
+	let op = operator ?? getDefaultOperator(field);
+	return {
+		type: "expression",
+		column: field.name,
+		operator: op,
+		value: createEmptyValue(op),
+		valueType: getValueType(field, op)
+	};
+}
+function createEmptyValue(operator) {
+	switch (getOperatorArity(operator)) {
+		case "none": return null;
+		case "pair": return ["", ""];
+		case "list": return [];
+		default: return "";
+	}
+}
+/**
+* Returns a copy of the expression with a new operator, adjusting the value to
+* the new operator's arity and the value type accordingly.
+*/
+function changeOperator(expression, operator, field) {
+	let previousArity = getOperatorArity(normalizeOperator(expression.operator));
+	let arity = getOperatorArity(operator);
+	let value = expression.value;
+	if (arity !== previousArity) value = createEmptyValue(operator);
+	let valueType = expression.valueType === "special" && arity === previousArity ? "special" : getValueType(field, operator);
+	return {
+		...expression,
+		operator,
+		value,
+		valueType
+	};
+}
+/** Returns the node at `path`, or null when the path does not exist. */
+function getNodeAtPath(filter, path) {
+	let node = filter;
+	for (let index of path) {
+		if (!node || !isGroup(node)) return null;
+		node = node.items[index];
+	}
+	return node ?? null;
+}
+/**
+* Returns a copy of the tree with `updater` applied to the node at `path`.
+* Returning null removes the node. An unknown path leaves the tree untouched.
+*/
+function updateNodeAtPath(filter, path, updater) {
+	if (path.length === 0) return updater(filter) ?? filter;
+	if (!isGroup(filter)) return filter;
+	let [index, ...rest] = path;
+	let child = filter.items[index];
+	if (!child) return filter;
+	let items = [...filter.items];
+	if (rest.length === 0) {
+		let updated = updater(child);
+		if (updated === null) items.splice(index, 1);
+		else items[index] = updated;
+	} else items[index] = updateNodeAtPath(child, rest, updater);
+	return {
+		...filter,
+		items
+	};
+}
+/** Returns a copy of the tree with `node` appended to the group at `path`. */
+function insertNodeAtPath(filter, path, node) {
+	return updateNodeAtPath(filter, path, (target) => isGroup(target) ? {
+		...target,
+		items: [...target.items, node]
+	} : target);
+}
+/**
+* Returns a copy of the tree with the node at `path` removed. The root is never
+* removed; it is reset to the default layout instead.
+*/
+function removeNodeAtPath(filter, path) {
+	if (path.length === 0) return createEmptyFilter();
+	return updateNodeAtPath(filter, path, () => null);
+}
+/** Returns a copy of the tree with the mode of the group at `path` changed. */
+function setGroupMode(filter, path, mode) {
+	return updateNodeAtPath(filter, path, (node) => isGroup(node) ? {
+		...node,
+		mode
+	} : node);
+}
+/** Returns a copy of the tree with an empty group appended to the group at `path`. */
+function addGroupAtPath(filter, path = []) {
+	let parent = getNodeAtPath(filter, path);
+	return insertNodeAtPath(filter, path, createEmptyGroup(parent && isGroup(parent) && parent.mode === "and" ? "or" : "and"));
+}
+
+//#endregion
+//#region src/filter/convertFilter.ts
+const CONVERT_URL = "/api/filter/convert";
+/**
+* Converts between a structured filter and a DevExpress filter string.
+*
+* The conversion is done server-side by `api/filter/convert`, because the
+* criteria string grammar is implemented by the licensed DevExpress parser that
+* the Windows client and the report engine use. Doing it in the browser would
+* risk producing strings the server cannot parse back.
+*/
+async function convertFilter(request, signal) {
+	let response = await fetch(CONVERT_URL, {
+		method: "POST",
+		headers: { "Content-Type": "application/json" },
+		body: JSON.stringify(request),
+		signal
+	});
+	if (!response.ok) throw new Error(`Failed to convert filter: ${response.status} ${response.statusText}`);
+	let result = await response.json();
+	return {
+		...result,
+		filterObject: result.filterObject ? toFilterTree(result.filterObject) : null
+	};
+}
+
+//#endregion
+//#region src/filter/describeFilter.ts
+/**
+* Builds a human-readable description of a filter, without contacting the
+* server. Use this for read-only summaries; the authoritative filter string is
+* produced by `api/filter/convert`, since only the server can generate the
+* DevExpress criteria syntax.
+*/
+function describeFilter(filter, options = {}) {
+	if (!filter) return "";
+	return describe(filter, new Map((options.fields ?? []).map((field) => [field.name.toLowerCase(), field])), 0);
+}
+function describe(item, fields, depth) {
+	if (isExpression(item)) return describeExpression(item, fields);
+	let parts = item.items.map((child) => describe(child, fields, depth + 1)).filter((part) => part !== "");
+	if (parts.length === 0) return "";
+	if (parts.length === 1) return parts[0];
+	let separator = item.mode === "or" ? " OR " : " AND ";
+	let joined = parts.join(separator);
+	return depth === 0 ? joined : `(${joined})`;
+}
+function describeExpression(expression, fields) {
+	if (!expression.column || !expression.operator) return "";
+	let field = fields.get(expression.column.toLowerCase());
+	let caption = field?.caption ?? expression.column;
+	let operator = normalizeOperator(expression.operator);
+	let label = getOperatorLabel(operator, field?.type);
+	let arity = getOperatorArity(operator);
+	if (arity === "none") return `[${caption}] ${label}`;
+	return `[${caption}] ${label} ${formatValue(expression, arity)}`;
+}
+function formatValue(expression, arity) {
+	let { value, valueType } = expression;
+	if (valueType === "special" && typeof value === "string") return getDynamicValueLabel(value);
+	if (Array.isArray(value)) {
+		let formatted = value.map((item) => formatScalar(item, valueType));
+		return arity === "pair" ? formatted.join(" - ") : `(${formatted.join(", ")})`;
+	}
+	return formatScalar(value, valueType);
+}
+function formatScalar(value, valueType) {
+	if (value === null || value === void 0) return "";
+	if (value instanceof Date) return value.toISOString().slice(0, 10);
+	if (typeof value === "number" || typeof value === "boolean") return String(value);
+	if (valueType === "number" || valueType === "boolean") return String(value);
+	return `'${String(value)}'`;
+}
+
+//#endregion
+//#region src/filter/fields.ts
+const FIELD_TYPES = [
+	"string",
+	"number",
+	"boolean",
+	"date",
+	"datetime",
+	"uniqueidentifier"
+];
+/** The builder type for a normalized `DataType`. Unknown types are filtered as text. */
+function toFilterFieldType(dataType) {
+	let normalized = dataType?.trim().toLowerCase();
+	return FIELD_TYPES.find((type) => type === normalized) ?? "string";
+}
+function toBoolean$1(value) {
+	return value === true || value === 1;
+}
+/** Maps a view field record onto the metadata the builder renders. */
+function toFieldMetadata(record) {
+	return {
+		name: record.FieldName ?? "",
+		type: toFilterFieldType(record.DataType),
+		nullable: toBoolean$1(record.Nullable),
+		excludeFromFilter: toBoolean$1(record.ExcludeFromFilter),
+		valueListRecordSource: record.ValueListRecordSource || void 0
+	};
+}
+/**
+* Maps and sorts view field records. Fields the view marks as excluded are
+* dropped rather than hidden, since nothing else can use them.
+*/
+function toFieldMetadataList(records) {
+	return records.map(toFieldMetadata).filter((field) => field.name !== "" && !field.excludeFromFilter).sort((a, b) => a.name.localeCompare(b.name));
+}
+
+//#endregion
+//#region src/filter/standardLayout.ts
+/**
+* The "standard layout" is the simplified shape the Windows filter editor can
+* render in its flow view: an outer `or` group whose items are `and` groups of
+* expressions. Anything else falls back to the advanced (DevExpress) editor
+* there, and to the nested tree editor on the web.
+*
+* @see `afFilterEditor.CanRenderFilter`
+*/
+function isStandardLayout(filter) {
+	if (!filter || isExpression(filter) || filter.mode !== "or") return false;
+	return filter.items.every((item) => isGroup(item) && item.mode === "and" && item.items.every(isExpression));
+}
+/**
+* Coerces an arbitrary filter tree into the standard layout.
+*
+* An `or` group's items each become their own `and` group. Anything else is
+* flattened into a single `and` group. This loses nesting, so only use it when
+* the consumer cannot handle a nested tree.
+*/
+function coerceToStandardLayout(filter) {
+	if (!filter) return {
+		type: "group",
+		mode: "or",
+		items: [{
+			type: "group",
+			mode: "and",
+			items: []
+		}]
+	};
+	if (isExpression(filter)) return {
+		type: "group",
+		mode: "or",
+		items: [{
+			type: "group",
+			mode: "and",
+			items: [filter]
+		}]
+	};
+	if (filter.mode === "or") {
+		let groups = filter.items.map((item) => {
+			let expressions = [];
+			collectExpressions(item, expressions);
+			return {
+				type: "group",
+				mode: "and",
+				items: expressions
+			};
+		});
+		return {
+			type: "group",
+			mode: "or",
+			items: groups.length > 0 ? groups : [{
+				type: "group",
+				mode: "and",
+				items: []
+			}]
+		};
+	}
+	let expressions = [];
+	collectExpressions(filter, expressions);
+	return {
+		type: "group",
+		mode: "or",
+		items: [{
+			type: "group",
+			mode: "and",
+			items: expressions
+		}]
+	};
+}
+/**
+* Collects every expression in a (possibly nested) filter, in document order.
+*/
+function collectExpressions(item, into) {
+	if (isExpression(item)) {
+		into.push(item);
+		return;
+	}
+	for (let child of item.items) collectExpressions(child, into);
+}
+
+//#endregion
+//#region src/filter/savedFilters.ts
+/**
+* `sviw_Database_MyFilters` unions in a synthetic "No Filter" row so the Windows
+* tree can render a "no filter" entry. It is not a real filter and must be
+* dropped before the list is shown.
+*/
+const NO_FILTER_ID = -1;
+/**
+* Maps a database record onto a `SavedFilter`.
+*
+* `CreatedByUser` needs care: the view computes it as the *string* `'true'` or
+* `'false'` (and `'False'` on the synthetic row), not as a bit.
+*/
+function toSavedFilter(record) {
+	return {
+		filterId: record.FilterID ?? -1,
+		primKey: record.PrimKey ?? "",
+		name: record.FilterName ?? "",
+		criteria: record.FilterCriteria ?? "",
+		dbObjectId: record.DBObjectID ?? "",
+		accessLevel: toAccessLevel(record.AccessLevel),
+		createdByUser: toBoolean(record.CreatedByUser),
+		createdBy: record.CreatedBy ?? "",
+		domain: record.Domain ?? null,
+		crossDomain: toBoolean(record.CrossDomain),
+		isPersonallyShared: toBoolean(record.IsPersonallyShared),
+		hideCriteria: toBoolean(record.HideFilterCriteria),
+		headerText: record.OptionalHeaderText || null,
+		comment: record.OptionalComment || null,
+		parameters: record.Parameters || null,
+		reportTitle: record.ReportTitle || null,
+		created: toDate(record.Created),
+		updated: toDate(record.Updated)
+	};
+}
+function toAccessLevel(value) {
+	if (value === "Manager" || value === "Editor") return value;
+	return "Reader";
+}
+function toBoolean(value) {
+	if (typeof value === "string") return value.toLowerCase() === "true";
+	return Boolean(value);
+}
+function toDate(value) {
+	if (!value) return null;
+	if (value instanceof Date) return value;
+	let date = new Date(value);
+	return Number.isNaN(date.getTime()) ? null : date;
+}
+/** Drops the synthetic "No Filter" row and sorts by name. */
+function toSavedFilters(records) {
+	return records.filter((record) => (record.FilterID ?? -1) !== -1).map(toSavedFilter).sort((a, b) => a.name.localeCompare(b.name));
+}
+/**
+* Splits filters into the two branches the Windows tree shows: the ones the user
+* created, and the ones that have been shared with them.
+*/
+function partitionSavedFilters(filters) {
+	let mine = [];
+	let shared = [];
+	for (let filter of filters) if (filter.createdByUser) mine.push(filter);
+	else shared.push(filter);
+	return {
+		mine,
+		shared
+	};
+}
+function findSavedFilter(filters, filterId) {
+	if (filterId == null) return void 0;
+	return filters.find((filter) => filter.filterId === filterId);
+}
+/** True when the user may overwrite the filter's criteria. */
+function canEditSavedFilter(filter) {
+	return filter.accessLevel === "Editor" || filter.accessLevel === "Manager";
+}
+/** True when the user may change who the filter is shared with. */
+function canShareSavedFilter(filter) {
+	return filter.accessLevel === "Manager";
+}
+/**
+* True when the user may rename or delete the filter.
+*
+* `sstp_WebSiteCMS_FilterBuilder_RenameFilter` and `…_DeleteFilter` both require
+* `CreatedBy = SUSER_SNAME()` — the manager-access branch is commented out in
+* both procedures, deliberately, because the UI only ever offers these for a
+* user's own filters.
+*/
+function canRenameSavedFilter(filter) {
+	return filter.createdByUser;
+}
+const canDeleteSavedFilter = canRenameSavedFilter;
+/**
+* True when the user may toggle the cross-domain flag.
+*
+* `sstp_Database_Filters_SetCrossDomain` also filters on
+* `CreatedBy = SUSER_SNAME()`.
+*/
+const canSetCrossDomain = canRenameSavedFilter;
+
+//#endregion
+//#region src/getUserImage.ts
+const sizeMap = {
+	xs: 64,
+	sm: 128,
+	md: 256,
+	lg: 512,
+	xl: void 0
 };
 function getUserImage(primKeyOrOptions, login, hash, size = "xs") {
-  if (primKeyOrOptions && typeof primKeyOrOptions === "object") {
-    return getUserImage(primKeyOrOptions.primKey, primKeyOrOptions.login, primKeyOrOptions.hash, primKeyOrOptions.size);
-  }
-  if (!primKeyOrOptions || !hash) {
-    return "";
-  }
-  let sizePx = sizeMap[size];
-  return `/api/data/blob/EmployeesLookup/${primKeyOrOptions}/Image/${encodeURIComponent(login ?? "")}${login ? "." : ""}${encodeURIComponent(hash)}.jpg${sizePx ? `?width=${sizePx}` : ""}`;
+	if (primKeyOrOptions && typeof primKeyOrOptions === "object") return getUserImage(primKeyOrOptions.primKey, primKeyOrOptions.login, primKeyOrOptions.hash, primKeyOrOptions.size);
+	if (!primKeyOrOptions || !hash) return "";
+	let sizePx = sizeMap[size];
+	return `/api/data/blob/EmployeesLookup/${primKeyOrOptions}/Image/${encodeURIComponent(login ?? "")}${login ? "." : ""}${encodeURIComponent(hash)}.jpg${sizePx ? `?width=${sizePx}` : ""}`;
 }
 
-// src/localize.ts
+//#endregion
+//#region src/localize.ts
+/**
+* Localization function for tagged templates. Replaces the arguments
+* with $n, where n is the index, before asking Appframe to translate
+* the string.
+*
+* For example, if you call localize`Page ${2} or ${5}`, the string
+* "Page $0 of $1" will be sent to Appframe, and for norwegian,
+* "Side 2 av 5" will be returned.
+*
+* @param stringParts
+* @param args
+* @returns Translated string
+*/
 function localize(stringParts, ...args) {
-  invariant(
-    Array.isArray(stringParts) && stringParts.length === args.length + 1,
-    "Method 'localize' must be used as a tag function"
-  );
-  let stringToLocalize = stringParts.map((s, i) => i === stringParts.length - 1 ? s : `${s}$${i}`).join("");
-  let localized = getLocalizedString(stringToLocalize);
-  args.forEach((arg, index) => {
-    localized = localized.replace(`$${index}`, arg);
-  });
-  return localized;
-}
-
-// src/alert.ts
-var template = `
+	invariant(Array.isArray(stringParts) && stringParts.length === args.length + 1, "Method 'localize' must be used as a tag function");
+	let stringToLocalize = stringParts.map((s, i) => i === stringParts.length - 1 ? s : `${s}$${i}`).join("");
+	let localized = getLocalizedString(stringToLocalize);
+	args.forEach((arg, index) => {
+		localized = localized.replace(`$${index}`, arg);
+	});
+	return localized;
+}
+
+//#endregion
+//#region src/report/recordSource.ts
+const XML_ENTITIES = {
+	amp: "&",
+	lt: "<",
+	gt: ">",
+	quot: "\"",
+	apos: "'"
+};
+/** Resolves the XML entities the .NET serializer emits. */
+function decodeXml(value) {
+	return value.replace(/&(#x?[0-9a-f]+|[a-z]+);/gi, (match, entity) => {
+		if (entity.startsWith("#x") || entity.startsWith("#X")) return String.fromCodePoint(Number.parseInt(entity.slice(2), 16));
+		if (entity.startsWith("#")) return String.fromCodePoint(Number.parseInt(entity.slice(1), 10));
+		return XML_ENTITIES[entity.toLowerCase()] ?? match;
+	});
+}
+/** Escapes a value for use as XML text or as an attribute value. */
+function encodeXml(value) {
+	return value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&apos;");
+}
+/**
+* The text content of the first `<name>` element, or `null` when the element is
+* missing or self-closing (`<FilterString />`, which the serializer writes for
+* an empty value).
+*/
+function readElement(xml, name) {
+	let match = new RegExp(`<${name}(?:\\s[^>]*)?>([\\s\\S]*?)</${name}>`).exec(xml);
+	if (!match) return null;
+	let value = decodeXml(match[1]).trim();
+	return value === "" ? null : value;
+}
+/** The text content of every `<name>` element, in document order. */
+function readElements(xml, name) {
+	return [...xml.matchAll(new RegExp(`<${name}(?:\\s[^>]*)?>([\\s\\S]*?)</${name}>`, "g"))].map((match) => decodeXml(match[1]).trim());
+}
+/**
+* The CLR types the designer writes on a select column. Anything else — and a
+* column with no `DataType` at all, which is what it writes for strings — is
+* treated as text.
+*/
+const COLUMN_TYPES = {
+	Byte: "number",
+	Decimal: "number",
+	Double: "number",
+	Int16: "number",
+	Int32: "number",
+	Int64: "number",
+	Single: "number",
+	Boolean: "boolean",
+	DateTime: "date"
+};
+/** The columns of a `<SelectColumns>` block, in document order. */
+function readSelectColumns(xml) {
+	let block = /<SelectColumns>([\s\S]*?)<\/SelectColumns>/.exec(xml)?.[1] ?? "";
+	let columns = [];
+	for (let match of block.matchAll(/<afSelectColumn>([\s\S]*?)<\/afSelectColumn>/g)) {
+		let name = readElement(match[1], "Name");
+		if (!name) continue;
+		columns.push({
+			name,
+			type: COLUMN_TYPES[readElement(match[1], "DataType") ?? ""] ?? "string"
+		});
+	}
+	return columns;
+}
+/**
+* Reads the parts of an `afRecordSource` a web client can act on: the view, the
+* selected columns and the design-time filter.
+*
+* Returns `null` for anything that is not a record source, so a missing or
+* empty `RecordSource` column simply means "no lookup".
+*/
+function parseRecordSource(xml) {
+	if (!xml || !xml.includes("<afRecordSource")) return null;
+	let viewName = readElement(xml, "ViewName");
+	if (!viewName) return null;
+	let maxRecords = readElement(xml, "MaxRecords");
+	return {
+		viewName,
+		columns: readSelectColumns(xml),
+		whereClause: readElement(xml, "WhereClause"),
+		filterString: readElement(xml, "FilterString"),
+		maxRecords: maxRecords === null || maxRecords === "0" ? null : Number(maxRecords)
+	};
+}
+
+//#endregion
+//#region src/report/parameters.ts
+/**
+* Report parameters: mapping the metadata records onto something renderable,
+* and the XML the parameter values are stored as on a saved filter.
+*/
+const PARAMETER_TYPES = [
+	"String",
+	"Integer",
+	"Double",
+	"Date",
+	"Boolean"
+];
+/**
+* A default value naming a stored procedure, e.g. `astp_Reports_CurrentPeriod`.
+*
+* The Windows launcher executes the procedure and uses the first column of the
+* first row. The web client cannot execute an arbitrary procedure, so these are
+* resolved through the report endpoint instead.
+*/
+const PROCEDURE_DEFAULT = /^[a-z]stp_/i;
+/** True when a `DefaultValue` names a stored procedure rather than a literal. */
+function isProcedureDefault(defaultValue) {
+	return typeof defaultValue === "string" && PROCEDURE_DEFAULT.test(defaultValue.trim());
+}
+/** The choices of a parameter, one per line of its `Items` column. */
+function parseParameterItems(items) {
+	if (!items) return [];
+	return items.split(/\r\n|\r|\n/).map((item) => item.trim()).filter((item) => item !== "");
+}
+function toParameterType(dataType) {
+	return PARAMETER_TYPES.find((type) => type.toLowerCase() === dataType?.trim().toLowerCase()) ?? "String";
+}
+/**
+* The editor a parameter should use. A lookup or a fixed item list wins over the
+* data type, which is what the Windows launcher does as well.
+*/
+function toParameterEditor(type, hasLookup, hasItems) {
+	if (hasLookup) return "lookup";
+	if (hasItems) return "select";
+	switch (type) {
+		case "Integer":
+		case "Double": return "number";
+		case "Date": return "date";
+		case "Boolean": return "boolean";
+		default: return "text";
+	}
+}
+/** Maps a `sviw_WinClient_ReportsParameters` record onto a `ReportParameter`. */
+function toReportParameter(record) {
+	let name = record.Name ?? "";
+	let type = toParameterType(record.DataType);
+	let items = parseParameterItems(record.Items);
+	let recordSource = parseRecordSource(record.RecordSource);
+	let valueMember = record.ValueMember ?? null;
+	if (recordSource && !valueMember) valueMember = recordSource.columns[0]?.name ?? null;
+	let displayMember = recordSource?.columns.find((column) => column.name !== valueMember)?.name ?? null;
+	let hasLookup = Boolean(recordSource && valueMember);
+	return {
+		name,
+		label: record.Label?.trim() || name,
+		description: record.Description?.trim() || null,
+		type,
+		editor: toParameterEditor(type, hasLookup, items.length > 0),
+		defaultValue: record.DefaultValue ?? null,
+		items,
+		recordSource: hasLookup ? recordSource : null,
+		valueMember: hasLookup ? valueMember : null,
+		displayMember: hasLookup ? displayMember : null,
+		sortOrder: record.SortOrder ?? 0,
+		lookupWidth: record.LookupWidth ?? null,
+		lookupHeight: record.LookupHeight ?? null
+	};
+}
+/** Maps and sorts a report's parameter records. */
+function toReportParameters(records) {
+	return records.filter((record) => record.Name).map(toReportParameter).sort((a, b) => a.sortOrder - b.sortOrder || a.label.localeCompare(b.label));
+}
+/** Converts a raw value to the type a parameter expects. */
+function coerceParameterValue(parameter, value) {
+	if (value === null || value === void 0 || value === "") return parameter.type === "Boolean" ? false : null;
+	switch (parameter.type) {
+		case "Boolean": return typeof value === "boolean" ? value : /^(true|1|ja|yes)$/i.test(String(value));
+		case "Integer": {
+			let parsed = Number.parseInt(String(value), 10);
+			return Number.isNaN(parsed) ? null : parsed;
+		}
+		case "Double": {
+			let parsed = Number(String(value).replace(",", "."));
+			return Number.isNaN(parsed) ? null : parsed;
+		}
+		default: return String(value);
+	}
+}
+/**
+* The initial values for a set of parameters.
+*
+* Defaults naming a stored procedure are left unset: they have to be resolved
+* server-side, and the caller fills them in once they are.
+*/
+function getDefaultParameterValues(parameters) {
+	let values = {};
+	for (let parameter of parameters) values[parameter.name] = isProcedureDefault(parameter.defaultValue) ? coerceParameterValue(parameter, null) : coerceParameterValue(parameter, parameter.defaultValue);
+	return values;
+}
+function toXmlValue(parameter, value) {
+	if (value === null || value === void 0) return "";
+	if (typeof value === "boolean") return value ? "True" : "False";
+	return String(value);
+}
+/**
+* Serializes parameter values the way the Windows filter builder does, so that
+* a filter saved on the web is readable in the Windows client and the other way
+* around.
+*
+* ```xml
+* <Parameters Version="1">
+*   <Parameter Name="Period" Type="Integer">202601</Parameter>
+* </Parameters>
+* ```
+*/
+function serializeParameters(parameters, values) {
+	return `<Parameters Version="1">\n${parameters.map((parameter) => {
+		let value = toXmlValue(parameter, values[parameter.name] ?? null);
+		return `  <Parameter Name="${encodeXml(parameter.name)}" Type="${parameter.type}">${encodeXml(value)}</Parameter>`;
+	}).join("\n")}\n</Parameters>`;
+}
+/**
+* Reads the values back out of the XML stored on a saved filter. Values are
+* returned as strings and coerced against the report's own parameters by
+* `restoreParameterValues`, since the XML may name parameters the report no
+* longer has.
+*/
+function parseParameters(xml) {
+	if (!xml) return {};
+	let values = {};
+	for (let match of xml.matchAll(/<Parameter\s+([^>]*?)\/?>(?:([\s\S]*?)<\/Parameter>)?/g)) {
+		let name = /Name\s*=\s*"([^"]*)"/.exec(match[1])?.[1];
+		if (!name) continue;
+		values[name] = readElement(match[0], "Parameter") ?? "";
+	}
+	return values;
+}
+/**
+* Applies the values stored on a saved filter to a report's parameters, keeping
+* the defaults for anything the filter does not mention.
+*/
+function restoreParameterValues(parameters, xml) {
+	let stored = parseParameters(xml);
+	let values = getDefaultParameterValues(parameters);
+	for (let parameter of parameters) if (parameter.name in stored) values[parameter.name] = coerceParameterValue(parameter, stored[parameter.name]);
+	return values;
+}
+
+//#endregion
+//#region src/report/parameterDefaults.ts
+/**
+* Resolving report parameter defaults that name a stored procedure.
+*
+* A `DefaultValue` matching `^[a-z]stp_` names a procedure that produces the
+* default rather than being the default itself. Executing it is a server
+* concern, and the framework already exposes it through the `WebsiteCMS`
+* `api/reporting/filters` route.
+*/
+/**
+* Runs the stored procedure a parameter's default names and returns the value
+* it produces — the first column of the first row, the way the Windows launcher
+* reads it.
+*
+* Returns `null` when the parameter has no procedure default or the procedure
+* produced no rows.
+*/
+async function fetchParameterDefault(reportId, parameter, signal) {
+	if (!parameter.defaultValue || !isProcedureDefault(parameter.defaultValue)) return null;
+	let response = await fetch(`/api/reporting/filters/${encodeURIComponent(reportId)}/GetParameterDefaultValue`, {
+		body: JSON.stringify({ parameterName: parameter.name }),
+		credentials: "same-origin",
+		headers: {
+			"Content-Type": "application/json",
+			"X-Requested-With": "XMLHttpRequest"
+		},
+		method: "POST",
+		signal
+	});
+	if (!response.ok) throw new Error(`${response.status} ${response.statusText}`);
+	return firstValue(await response.json());
+}
+/**
+* Resolves every procedure default of a report in parallel and merges the
+* results over the literal defaults.
+*
+* A parameter whose procedure fails is left at its literal default rather than
+* failing the whole form — the user can still type a value.
+*/
+async function resolveParameterDefaults(reportId, parameters, literalDefaults, signal) {
+	let dynamic = parameters.filter((parameter) => isProcedureDefault(parameter.defaultValue ?? ""));
+	if (dynamic.length === 0) return literalDefaults;
+	let resolved = await Promise.all(dynamic.map(async (parameter) => {
+		try {
+			return [parameter.name, await fetchParameterDefault(reportId, parameter, signal)];
+		} catch {
+			return [parameter.name, null];
+		}
+	}));
+	let values = { ...literalDefaults };
+	for (let [name, value] of resolved) if (value !== null) values[name] = value;
+	return values;
+}
+/** The first column of the first row of whichever result set came back. */
+function firstValue(result) {
+	let row = (Array.isArray(result) ? result : Object.values(result).find((value) => Array.isArray(value)))?.[0];
+	if (row === void 0 || row === null) return null;
+	if (Array.isArray(row)) return row[0] ?? null;
+	if (typeof row === "object") return Object.values(row)[0] ?? null;
+	return row;
+}
+
+//#endregion
+//#region src/report/render.ts
+/**
+* Rendering a report through the framework's report route.
+*
+* The route is a CMS code module owned by the Appframe framework
+* (`WebsiteCMS.Reports`), registered on
+* `api/report/{ReportID}/{FileName}.{Extension}`. Everything here builds
+* requests for it — there is no report endpoint of our own.
+*/
+/**
+* The file extension each format is requested with. The route only accepts
+* `(pdf|csv|xlsx?|html|xbm|mht|rtf|txt)`, which is why `TEXT` is `txt` and
+* `IMAGE` is `xbm` rather than the format name.
+*/
+const REPORT_EXTENSIONS = {
+	CSV: "csv",
+	HTML: "html",
+	IMAGE: "xbm",
+	MHT: "mht",
+	PDF: "pdf",
+	RTF: "rtf",
+	TEXT: "txt",
+	XLS: "xls",
+	XLSX: "xlsx"
+};
+/** The media type each format is served as, for previewing a rendered report. */
+const REPORT_MEDIA_TYPES = {
+	CSV: "text/csv",
+	HTML: "text/html",
+	IMAGE: "image/x-xbitmap",
+	MHT: "message/rfc822",
+	PDF: "application/pdf",
+	RTF: "text/enriched",
+	TEXT: "text/plain",
+	XLS: "application/vnd.ms-excel",
+	XLSX: "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet"
+};
+/** The extension a format is requested with. */
+function getReportExtension(format) {
+	return REPORT_EXTENSIONS[format];
+}
+/** The media type a format is served as. */
+function getReportMediaType(format) {
+	return REPORT_MEDIA_TYPES[format];
+}
+/**
+* Characters that must not reach the file name, because it is a path segment of
+* the route: separators, the extension delimiter, the query and fragment
+* delimiters, and control characters.
+*/
+const UNSAFE_FILE_NAME_CHARACTERS = /[\\/:*?"<>|.#&+%\u0000-\u001f]/g;
+/**
+* The name a rendered report is downloaded as, including its extension.
+*
+* The file name is part of the route rather than a query parameter, so anything
+* that would change the path is replaced.
+*/
+function getReportFileName(options) {
+	let safe = (options.fileName ?? options.reportId).trim().replace(UNSAFE_FILE_NAME_CHARACTERS, "-").replace(/-{2,}/g, "-").replace(/^-|-$/g, "").trim();
+	return `${safe === "" ? options.reportId : safe}.${getReportExtension(options.format)}`;
+}
+/**
+* The route is always on the same origin, but a `Request` needs an absolute
+* URL, so the path is resolved against the document when there is one.
+*/
+function toRequestUrl(path) {
+	let base = window.location?.href;
+	return base ? new URL(path, base).toString() : path;
+}
+/**
+* The request that renders a report.
+*
+* A report without parameters is a plain `GET`, so it can be opened directly in
+* a new tab. As soon as there are parameters or a header the options go in a
+* JSON body, which the route only reads from a `POST`.
+*
+* `filter` is always sent alongside `parameters`: the route reads the filter out
+* of the body *guarded by the presence of `parameters`*, and reads it with an
+* indexer that throws when the key is missing.
+*/
+function getReportRequest(options) {
+	let { domain, filter, headerText, hideFilterString, parameters, reportId, signal, timezone } = options;
+	let fileName = getReportFileName(options);
+	let url = `/api/report/${encodeURIComponent(reportId)}/${encodeURIComponent(fileName)}`;
+	let query = new URLSearchParams();
+	let entries = toParameterEntries(parameters);
+	let needsBody = entries.length > 0 || Boolean(headerText) || hideFilterString === true;
+	if (domain) query.set("Domain", domain);
+	query.set("timezone", String(timezone ?? -(/* @__PURE__ */ new Date()).getTimezoneOffset() / 60));
+	if (!needsBody) {
+		if (filter) query.set("Filter", filter);
+		return new Request(toRequestUrl(`${url}?${query}`), {
+			credentials: "same-origin",
+			signal
+		});
+	}
+	let body = {
+		filter: filter ?? "",
+		parameters: entries
+	};
+	if (headerText) body.optionalheader = headerText;
+	if (hideFilterString === true) body.showfiltercriteria = "true";
+	return new Request(toRequestUrl(`${url}?${query}`), {
+		body: JSON.stringify(body),
+		credentials: "same-origin",
+		headers: {
+			"Content-Type": "application/json",
+			"X-Requested-With": "XMLHttpRequest"
+		},
+		method: "POST",
+		signal
+	});
+}
+/**
+* Renders a report and resolves with the rendered file.
+*
+* The route answers with a JSON body carrying an `error` when rendering fails,
+* rather than with a failing status, so a JSON response is turned into an error
+* here.
+*/
+async function renderReport(options) {
+	let response = await fetch(getReportRequest(options));
+	if ((response.headers.get("content-type") ?? "").includes("application/json")) {
+		let data = await response.json();
+		throw new Error(data.error ?? "Failed to render report");
+	}
+	if (!response.ok) throw new Error(`${response.status} ${response.statusText}`);
+	return response.blob();
+}
+/** Renders a report and saves it, reporting progress as it downloads. */
+function downloadReport(options) {
+	return downloadRequest(getReportRequest(options), {
+		fileName: getReportFileName(options),
+		onProgress: options.onProgress,
+		signal: options.signal
+	});
+}
+/**
+* Renders a report and opens it in a new tab.
+*
+* The blob is rendered first rather than pointing a tab at the route, so a
+* failure surfaces as an error here instead of as a tab showing JSON, and so
+* reports with parameters — which have to be posted — can be previewed too.
+*/
+async function openReport(options) {
+	let blob = await renderReport(options);
+	let url = URL.createObjectURL(blob.type ? blob : new Blob([blob], { type: getReportMediaType(options.format) }));
+	if (!window.open(url, "_blank", "noopener")) {
+		URL.revokeObjectURL(url);
+		throw new Error("The report could not be opened. Allow pop-ups for this site and try again.");
+	}
+	window.setTimeout(() => URL.revokeObjectURL(url), 6e4);
+}
+/**
+* Renders a report and opens the browser's print dialog for it.
+*
+* The report is loaded into an offscreen iframe rather than a new tab, so the
+* print dialog opens over the launcher and the user is not left with a stray
+* tab afterwards. Browsers that will not print an embedded document fall back
+* to opening it, which leaves the user one keystroke from printing.
+*/
+async function printReport(options) {
+	let document_ = window.document;
+	if (!document_?.body) return openReport(options);
+	let blob = await renderReport(options);
+	let url = URL.createObjectURL(blob.type ? blob : new Blob([blob], { type: getReportMediaType(options.format) }));
+	let frame = document_.createElement("iframe");
+	frame.setAttribute("aria-hidden", "true");
+	frame.style.cssText = "position:fixed;inset-block-start:0;inset-inline-start:0;inline-size:1px;block-size:1px;border:0;visibility:hidden";
+	let cleanUp = () => {
+		frame.remove();
+		URL.revokeObjectURL(url);
+	};
+	try {
+		await new Promise((resolve, reject) => {
+			frame.addEventListener("load", () => resolve(), { once: true });
+			frame.addEventListener("error", () => reject(/* @__PURE__ */ new Error("The report could not be loaded for printing")), { once: true });
+			frame.src = url;
+			document_.body.append(frame);
+		});
+		frame.contentWindow?.focus();
+		frame.contentWindow?.print();
+	} catch {
+		cleanUp();
+		return openReport(options);
+	}
+	window.setTimeout(cleanUp, 6e4);
+}
+/**
+* Parameters in the shape the route expects — `{ name, value }` objects.
+*
+* Empty values are dropped: the route skips them anyway, and a report falls back
+* to its own default when a parameter is not sent.
+*/
+function toParameterEntries(parameters) {
+	if (!parameters) return [];
+	return Object.entries(parameters).filter(([, value]) => value !== null && value !== void 0 && value !== "").map(([name, value]) => ({
+		name,
+		value: typeof value === "boolean" ? String(value) : value
+	}));
+}
+
+//#endregion
+//#region src/report/report.ts
+/**
+* Mapping a `sviw_WinClient_MyReports` record onto the report model, including
+* which output formats the report offers.
+*/
+function isSet(value) {
+	return value === true || value === 1;
+}
+/**
+* The formats a report may be rendered to, in the order the launcher offers
+* them.
+*
+* `FormatCSV` covers the whole spreadsheet family: the Windows launcher enables
+* "save as XLS" and "save as XLSX" from the same flag, because they all come out
+* of the same DevExpress export.
+*/
+function getReportFormats(record) {
+	let formats = [];
+	if (isSet(record.FormatPDF)) formats.push("PDF");
+	if (isSet(record.FormatCSV)) formats.push("XLSX", "XLS", "CSV");
+	if (isSet(record.FormatHTML)) formats.push("HTML");
+	if (isSet(record.FormatRTF)) formats.push("RTF");
+	if (isSet(record.FormatMHT)) formats.push("MHT");
+	if (isSet(record.FormatTEXT)) formats.push("TEXT");
+	if (isSet(record.FormatIMAGE)) formats.push("IMAGE");
+	return formats;
+}
+/** Maps a report record onto the model the launcher renders. */
+function toReport(record) {
+	let recordSource = parseRecordSource(record.RecordSource);
+	return {
+		reportId: record.ReportID ?? "",
+		shortId: record.ShortID ?? null,
+		title: record.Title?.trim() || null,
+		description: record.Description?.trim() || null,
+		viewName: recordSource?.viewName ?? null,
+		initialFilter: recordSource?.filterString ?? null,
+		hasTitle: isSet(record.HasTitle),
+		hasHeader: isSet(record.HasHeader),
+		formats: getReportFormats(record),
+		timeout: record.Timeout ?? null
+	};
+}
+
+//#endregion
+//#region src/alert.ts
+const template = `
 	<dialog class="alert-dialog">
 			<form method="dialog">
 					<article></article>
@@ -519,160 +1919,130 @@ var template = `
 			</form>
 	</dialog>
 `;
-if (window.document && !document.querySelector("#AlertDialogTemplate")) {
-  let $template = document.createElement("template");
-  $template.id = "AlertDialogTemplate";
-  $template.innerHTML = template;
-  document.body.append($template);
+function addDialogTemplate() {
+	if (document.querySelector("#AlertDialogTemplate")) return;
+	let $template = document.createElement("template");
+	$template.id = "AlertDialogTemplate";
+	$template.innerHTML = template;
+	document.body.append($template);
+}
+if (window.document) {
+	if (document.body) addDialogTemplate();
+	else document.addEventListener("DOMContentLoaded", addDialogTemplate, { once: true });
 }
 function waitForDialog(dialog, cancelValue = "No") {
-  return new Promise((resolve) => {
-    let controller = new AbortController();
-    dialog.addEventListener(
-      "close",
-      () => {
-        resolve(dialog.returnValue);
-        controller.abort();
-      },
-      { signal: controller.signal }
-    );
-    dialog.addEventListener(
-      "cancel",
-      () => {
-        resolve(cancelValue);
-        controller.abort();
-      },
-      { signal: controller.signal }
-    );
-  });
-}
-var alertDialogPromiseMap = /* @__PURE__ */ new Map();
+	return new Promise((resolve) => {
+		let controller = new AbortController();
+		dialog.addEventListener("close", () => {
+			resolve(dialog.returnValue);
+			controller.abort();
+		}, { signal: controller.signal });
+		dialog.addEventListener("cancel", () => {
+			resolve(cancelValue);
+			controller.abort();
+		}, { signal: controller.signal });
+	});
+}
+const alertDialogPromiseMap = /* @__PURE__ */ new Map();
 async function openAlertDialog({ buttons, content, className, id, title }) {
-  if (id && alertDialogPromiseMap.has(id)) {
-    return await alertDialogPromiseMap.get(id);
-  }
-  let $template = document.querySelector("#AlertDialogTemplate");
-  if (!$template) throw Error("No alert dialog template found");
-  let $dialog = $template.content.firstElementChild?.cloneNode(true);
-  let $content = $dialog?.querySelector("article");
-  let $menu = $dialog?.querySelector("footer menu");
-  if (!$dialog || !$content || !$menu) throw Error("Invalid alert dialog template");
-  if (className) {
-    for (const className_ of className.split(/\s+/)) {
-      $dialog?.classList.add(className_);
-    }
-  }
-  if (title) {
-    let $header = document.createElement("header");
-    $header.append(title);
-    $content.parentNode?.insertBefore($header, $content);
-  }
-  $content.appendChild(typeof content === "string" ? document.createTextNode(content) : content);
-  for (let { label, value, primary } of buttons) {
-    let listItem = document.createElement("li");
-    let buttonElem = document.createElement("button");
-    buttonElem.value = value;
-    if (primary) {
-      buttonElem.classList.add("primary");
-    }
-    buttonElem.textContent = label;
-    listItem.appendChild(buttonElem);
-    $menu.appendChild(buttonElem);
-  }
-  document.body.appendChild($dialog);
-  $dialog.showModal();
-  let dialogPromise = waitForDialog($dialog).then((returnValue) => {
-    if (id && alertDialogPromiseMap.has(id)) {
-      alertDialogPromiseMap.delete(id);
-    }
-    if ($dialog) document.body.removeChild($dialog);
-    return returnValue;
-  });
-  if (id) {
-    alertDialogPromiseMap.set(id, dialogPromise);
-  }
-  return await dialogPromise;
-}
-var ConfirmButtons = /* @__PURE__ */ ((ConfirmButtons2) => {
-  ConfirmButtons2[ConfirmButtons2["YesNo"] = 0] = "YesNo";
-  ConfirmButtons2[ConfirmButtons2["OkCancel"] = 1] = "OkCancel";
-  return ConfirmButtons2;
-})(ConfirmButtons || {});
+	if (id && alertDialogPromiseMap.has(id)) return await alertDialogPromiseMap.get(id);
+	let $template = document.querySelector("#AlertDialogTemplate");
+	if (!$template) throw Error("No alert dialog template found");
+	let $dialog = $template.content.firstElementChild?.cloneNode(true);
+	let $content = $dialog?.querySelector("article");
+	let $menu = $dialog?.querySelector("footer menu");
+	if (!$dialog || !$content || !$menu) throw Error("Invalid alert dialog template");
+	if (className) for (const className_ of className.split(/\s+/)) $dialog?.classList.add(className_);
+	if (title) {
+		let $header = document.createElement("header");
+		$header.append(title);
+		$content.parentNode?.insertBefore($header, $content);
+	}
+	$content.appendChild(typeof content === "string" ? document.createTextNode(content) : content);
+	for (let { label, value, primary } of buttons) {
+		let listItem = document.createElement("li");
+		let buttonElem = document.createElement("button");
+		buttonElem.value = value;
+		if (primary) buttonElem.classList.add("primary");
+		buttonElem.textContent = label;
+		listItem.appendChild(buttonElem);
+		$menu.appendChild(buttonElem);
+	}
+	document.body.appendChild($dialog);
+	$dialog.showModal();
+	let dialogPromise = waitForDialog($dialog).then((returnValue) => {
+		if (id && alertDialogPromiseMap.has(id)) alertDialogPromiseMap.delete(id);
+		if ($dialog) document.body.removeChild($dialog);
+		return returnValue;
+	});
+	if (id) alertDialogPromiseMap.set(id, dialogPromise);
+	return await dialogPromise;
+}
+let ConfirmButtons = /* @__PURE__ */ function(ConfirmButtons) {
+	ConfirmButtons[ConfirmButtons["YesNo"] = 0] = "YesNo";
+	ConfirmButtons[ConfirmButtons["OkCancel"] = 1] = "OkCancel";
+	return ConfirmButtons;
+}({});
 async function confirm(prompt, options = {}) {
-  let { buttons: optionButtons = 0 /* YesNo */, title } = options;
-  let buttons = optionButtons === 1 /* OkCancel */ ? [
-    { label: getLocalizedString("OK"), value: "yes", primary: true },
-    { label: getLocalizedString("Cancel"), value: "no" }
-  ] : [
-    { label: getLocalizedString("Yes"), value: "yes", primary: true },
-    { label: getLocalizedString("No"), value: "no" }
-  ];
-  let result = await openAlertDialog({ content: prompt, buttons, className: "alert-dialog-confirm", title });
-  return result === "yes";
+	let { buttons: optionButtons = 0, title } = options;
+	return await openAlertDialog({
+		content: prompt,
+		buttons: optionButtons === 1 ? [{
+			label: getLocalizedString("OK"),
+			value: "yes",
+			primary: true
+		}, {
+			label: getLocalizedString("Cancel"),
+			value: "no"
+		}] : [{
+			label: getLocalizedString("Yes"),
+			value: "yes",
+			primary: true
+		}, {
+			label: getLocalizedString("No"),
+			value: "no"
+		}],
+		className: "alert-dialog-confirm",
+		title
+	}) === "yes";
 }
 async function alert(prompt, options = {}) {
-  await openAlertDialog({
-    content: prompt,
-    className: "alert-dialog-alert",
-    buttons: [{ label: getLocalizedString("OK"), value: "ok", primary: true }],
-    ...options
-  });
-}
-
-// src/settings.ts
-function getKey(article2) {
-  const articleKey = article2 ?? window.af?.article?.id ?? window.window?.location.pathname.substring(1).split("/")[0];
-  return `${articleKey}.${window.af?.userSession.login ?? "anonymous"}`;
-}
-function getSettings(setting, article2) {
-  if (!window.af?.userSession) return null;
-  const key = getKey(article2);
-  const settings = JSON.parse(localStorage.getItem(key) || "{}");
-  if (setting) {
-    return settings[setting] || null;
-  }
-  return settings;
-}
-function saveSettings(setting, value, article2) {
-  if (!window.af?.userSession) return;
-  const key = getKey(article2);
-  let userSettings = JSON.parse(localStorage.getItem(key) || "{}");
-  if (typeof value !== "undefined") {
-    userSettings[setting] = value;
-  } else {
-    userSettings = setting;
-  }
-  localStorage.setItem(key, JSON.stringify(userSettings));
-}
-
-// src/index.ts
-var version = "2.11.9";
-export {
-  ConfirmButtons,
-  SessionHandler,
-  UserSession,
-  alert,
-  confirm,
-  downloadBlob,
-  downloadRequest,
-  expose,
-  getLocalizedString,
-  getSessionData,
-  getSettings,
-  getUserImage,
-  invariant,
-  localStorage_default as localStorage,
-  localize,
-  logActivity,
-  logError,
-  mitt_default as mitt,
-  openAlertDialog,
-  saveSettings,
-  startActivity,
-  time,
-  toLocalDateTime,
-  toLocalISODate,
-  toLocalISODateTime,
-  version,
-  waitForDialog
-};
+	await openAlertDialog({
+		content: prompt,
+		className: "alert-dialog-alert",
+		buttons: [{
+			label: getLocalizedString("OK"),
+			value: "ok",
+			primary: true
+		}],
+		...options
+	});
+}
+
+//#endregion
+//#region src/settings.ts
+function getKey(article) {
+	return `${article ?? window.af?.article?.id ?? window.window?.location.pathname.substring(1).split("/")[0]}.${window.af?.userSession.login ?? "anonymous"}`;
+}
+function getSettings(setting, article) {
+	if (!window.af?.userSession) return null;
+	const key = getKey(article);
+	const settings = JSON.parse(localStorage.getItem(key) || "{}");
+	if (setting) return settings[setting] || null;
+	return settings;
+}
+function saveSettings(setting, value, article) {
+	if (!window.af?.userSession) return;
+	const key = getKey(article);
+	let userSettings = JSON.parse(localStorage.getItem(key) || "{}");
+	if (typeof value !== "undefined") userSettings[setting] = value;
+	else userSettings = setting;
+	localStorage.setItem(key, JSON.stringify(userSettings));
+}
+
+//#endregion
+//#region src/index.ts
+const version = "2.11.10";
+
+//#endregion
+export { ConfirmButtons, NO_FILTER_ID, RELATIVE_DATE_VALUES, SessionHandler, UserSession, addGroupAtPath, alert, canDeleteSavedFilter, canEditSavedFilter, canRenameSavedFilter, canSetCrossDomain, canShareSavedFilter, changeOperator, coerceParameterValue, coerceToStandardLayout, confirm, convertFilter, countExpressions, createEmptyFilter, createEmptyGroup, createExpression, decodeXml, describeFilter, downloadBlob, downloadReport, downloadRequest, encodeXml, expose, fetchParameterDefault, findSavedFilter, getDefaultOperator, getDefaultParameterValues, getDynamicValueLabel, getDynamicValuesForField, getLocalizedString, getNodeAtPath, getOperatorArity, getOperatorLabel, getOperatorsForField, getReportExtension, getReportFileName, getReportFormats, getReportMediaType, getReportRequest, getSessionData, getSettings, getUserImage, getValueType, insertNodeAtPath, invariant, isCompleteExpression, isEmptyFilter, isExpression, isGroup, isProcedureDefault, isStandardLayout, localStorage_default as localStorage, localize, logActivity, logError, mitt_default as mitt, normalizeOperator, openAlertDialog, openReport, parseParameterItems, parseParameters, parseRecordSource, partitionSavedFilters, printReport, pruneFilter, readElement, readElements, removeNodeAtPath, renderReport, resolveParameterDefaults, restoreParameterValues, saveSettings, serializeParameters, setGroupMode, startActivity, time, toFieldMetadata, toFieldMetadataList, toFilterFieldType, toFilterTree, toLocalDateTime, toLocalISODate, toLocalISODateTime, toReport, toReportParameter, toReportParameters, toSavedFilter, toSavedFilters, updateNodeAtPath, version, waitForDialog };