@olenbetong/appframe-core 2.11.10 → 2.13.0

package/dist/iife/af.common.legacy.js

@@ -1,581 +1,1879 @@
-var af;
-(af ||= {}).common = (() => {
-  var __defProp = Object.defineProperty;
-  var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-  var __getOwnPropNames = Object.getOwnPropertyNames;
-  var __hasOwnProp = Object.prototype.hasOwnProperty;
-  var __export = (target, all) => {
-    for (var name in all)
-      __defProp(target, name, { get: all[name], enumerable: true });
-  };
-  var __copyProps = (to, from, except, desc) => {
-    if (from && typeof from === "object" || typeof from === "function") {
-      for (let key of __getOwnPropNames(from))
-        if (!__hasOwnProp.call(to, key) && key !== except)
-          __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-    }
-    return to;
-  };
-  var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-
-  // src/index.ts
-  var index_exports = {};
-  __export(index_exports, {
-    ConfirmButtons: () => ConfirmButtons,
-    SessionHandler: () => SessionHandler,
-    UserSession: () => UserSession,
-    alert: () => alert,
-    confirm: () => confirm,
-    downloadBlob: () => downloadBlob,
-    downloadRequest: () => downloadRequest,
-    expose: () => expose,
-    getLocalizedString: () => getLocalizedString,
-    getSessionData: () => getSessionData,
-    getSettings: () => getSettings,
-    getUserImage: () => getUserImage,
-    invariant: () => invariant,
-    localStorage: () => localStorage_default,
-    localize: () => localize,
-    logActivity: () => logActivity,
-    logError: () => logError,
-    mitt: () => mitt_default,
-    openAlertDialog: () => openAlertDialog,
-    saveSettings: () => saveSettings,
-    startActivity: () => startActivity,
-    time: () => time,
-    toLocalDateTime: () => toLocalDateTime,
-    toLocalISODate: () => toLocalISODate,
-    toLocalISODateTime: () => toLocalISODateTime,
-    version: () => version,
-    waitForDialog: () => waitForDialog
-  });
-
-  // ../../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
-  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);
-    }
-  };
-
-  // 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);
-    }
-  };
-
-  // src/log.ts
-  var article = window.af?.article?.id ?? window.window?.location.pathname.substring(1).split("/")[0];
-  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 {
-    }
-  }
-  function startActivity(activity, startParameters = {}) {
-    let start = performance.now();
-    return (endParameters = {}) => logActivity(activity, { ...startParameters, ...endParameters }, performance.now() - start);
-  }
-  async function time(callback) {
-    let start = performance.now();
-    let returnValue = await callback();
-    return [returnValue, 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 {
-    }
-  }
-  function getSessionId() {
-    return crypto.randomUUID?.();
-  }
-  var sessionStart = Date.now();
-  var sessionId = getSessionId();
-  var deviceId = "";
-  var 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();
-      }
-    });
-  }
-  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
-  function getLocalKey(key) {
-    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);
-        }
-      }
-    }
-  };
-  var localStorage_default = new LocalStorage();
-
-  // src/date.ts
-  function toLocalISODate(date) {
-    return date ? toLocalISODateTime(date).substring(0, 10) : null;
-  }
-  function pad(num, digits = 2) {
-    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;
-  }
-  function toLocalDateTime(date) {
-    return date ? date.toISOString().substring(0, 16) : "";
-  }
-
-  // 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
-  function invariant(condition, message) {
-    if (condition) {
-      return;
-    }
-    const provided = typeof message === "function" ? message() : message;
-    throw new Error(provided ?? "Invariant failed");
-  }
-
-  // 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)*)\}$/;
-  var arrowBlockRegex = /^(?:\(([^)]*)\)|([a-zA-Z$_][a-zA-Z0-9$_]*))\s*=>\s*\{([\s\S]*)\}$/;
-  var arrowExpressionRegex = /^(?:\(([^)]*)\)|([a-zA-Z$_][a-zA-Z0-9$_]*))\s*=>\s*([\s\S]+)$/;
-  var 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] };
-  }
-
-  // src/Namespace.ts
-  function Namespace() {
-  }
-  Namespace.prototype = /* @__PURE__ */ Object.create(null);
-  var Namespace_default = Namespace;
-
-  // 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
-  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
-  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;
-  }
-  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
-  };
-  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}` : ""}`;
-  }
-
-  // src/localize.ts
-  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 = `
+this.af = this.af || {};
+this.af.common = (function(exports) {
+
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+//#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(n) {
+					n(e);
+				}), (i = n.get("*")) && i.slice().map(function(n) {
+					n(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);
+		}
+	};
+
+//#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);
+		}
+	};
+
+//#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 {}
+	}
+	/**
+	* 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);
+	}
+	/**
+	* 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();
+		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 {}
+	}
+	function getSessionId() {
+		return crypto.randomUUID?.();
+	}
+	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();
+		});
+	}
+	function getSessionData() {
+		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(".");
+	}
+	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);
+		}
+	};
+	var localStorage_default = new LocalStorage();
+
+//#endregion
+//#region src/date.ts
+	function toLocalISODate(date) {
+		return date ? toLocalISODateTime(date).substring(0, 10) : null;
+	}
+	function pad(num, digits = 2) {
+		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;
+	}
+	/**
+	* 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) : "";
+	}
+
+//#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);
+			}
+		});
+	}
+
+//#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");
+	}
+
+//#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"
+			});
+		}
+	}
+
+//#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]
+		};
+	}
+
+//#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") 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;
+		}
+	}
+
+//#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;
+	}
+	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;
+	}
+
+//#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.
+	*
+	* Text defaults to `contains` because a substring search is what people
+	* reach for when they type into a filter box without picking an operator —
+	* `beginswith` silently misses matches in the middle of the value.
+	*/
+	const DEFAULT_OPERATOR_BY_TYPE = {
+		date: "equals",
+		datetime: "equals",
+		number: "equals",
+		boolean: "istrue",
+		string: "contains",
+		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}` : ""}`;
+	}
+
+//#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;
+	}
+
+//#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>
@@ -585,133 +1883,227 @@ var af;
 			</form>
 	</dialog>
 `;
-  if (window.document && !document.querySelector("#AlertDialogTemplate")) {
-    let $template = document.createElement("template");
-    $template.id = "AlertDialogTemplate";
-    $template.innerHTML = template;
-    document.body.append($template);
-  }
-  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();
-  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 || {});
-  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";
-  }
-  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.10";
-  return __toCommonJS(index_exports);
-})();
+	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 });
+		});
+	}
+	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;
+	}
+	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, 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
+		});
+	}
+
+//#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.12.0";
+
+//#endregion
+exports.ConfirmButtons = ConfirmButtons;
+exports.NO_FILTER_ID = NO_FILTER_ID;
+exports.RELATIVE_DATE_VALUES = RELATIVE_DATE_VALUES;
+exports.SessionHandler = SessionHandler;
+exports.UserSession = UserSession;
+exports.addGroupAtPath = addGroupAtPath;
+exports.alert = alert;
+exports.canDeleteSavedFilter = canDeleteSavedFilter;
+exports.canEditSavedFilter = canEditSavedFilter;
+exports.canRenameSavedFilter = canRenameSavedFilter;
+exports.canSetCrossDomain = canSetCrossDomain;
+exports.canShareSavedFilter = canShareSavedFilter;
+exports.changeOperator = changeOperator;
+exports.coerceParameterValue = coerceParameterValue;
+exports.coerceToStandardLayout = coerceToStandardLayout;
+exports.confirm = confirm;
+exports.convertFilter = convertFilter;
+exports.countExpressions = countExpressions;
+exports.createEmptyFilter = createEmptyFilter;
+exports.createEmptyGroup = createEmptyGroup;
+exports.createExpression = createExpression;
+exports.decodeXml = decodeXml;
+exports.describeFilter = describeFilter;
+exports.downloadBlob = downloadBlob;
+exports.downloadReport = downloadReport;
+exports.downloadRequest = downloadRequest;
+exports.encodeXml = encodeXml;
+exports.expose = expose;
+exports.fetchParameterDefault = fetchParameterDefault;
+exports.findSavedFilter = findSavedFilter;
+exports.getDefaultOperator = getDefaultOperator;
+exports.getDefaultParameterValues = getDefaultParameterValues;
+exports.getDynamicValueLabel = getDynamicValueLabel;
+exports.getDynamicValuesForField = getDynamicValuesForField;
+exports.getLocalizedString = getLocalizedString;
+exports.getNodeAtPath = getNodeAtPath;
+exports.getOperatorArity = getOperatorArity;
+exports.getOperatorLabel = getOperatorLabel;
+exports.getOperatorsForField = getOperatorsForField;
+exports.getReportExtension = getReportExtension;
+exports.getReportFileName = getReportFileName;
+exports.getReportFormats = getReportFormats;
+exports.getReportMediaType = getReportMediaType;
+exports.getReportRequest = getReportRequest;
+exports.getSessionData = getSessionData;
+exports.getSettings = getSettings;
+exports.getUserImage = getUserImage;
+exports.getValueType = getValueType;
+exports.insertNodeAtPath = insertNodeAtPath;
+exports.invariant = invariant;
+exports.isCompleteExpression = isCompleteExpression;
+exports.isEmptyFilter = isEmptyFilter;
+exports.isExpression = isExpression;
+exports.isGroup = isGroup;
+exports.isProcedureDefault = isProcedureDefault;
+exports.isStandardLayout = isStandardLayout;
+exports.localStorage = localStorage_default;
+exports.localize = localize;
+exports.logActivity = logActivity;
+exports.logError = logError;
+exports.mitt = mitt_default;
+exports.normalizeOperator = normalizeOperator;
+exports.openAlertDialog = openAlertDialog;
+exports.openReport = openReport;
+exports.parseParameterItems = parseParameterItems;
+exports.parseParameters = parseParameters;
+exports.parseRecordSource = parseRecordSource;
+exports.partitionSavedFilters = partitionSavedFilters;
+exports.printReport = printReport;
+exports.pruneFilter = pruneFilter;
+exports.readElement = readElement;
+exports.readElements = readElements;
+exports.removeNodeAtPath = removeNodeAtPath;
+exports.renderReport = renderReport;
+exports.resolveParameterDefaults = resolveParameterDefaults;
+exports.restoreParameterValues = restoreParameterValues;
+exports.saveSettings = saveSettings;
+exports.serializeParameters = serializeParameters;
+exports.setGroupMode = setGroupMode;
+exports.startActivity = startActivity;
+exports.time = time;
+exports.toFieldMetadata = toFieldMetadata;
+exports.toFieldMetadataList = toFieldMetadataList;
+exports.toFilterFieldType = toFilterFieldType;
+exports.toFilterTree = toFilterTree;
+exports.toLocalDateTime = toLocalDateTime;
+exports.toLocalISODate = toLocalISODate;
+exports.toLocalISODateTime = toLocalISODateTime;
+exports.toReport = toReport;
+exports.toReportParameter = toReportParameter;
+exports.toReportParameters = toReportParameters;
+exports.toSavedFilter = toSavedFilter;
+exports.toSavedFilters = toSavedFilters;
+exports.updateNodeAtPath = updateNodeAtPath;
+exports.version = version;
+exports.waitForDialog = waitForDialog;
+return exports;
+})({});