@knime/utils 1.12.1 → 2.0.1

package/dist/index.js

@@ -1,755 +1,957 @@
-import { isValid, set, getDate, getMonth, getYear, isAfter, isBefore } from 'date-fns';
-import prettyBytes from 'pretty-bytes';
-import DomPurify from 'dompurify';
-
-const capitalize = (input) => input.charAt(0).toUpperCase() + input.substring(1);
-const formats = {
-  customFormat: (input, delimiter) => capitalize(input.replace(delimiter, " ").toLowerCase()),
-  kebabFormat: (input) => formats.customFormat(input, "-"),
-  snakeFormat: (input) => formats.customFormat(input, "_"),
-  camelPascalCase: (input) => capitalize(
-    (input.match(/([A-Z]?[^A-Z]*)/g) ?? []).slice(0, -1).join(" ").toLowerCase()
-  )
-};
-const caseFormatter = ({
-  string,
-  delimiter,
-  format
-}) => {
-  if (delimiter) {
-    return formats.customFormat(string, delimiter);
-  }
-  if (format) {
-    return formats[format](string, delimiter ?? "");
-  }
-  return capitalize(string);
-};
-
-const updateDate = (base, date) => {
-  if (date) {
-    base = isValid(base) ? base : new Date(Date.UTC(0, 0));
-    return set(base, {
-      year: getYear(date),
-      month: getMonth(date),
-      date: getDate(date)
-    });
-  }
-  return base;
-};
-
-const updateTime = (base, date) => {
-  const d = new Date(base);
-  if (date) {
-    d.setHours(date.getHours());
-    d.setMinutes(date.getMinutes());
-    d.setSeconds(date.getSeconds());
-    d.setMilliseconds(date.getMilliseconds());
-  }
-  return d;
-};
-
-const isBeforeMinDate = (date, min, checkDate, checkTime) => {
-  if (min) {
-    if (checkTime && checkDate) {
-      return isBefore(date, min);
-    }
-    if (checkTime) {
-      const base = /* @__PURE__ */ new Date(0);
-      return isBefore(updateTime(base, date), updateTime(base, min));
-    }
-    if (checkDate) {
-      const base = /* @__PURE__ */ new Date(0);
-      return isBefore(updateDate(base, date), updateDate(base, min));
-    }
-  }
-  return false;
-};
-const isAfterMaxDate = (date, max, checkDate, checkTime) => {
-  if (max) {
-    if (checkTime && checkDate) {
-      return isAfter(date, max);
-    }
-    if (checkTime) {
-      const base = /* @__PURE__ */ new Date(0);
-      return isAfter(updateTime(base, date), updateTime(base, max));
-    }
-    if (checkDate) {
-      const base = /* @__PURE__ */ new Date(0);
-      return isAfter(updateDate(base, date), updateDate(base, max));
-    }
-  }
-  return false;
-};
-
-const debounce = (callback, wait) => {
-  let timer;
-  let lastCall = 0;
-  return (...args) => {
-    const [value, index] = args;
-    clearTimeout(timer);
-    const now = Date.now();
-    const timeFromLastCall = now - lastCall;
-    if (timeFromLastCall > wait) {
-      lastCall = now;
-      callback(value, index);
-    } else {
-      timer = setTimeout(() => {
-        lastCall = now;
-        callback(value, index);
-      }, wait);
-    }
-  };
-};
-
-const modeDefinitions = [
-  {
-    id: "search",
-    normalize(searchTerm, caseSensitiveSearch) {
-      return caseSensitiveSearch ? searchTerm : searchTerm.toLowerCase();
-    },
-    test(text, normalizedSearchTerm, caseSensitiveSearch, inverseSearch) {
-      const testText = caseSensitiveSearch ? text : text.toLowerCase();
-      const matches = testText.includes(normalizedSearchTerm);
-      return inverseSearch ? !matches : matches;
-    }
-  },
-  {
-    id: "wildcard",
-    normalize(searchTerm, caseSensitiveSearch) {
-      if (searchTerm.length > 0) {
-        const escapedSearchTerm = searchTerm.replace(
-          /[-[\]{}()+.,\\^$|#\s]/g,
-          "\\$&"
-        );
-        const wildcardSearchTerm = escapedSearchTerm.replace(/\*/g, ".*").replace(/\?/g, ".?");
-        searchTerm = `^${wildcardSearchTerm}$`;
-      } else {
-        return { test: () => false };
-      }
-      try {
-        const flags = caseSensitiveSearch ? "" : "i";
-        return new RegExp(searchTerm, flags);
-      } catch (_error) {
-        return /$^/;
-      }
-    },
-    test(text, normalizedSearchTerm, caseSensitiveSearch, inverseSearch) {
-      const matches = normalizedSearchTerm.test(text);
-      return inverseSearch ? !matches : matches;
-    }
-  },
-  {
-    id: "regex",
-    normalize(searchTerm, caseSensitiveSearch) {
-      try {
-        const flags = caseSensitiveSearch ? "" : "i";
-        return new RegExp(`^(${searchTerm})$`, flags);
-      } catch (_error) {
-        return /$^/;
-      }
-    },
-    test(text, normalizedSearchTerm, caseSensitiveSearch, inverseSearch) {
-      const matches = normalizedSearchTerm.test(text);
-      return inverseSearch ? !matches : matches;
-    }
-  },
-  {
-    id: "type",
-    normalize(selectedTypes) {
-      return { test: (type) => selectedTypes.includes(type) };
-    },
-    test(type, normalizedSearchTerm) {
-      if (typeof type === "undefined") {
-        return false;
-      }
-      return normalizedSearchTerm.test(type);
-    }
-  }
-];
-const filters = Object.assign({}, ...modeDefinitions.map((obj) => ({ [obj.id]: obj })));
-
-const getLocalTimeZone = () => Intl.DateTimeFormat().resolvedOptions().timeZone;
-
-const formatDateString = (dateString, useTimeZone = false) => {
-  const date = new Date(dateString);
-  if (isNaN(date)) {
-    throw Error("Invalid Date format");
-  }
-  const baseDateOptions = {
-    day: "numeric",
-    month: "short",
-    year: "numeric"
-  };
-  const dateOptions = useTimeZone ? { ...baseDateOptions, timeZone: getLocalTimeZone() } : baseDateOptions;
-  return date.toLocaleDateString("en-US", dateOptions);
-};
-const formatTimeString = (timeString, useTimeZone = false) => {
-  const time = new Date(timeString);
-  if (isNaN(time)) {
-    throw Error("Invalid Date format");
-  }
-  const baseTimeOptions = {
-    hour: "numeric",
-    minute: "2-digit"
-  };
-  const timeOptions = useTimeZone ? { ...baseTimeOptions, timeZone: getLocalTimeZone() } : baseTimeOptions;
-  return time.toLocaleTimeString("en-US", timeOptions);
-};
-const formatDateTimeString = (dateTimeString, useTimeZone = false) => {
-  return `${formatDateString(dateTimeString, useTimeZone)} ${formatTimeString(
-    dateTimeString,
-    useTimeZone
-  )}`;
-};
-const formatLocalDateTimeString = (date, showTime) => showTime ? formatDateTimeString(date, true) : formatDateString(date, true);
-const formatFileSize = (bytes) => {
-  const safeBytes = Number.isFinite(bytes) && bytes >= 0 ? bytes : 0;
-  return prettyBytes(safeBytes);
-};
-
-const getDeepActiveElement = () => {
-  let element = document?.activeElement;
-  while (element?.shadowRoot) {
-    element = element?.shadowRoot?.activeElement;
-  }
-  return element;
-};
-
-const getWrappedAroundIndex = (index, length) => (index % length + length) % length;
-
-const extractPeriodFromRegexMatch = (negative, match) => {
-  return {
-    negative,
-    years: parseInt(match[1] ?? "0", 10),
-    months: parseInt(match[2] ?? "0", 10),
-    weeks: parseInt(match[3] ?? "0", 10),
-    days: parseInt(match[4] ?? "0", 10)
-  };
-};
-const extractDurationFromRegexMatch = (negative, match) => {
-  const milliseconds = parseInt(match[4]?.padEnd(3, "0") ?? "0", 10);
-  return {
-    negative,
-    hours: parseInt(match[1] ?? "0", 10),
-    minutes: parseInt(match[2] ?? "0", 10),
-    seconds: parseInt(match[3] ?? "0", 10),
-    milliseconds
-  };
-};
-const isZero = (interval) => {
-  if (interval.type === "DATE") {
-    return interval.interval.years === 0 && interval.interval.months === 0 && interval.interval.weeks === 0 && interval.interval.days === 0;
-  } else {
-    return interval.interval.hours === 0 && interval.interval.minutes === 0 && interval.interval.seconds === 0 && interval.interval.milliseconds === 0;
-  }
-};
-const formatIntervalToISOIntervalString = (toFormat) => {
-  let output = "P";
-  if (toFormat.type === "DATE") {
-    output += `${toFormat.interval.years}Y${toFormat.interval.months}M${toFormat.interval.weeks}W${toFormat.interval.days}D`;
-  } else {
-    output += `T${toFormat.interval.hours}H${toFormat.interval.minutes}M${toFormat.interval.seconds}.${toFormat.interval.milliseconds.toString().padStart(3, "0")}S`;
-  }
-  if (toFormat.interval.negative) {
-    output = `-${output}`;
-  }
-  return output;
-};
-const formatIntervalToHumanReadableIntervalString = (toFormat) => {
-  const formatPart = (value, unit) => {
-    if (value === 0) {
-      return "";
-    } else if (value === 1) {
-      return `${value} ${unit} `;
-    } else {
-      return `${value} ${unit}s `;
-    }
-  };
-  let output = "";
-  if (toFormat.type === "DATE") {
-    if (isZero(toFormat)) {
-      return "0 days";
-    }
-    output += formatPart(toFormat.interval.years, "year");
-    output += formatPart(toFormat.interval.months, "month");
-    output += formatPart(toFormat.interval.weeks, "week");
-    output += formatPart(toFormat.interval.days, "day");
-  } else {
-    if (isZero(toFormat)) {
-      return "0 seconds";
-    }
-    output += formatPart(toFormat.interval.hours, "hour");
-    output += formatPart(toFormat.interval.minutes, "minute");
-    const milliSecondsZero = toFormat.interval.milliseconds === 0;
-    if (toFormat.interval.seconds !== 0 || !milliSecondsZero) {
-      if (milliSecondsZero) {
-        output += formatPart(toFormat.interval.seconds, "second");
-      } else {
-        output += `${toFormat.interval.seconds}.${toFormat.interval.milliseconds.toString().padStart(3, "0")} seconds `;
-      }
-    }
-  }
-  if (toFormat.interval.negative) {
-    output = `-(${output.trim()})`;
-  }
-  return output.trim();
-};
-const yearsPart = "(\\d+)\\s*y(?:ears?)?";
-const monthsPart = "(\\d+)\\s*m(?:o(?:nths?)?)?";
-const weeksPart = "(\\d+)\\s*w(?:eeks?)?";
-const daysPart = "(\\d+)\\s*d(?:ays?)?";
-const hoursPart = "(\\d+)\\s*h(?:ours?)?";
-const minutesPart = "(\\d+)\\s*m(?:in(?:s|utes?)?)?";
-const secondsPart = "(\\d+)(?:[,.](\\d{1,3}))?\\s*s(?:ec(?:s|onds?)?)?";
-const humanReadablePeriodRegex = new RegExp(
-  `^(?:${yearsPart})?\\s*(?:${monthsPart})?\\s*(?:${weeksPart})?\\s*(?:${daysPart})?\\s*$`,
-  "i"
-);
-const humanReadableDurationRegex = new RegExp(
-  `^(?:${hoursPart})?\\s*(?:${minutesPart})?\\s*(?:${secondsPart})?$`,
-  "i"
-);
-const negativeHumanReadablePeriodRegex = new RegExp(
-  `^\\s*-\\s*\\(\\s*${humanReadablePeriodRegex.source.replace(/[$^]/g, "")}\\s*\\)\\s*$`,
-  "i"
-);
-const negativeHumanReadablePeriodRegexWithSingleField = new RegExp(
-  `^\\s*-\\s*(?:\\s*${yearsPart}|${monthsPart}|${weeksPart}|${daysPart})\\s*$`,
-  "i"
-);
-const negativeHumanReadableDurationRegex = new RegExp(
-  `^\\s*-\\s*\\(\\s*${humanReadableDurationRegex.source.replace(/[$^]/g, "")}\\s*\\)\\s*$`,
-  "i"
-);
-const negativeHumanReadableDurationRegexWithSingleField = new RegExp(
-  `^\\s*-\\s*(?:\\s*${hoursPart}|${minutesPart}|${secondsPart})\\s*$`,
-  "i"
-);
-const parseHumanReadableIntervalString = (intervalString) => {
-  intervalString = intervalString?.trim();
-  if (!intervalString) {
-    throw new Error("Empty interval string");
-  }
-  const matchPositivePeriod = humanReadablePeriodRegex.exec(intervalString);
-  const matchNegativePeriod = negativeHumanReadablePeriodRegex.exec(intervalString) ?? negativeHumanReadablePeriodRegexWithSingleField.exec(intervalString);
-  const matchPositiveDuration = humanReadableDurationRegex.exec(intervalString);
-  const matchNegativeDuration = negativeHumanReadableDurationRegex.exec(intervalString) ?? negativeHumanReadableDurationRegexWithSingleField.exec(intervalString);
-  const matchPeriod = matchPositivePeriod ?? matchNegativePeriod;
-  const matchDuration = matchPositiveDuration ?? matchNegativeDuration;
-  const negative = (matchNegativePeriod ?? matchNegativeDuration) !== null;
-  if (matchDuration && matchPeriod) {
-    throw new Error("Ambiguous time format");
-  }
-  if (matchPeriod) {
-    return {
-      type: "DATE",
-      interval: extractPeriodFromRegexMatch(negative, matchPeriod)
-    };
-  } else if (matchDuration) {
-    return {
-      type: "TIME",
-      interval: extractDurationFromRegexMatch(negative, matchDuration)
-    };
-  } else {
-    throw new Error(`Invalid human readable time: ${intervalString}`);
-  }
-};
-const isValidHumanReadableIntervalString = (time, expectedType) => {
-  try {
-    const validationResult = parseHumanReadableIntervalString(time);
-    const actualType = validationResult.type;
-    const negative = validationResult.interval.negative;
-    if (actualType === expectedType || expectedType === "DATE_OR_TIME") {
-      return {
-        valid: true,
-        type: actualType,
-        negative
-      };
-    } else {
-      return { valid: false };
-    }
-  } catch (_e) {
-    return { valid: false };
-  }
-};
-const parseISOIntervalString = (isoString) => {
-  isoString = isoString?.trim();
-  if (["", "P", "PT", "-", "-P", "-PT"].includes(isoString)) {
-    throw new Error("Empty ISO duration");
-  }
-  const periodRegex = /^-?P(?:(\d+)Y)?(?:(\d+)M)?(?:(\d+)W)?(?:(\d+)D)?$/;
-  const durationRegex = /^-?PT(?:(\d+)H)?(?:(\d+)M)?(?:(\d+)(?:[,.](\d{1,3}))?S)?$/;
-  const matchPeriod = periodRegex.exec(isoString);
-  const matchDuration = durationRegex.exec(isoString);
-  if (matchPeriod) {
-    return {
-      type: "DATE",
-      interval: extractPeriodFromRegexMatch(
-        isoString.startsWith("-"),
-        matchPeriod
-      )
-    };
-  } else if (matchDuration) {
-    return {
-      type: "TIME",
-      interval: extractDurationFromRegexMatch(
-        isoString.startsWith("-"),
-        matchDuration
-      )
-    };
-  } else {
-    throw new Error(`Invalid ISO duration: ${isoString}`);
-  }
-};
-const isValidISOIntervalString = (isoString, type) => {
-  try {
-    const validationResult = parseISOIntervalString(isoString);
-    const actualType = validationResult.type;
-    const negative = validationResult.interval.negative;
-    if (actualType === type || type === "DATE_OR_TIME") {
-      return {
-        valid: true,
-        type: actualType,
-        negative
-      };
-    } else {
-      return { valid: false };
-    }
-  } catch (_e) {
-    return { valid: false };
-  }
-};
-const parseGenericIntervalString = (time) => {
-  const validISO = isValidISOIntervalString(time, "DATE_OR_TIME");
-  const validHumanReadable = isValidHumanReadableIntervalString(
-    time,
-    "DATE_OR_TIME"
-  );
-  if (validISO.valid) {
-    return parseISOIntervalString(time);
-  } else if (validHumanReadable.valid) {
-    return parseHumanReadableIntervalString(time);
-  } else {
-    throw new Error(`Invalid interval string: ${time}`);
-  }
-};
-const isValidIntervalString = (time, type) => {
-  const validISO = isValidISOIntervalString(time, type);
-  const validHumanReadable = isValidHumanReadableIntervalString(time, type);
-  if (validISO.valid) {
-    return validISO;
-  } else if (validHumanReadable.valid) {
-    return validHumanReadable;
-  } else {
-    return { valid: false };
-  }
-};
-
-const intervalUtils = /*#__PURE__*/Object.freeze(/*#__PURE__*/Object.defineProperty({
-  __proto__: null,
-  formatIntervalToHumanReadableIntervalString,
-  formatIntervalToISOIntervalString,
-  isValidHumanReadableIntervalString,
-  isValidISOIntervalString,
-  isValidIntervalString,
-  isZero,
-  parseGenericIntervalString,
-  parseHumanReadableIntervalString,
-  parseISOIntervalString
-}, Symbol.toStringTag, { value: 'Module' }));
-
-const numIntegerDigits = (input) => Math.max(Math.floor(Math.log10(Math.abs(input))), 0) + 1;
-
-class AbortError extends Error {
-}
-const createAbortablePromise = () => {
-  const abortController = new AbortController();
-  const runAbortablePromise = (request) => {
-    return new Promise((resolve, reject) => {
-      const abortListener = ({ target }) => {
-        abortController.signal.removeEventListener("abort", abortListener);
-        const reason = target.reason;
-        reject(reason instanceof AbortError ? reason : new AbortError(reason));
-      };
-      request().then(resolve).catch((error) => {
-        if (error instanceof AbortError) {
-          return;
-        }
-        reject(error);
-      });
-      abortController.signal.addEventListener("abort", abortListener);
-    });
-  };
-  return { abortController, runAbortablePromise };
-};
-
-const createUnwrappedPromise = () => {
-  let resolve = () => {
-  };
-  let reject = () => {
-  };
-  const promise = new Promise((res, rej) => {
-    resolve = res;
-    reject = rej;
-  });
-  return { resolve, reject, promise };
-};
-
+import { getDate, getMonth, getYear, isAfter, isBefore, isValid, set } from "date-fns";
+import prettyBytes from "pretty-bytes";
+import DomPurify from "dompurify";
+//#region \0rolldown/runtime.js
+var __defProp = Object.defineProperty;
+var __exportAll = (all, no_symbols) => {
+	let target = {};
+	for (var name in all) __defProp(target, name, {
+		get: all[name],
+		enumerable: true
+	});
+	if (!no_symbols) __defProp(target, Symbol.toStringTag, { value: "Module" });
+	return target;
+};
+//#endregion
+//#region src/capitalize.ts
+/**
+* Uppercases first letter of string
+* @param string to be capitalized first string, e.g. "workflow"
+* @return Capitalized String, e.g. "Workflow"
+*/
+var capitalize = (input) => input.charAt(0).toUpperCase() + input.substring(1);
+var formats = {
+	customFormat: (input, delimiter) => capitalize(input.replace(delimiter, " ").toLowerCase()),
+	kebabFormat: (input) => formats.customFormat(input, "-"),
+	snakeFormat: (input) => formats.customFormat(input, "_"),
+	camelPascalCase: (input) => capitalize((input.match(/([A-Z]?[^A-Z]*)/g) ?? []).slice(0, -1).join(" ").toLowerCase())
+};
+var caseFormatter = ({ string, delimiter, format }) => {
+	if (delimiter) return formats.customFormat(string, delimiter);
+	if (format) return formats[format](string, delimiter ?? "");
+	return capitalize(string);
+};
+//#endregion
+//#region src/updateDate.ts
+/**
+* Updates the date part (year, day and month) of a date object (base)
+* time, offset (timezone) and so on will be left untouched.
+*
+* @param  base - Date which will be used (copied) to set day, month and year.
+* @param  date - Extract day, month and year from this date object.
+* @returns Copy of base with day, month and year of date.
+*/
+var updateDate_default = (base, date) => {
+	if (date) {
+		base = isValid(base) ? base : new Date(Date.UTC(0, 0));
+		return set(base, {
+			year: getYear(date),
+			month: getMonth(date),
+			date: getDate(date)
+		});
+	}
+	return base;
+};
+//#endregion
+//#region src/updateTime.ts
+/**
+* Updates the time part (hour, minute, second and millisecond) of a date object (base)
+* date, offset (timezone) and so on will be left untouched.
+*
+* @param base - Date which will be used (copied) to set day, month and year.
+* @param date - Extract hour, minute, second and millisecond from this date object.
+* @returns Copy of base with hour, minute, second and millisecond changed.
+*/
+var updateTime_default = (base, date) => {
+	const d = new Date(base);
+	if (date) {
+		d.setHours(date.getHours());
+		d.setMinutes(date.getMinutes());
+		d.setSeconds(date.getSeconds());
+		d.setMilliseconds(date.getMilliseconds());
+	}
+	return d;
+};
+//#endregion
+//#region src/dateMinMaxCheck.ts
+/**
+* Check if date is before min.
+* @param date
+* @param min
+* @param checkDate - check date part (year, day, month).
+* @param checkTime - check time part (hour, minutes etc.).
+* @returns whether limit is kept or not.
+*/
+var isBeforeMinDate = (date, min, checkDate, checkTime) => {
+	if (min) {
+		if (checkTime && checkDate) return isBefore(date, min);
+		if (checkTime) {
+			const base = /* @__PURE__ */ new Date(0);
+			return isBefore(updateTime_default(base, date), updateTime_default(base, min));
+		}
+		if (checkDate) {
+			const base = /* @__PURE__ */ new Date(0);
+			return isBefore(updateDate_default(base, date), updateDate_default(base, min));
+		}
+	}
+	return false;
+};
+/**
+* Check
+* @param date - date to check.
+* @param max - maximum date.
+* @param checkDate - check date part (year, day, month).
+* @param checkTime - check time part (hour, minutes etc.).
+* @returns whether limit is kept or not.
+*/
+var isAfterMaxDate = (date, max, checkDate, checkTime) => {
+	if (max) {
+		if (checkTime && checkDate) return isAfter(date, max);
+		if (checkTime) {
+			const base = /* @__PURE__ */ new Date(0);
+			return isAfter(updateTime_default(base, date), updateTime_default(base, max));
+		}
+		if (checkDate) {
+			const base = /* @__PURE__ */ new Date(0);
+			return isAfter(updateDate_default(base, date), updateDate_default(base, max));
+		}
+	}
+	return false;
+};
+//#endregion
+//#region src/debounce.ts
+var debounce = (callback, wait) => {
+	let timer;
+	let lastCall = 0;
+	return (...args) => {
+		const [value, index] = args;
+		clearTimeout(timer);
+		const now = Date.now();
+		if (now - lastCall > wait) {
+			lastCall = now;
+			callback(value, index);
+		} else timer = setTimeout(() => {
+			lastCall = now;
+			callback(value, index);
+		}, wait);
+	};
+};
+var filters = Object.assign({}, ...[
+	{
+		id: "search",
+		normalize(searchTerm, caseSensitiveSearch) {
+			return caseSensitiveSearch ? searchTerm : searchTerm.toLowerCase();
+		},
+		test(text, normalizedSearchTerm, caseSensitiveSearch, inverseSearch) {
+			const matches = (caseSensitiveSearch ? text : text.toLowerCase()).includes(normalizedSearchTerm);
+			return inverseSearch ? !matches : matches;
+		}
+	},
+	{
+		id: "wildcard",
+		normalize(searchTerm, caseSensitiveSearch) {
+			if (searchTerm.length > 0) searchTerm = `^${searchTerm.replace(/[-[\]{}()+.,\\^$|#\s]/g, "\\$&").replace(/\*/g, ".*").replace(/\?/g, ".?")}$`;
+			else return { test: () => false };
+			try {
+				return new RegExp(searchTerm, caseSensitiveSearch ? "" : "i");
+			} catch (_error) {
+				return /$^/;
+			}
+		},
+		test(text, normalizedSearchTerm, caseSensitiveSearch, inverseSearch) {
+			const matches = normalizedSearchTerm.test(text);
+			return inverseSearch ? !matches : matches;
+		}
+	},
+	{
+		id: "regex",
+		normalize(searchTerm, caseSensitiveSearch) {
+			try {
+				const flags = caseSensitiveSearch ? "" : "i";
+				return new RegExp(`^(${searchTerm})$`, flags);
+			} catch (_error) {
+				return /$^/;
+			}
+		},
+		test(text, normalizedSearchTerm, caseSensitiveSearch, inverseSearch) {
+			const matches = normalizedSearchTerm.test(text);
+			return inverseSearch ? !matches : matches;
+		}
+	},
+	{
+		id: "type",
+		normalize(selectedTypes) {
+			return { test: (type) => selectedTypes.includes(type) };
+		},
+		test(type, normalizedSearchTerm) {
+			if (typeof type === "undefined") return false;
+			return normalizedSearchTerm.test(type);
+		}
+	}
+].map((obj) => ({ [obj.id]: obj })));
+//#endregion
+//#region src/localTimezone.ts
+/**
+* Get the users local timezone.
+*
+* @returns current users timezone (browser based) tz db string (e. g. Europe/Berlin).
+*/
+var localTimezone_default = () => Intl.DateTimeFormat().resolvedOptions().timeZone;
+//#endregion
+//#region src/format.ts
+/**
+* Converts the specified date String to human readable text containing the day, month, and year.
+* Example: '2018-07-31T09:44:31+00:00' => 'Jul 31, 2018'
+*
+* @param dateString String representation of the Date to format
+* @param useTimeZone to set the timeZone where the user is located, and display local date and time
+* @returns human readable date String
+*/
+var formatDateString = (dateString, useTimeZone = false) => {
+	const date = new Date(dateString);
+	if (isNaN(date)) throw Error("Invalid Date format");
+	const baseDateOptions = {
+		day: "numeric",
+		month: "short",
+		year: "numeric"
+	};
+	const dateOptions = useTimeZone ? {
+		...baseDateOptions,
+		timeZone: localTimezone_default()
+	} : baseDateOptions;
+	return date.toLocaleDateString("en-US", dateOptions);
+};
+/**
+* Converts the specified time String to human readable text containing the hour (12-hour) and minute.
+* Example: '2018-07-31T09:44:31+00:00' => '9:44 AM'
+*
+* @param timeString String representation of the Date (including time) to format
+* @param useTimeZone to set the timeZone where the user is located, and display local date and time
+* @returns human readable time String
+*/
+var formatTimeString = (timeString, useTimeZone = false) => {
+	const time = new Date(timeString);
+	if (isNaN(time)) throw Error("Invalid Date format");
+	const baseTimeOptions = {
+		hour: "numeric",
+		minute: "2-digit"
+	};
+	const timeOptions = useTimeZone ? {
+		...baseTimeOptions,
+		timeZone: localTimezone_default()
+	} : baseTimeOptions;
+	return time.toLocaleTimeString("en-US", timeOptions);
+};
+/**
+* Converts the specified time String to human readable text containing the date (day, month, year) and time (hour,
+* minute; 12-hour).
+* Example: '2018-07-31T09:44:31+00:00' => 'Jul 31, 2018 9:44 AM'
+*
+* @param dateTimeString String representation of the Date (including time and date) to format
+* @param useTimeZone to set the timeZone where the user is located, and display local date and time
+* @returns human readable date/time String
+*/
+var formatDateTimeString = (dateTimeString, useTimeZone = false) => {
+	return `${formatDateString(dateTimeString, useTimeZone)} ${formatTimeString(dateTimeString, useTimeZone)}`;
+};
+/**
+* Converts the specified date and time to the user time zone with option to display (day, month, year) only or with time (hour,
+* minute; 12-hour).
+*
+* @param showTime String representation of the Date to convert and format
+* @param String | number} date String representation of the Date to convert and format
+* @returns human readable date/time String converted to user time zone
+*/
+var formatLocalDateTimeString = (date, showTime) => showTime ? formatDateTimeString(date, true) : formatDateString(date, true);
+var formatFileSize = (bytes) => {
+	return prettyBytes(Number.isFinite(bytes) && bytes >= 0 ? bytes : 0);
+};
+//#endregion
+//#region src/getDeepActiveElement.ts
+var getDeepActiveElement = () => {
+	let element = document?.activeElement;
+	while (element?.shadowRoot) element = element?.shadowRoot?.activeElement;
+	return element;
+};
+//#endregion
+//#region src/getWrappedAroundIndex.ts
+/**
+* Since (a % b) yields a negative outcome for negative a, we need this method in order
+*  to correctly compute wrapped around indices in lists
+* @param {number} index an arbitrary integer
+* @param {number} length a positive integer
+* @returns {number} the non-negative modulo outcome
+*/
+var getWrappedAroundIndex_default = (index, length) => (index % length + length) % length;
+//#endregion
+//#region src/intervalUtils.ts
+var intervalUtils_exports = /* @__PURE__ */ __exportAll({
+	formatIntervalToHumanReadableIntervalString: () => formatIntervalToHumanReadableIntervalString,
+	formatIntervalToISOIntervalString: () => formatIntervalToISOIntervalString,
+	isValidHumanReadableIntervalString: () => isValidHumanReadableIntervalString,
+	isValidISOIntervalString: () => isValidISOIntervalString,
+	isValidIntervalString: () => isValidIntervalString,
+	isZero: () => isZero,
+	parseGenericIntervalString: () => parseGenericIntervalString,
+	parseHumanReadableIntervalString: () => parseHumanReadableIntervalString,
+	parseISOIntervalString: () => parseISOIntervalString
+});
+var extractPeriodFromRegexMatch = (negative, match) => {
+	return {
+		negative,
+		years: parseInt(match[1] ?? "0", 10),
+		months: parseInt(match[2] ?? "0", 10),
+		weeks: parseInt(match[3] ?? "0", 10),
+		days: parseInt(match[4] ?? "0", 10)
+	};
+};
+var extractDurationFromRegexMatch = (negative, match) => {
+	const milliseconds = parseInt(match[4]?.padEnd(3, "0") ?? "0", 10);
+	return {
+		negative,
+		hours: parseInt(match[1] ?? "0", 10),
+		minutes: parseInt(match[2] ?? "0", 10),
+		seconds: parseInt(match[3] ?? "0", 10),
+		milliseconds
+	};
+};
+var isZero = (interval) => {
+	if (interval.type === "DATE") return interval.interval.years === 0 && interval.interval.months === 0 && interval.interval.weeks === 0 && interval.interval.days === 0;
+	else return interval.interval.hours === 0 && interval.interval.minutes === 0 && interval.interval.seconds === 0 && interval.interval.milliseconds === 0;
+};
+/**
+* Take an interval object and convert it to an ISO duration or period string. All parts of the
+* relevant part of the Interval object are included in the output, even if they are zero.
+*
+* Technically the ISO standard allows to mix period and duration parts, but we don't support that
+* here because it's incredibly hard to deal with all the edge cases. Maybe in a future ticket.
+*
+* The output here is allowed to be negative, in which case the minus sign is prepended to the
+* output.
+*
+* @param toFormat The PeriodOrDuration object to format
+*/
+var formatIntervalToISOIntervalString = (toFormat) => {
+	let output = "P";
+	if (toFormat.type === "DATE") output += `${toFormat.interval.years}Y${toFormat.interval.months}M${toFormat.interval.weeks}W${toFormat.interval.days}D`;
+	else output += `T${toFormat.interval.hours}H${toFormat.interval.minutes}M${toFormat.interval.seconds}.${toFormat.interval.milliseconds.toString().padStart(3, "0")}S`;
+	if (toFormat.interval.negative) output = `-${output}`;
+	return output;
+};
+/**
+* Take an interval object and convert it to a human readable string. Only non-zero parts are
+* included in the output (unless all parts are 0).
+*
+* The output here is allowed to be negative, in which case the minus sign is prepended to the
+* output and we wrap the whole thing in brackets e.g. -(1 year 2 days).
+*
+* @param toFormat The PeriodOrDuration object to format
+*/
+var formatIntervalToHumanReadableIntervalString = (toFormat) => {
+	const formatPart = (value, unit) => {
+		if (value === 0) return "";
+		else if (value === 1) return `${value} ${unit} `;
+		else return `${value} ${unit}s `;
+	};
+	let output = "";
+	if (toFormat.type === "DATE") {
+		if (isZero(toFormat)) return "0 days";
+		output += formatPart(toFormat.interval.years, "year");
+		output += formatPart(toFormat.interval.months, "month");
+		output += formatPart(toFormat.interval.weeks, "week");
+		output += formatPart(toFormat.interval.days, "day");
+	} else {
+		if (isZero(toFormat)) return "0 seconds";
+		output += formatPart(toFormat.interval.hours, "hour");
+		output += formatPart(toFormat.interval.minutes, "minute");
+		const milliSecondsZero = toFormat.interval.milliseconds === 0;
+		if (toFormat.interval.seconds !== 0 || !milliSecondsZero) if (milliSecondsZero) output += formatPart(toFormat.interval.seconds, "second");
+		else output += `${toFormat.interval.seconds}.${toFormat.interval.milliseconds.toString().padStart(3, "0")} seconds `;
+	}
+	if (toFormat.interval.negative) output = `-(${output.trim()})`;
+	return output.trim();
+};
+var yearsPart = "(\\d+)\\s*y(?:ears?)?";
+var monthsPart = "(\\d+)\\s*m(?:o(?:nths?)?)?";
+var weeksPart = "(\\d+)\\s*w(?:eeks?)?";
+var daysPart = "(\\d+)\\s*d(?:ays?)?";
+var hoursPart = "(\\d+)\\s*h(?:ours?)?";
+var minutesPart = "(\\d+)\\s*m(?:in(?:s|utes?)?)?";
+var secondsPart = "(\\d+)(?:[,.](\\d{1,3}))?\\s*s(?:ec(?:s|onds?)?)?";
+/**
+* Matches a human readable period string, e.g. "1y 2mo 3weeks 4day" (each part is optional)
+*/
+var humanReadablePeriodRegex = new RegExp(`^(?:${yearsPart})?\\s*(?:${monthsPart})?\\s*(?:${weeksPart})?\\s*(?:${daysPart})?\\s*$`, "i");
+/**
+* Matches a human readable duration string, e.g. "1h 2m 3.456s" (each part is optional)
+*/
+var humanReadableDurationRegex = new RegExp(`^(?:${hoursPart})?\\s*(?:${minutesPart})?\\s*(?:${secondsPart})?$`, "i");
+/**
+* Matches a negative human readable period string, e.g. "-(1y 2mo 3weeks 4day)" (each part is optional)
+*/
+var negativeHumanReadablePeriodRegex = new RegExp(`^\\s*-\\s*\\(\\s*${humanReadablePeriodRegex.source.replace(/[$^]/g, "")}\\s*\\)\\s*$`, "i");
+/**
+* Matches a negative human readable period string with one field like "-1y" or "-1w"
+*/
+var negativeHumanReadablePeriodRegexWithSingleField = new RegExp(`^\\s*-\\s*(?:\\s*${yearsPart}|${monthsPart}|${weeksPart}|${daysPart})\\s*$`, "i");
+/**
+* Matches a negative human readable duration string, e.g. "-(1h 2m 3.456s)" (each part is optional)
+*/
+var negativeHumanReadableDurationRegex = new RegExp(`^\\s*-\\s*\\(\\s*${humanReadableDurationRegex.source.replace(/[$^]/g, "")}\\s*\\)\\s*$`, "i");
+/**
+* Matches a negative human readable duration string with one field like "-1h" or "-1.5s"
+*/
+var negativeHumanReadableDurationRegexWithSingleField = new RegExp(`^\\s*-\\s*(?:\\s*${hoursPart}|${minutesPart}|${secondsPart})\\s*$`, "i");
+/**
+* Try to parse a human readable interval string into an Interval object. Any parts not specified
+* are assumed to be zero. Note that the string must be either a period or a duration, not a mix of
+* both. So for example, "1y 2mo 3weeks 4day" is fine, as is "1h 2m 3.456s". However, "1y 2mo 1sec"
+* is not, since it's a mix of both.
+*
+* Negative intervals are allowed, although if multiple fields are provided the string must include
+* brackets, so "-(1y 2mo)" is also valid, as is "-5 seconds".
+*
+* The string is required to have at least some content, any string that is blank will throw an error.
+*
+* @param intervalString The human readable time string
+*/
+var parseHumanReadableIntervalString = (intervalString) => {
+	intervalString = intervalString?.trim();
+	if (!intervalString) throw new Error("Empty interval string");
+	const matchPositivePeriod = humanReadablePeriodRegex.exec(intervalString);
+	const matchNegativePeriod = negativeHumanReadablePeriodRegex.exec(intervalString) ?? negativeHumanReadablePeriodRegexWithSingleField.exec(intervalString);
+	const matchPositiveDuration = humanReadableDurationRegex.exec(intervalString);
+	const matchNegativeDuration = negativeHumanReadableDurationRegex.exec(intervalString) ?? negativeHumanReadableDurationRegexWithSingleField.exec(intervalString);
+	const matchPeriod = matchPositivePeriod ?? matchNegativePeriod;
+	const matchDuration = matchPositiveDuration ?? matchNegativeDuration;
+	const negative = (matchNegativePeriod ?? matchNegativeDuration) !== null;
+	if (matchDuration && matchPeriod) throw new Error("Ambiguous time format");
+	if (matchPeriod) return {
+		type: "DATE",
+		interval: extractPeriodFromRegexMatch(negative, matchPeriod)
+	};
+	else if (matchDuration) return {
+		type: "TIME",
+		interval: extractDurationFromRegexMatch(negative, matchDuration)
+	};
+	else throw new Error(`Invalid human readable time: ${intervalString}`);
+};
+/**
+* Check if the given string can be understood as a human readable duration or period string. The
+* type parameter specifies whether the string should be a date, time, or either.
+*
+* @param time the string to check
+* @param expectedType the type of the string - either "DATE", "TIME", or "ANY"
+*/
+var isValidHumanReadableIntervalString = (time, expectedType) => {
+	try {
+		const validationResult = parseHumanReadableIntervalString(time);
+		const actualType = validationResult.type;
+		const negative = validationResult.interval.negative;
+		if (actualType === expectedType || expectedType === "DATE_OR_TIME") return {
+			valid: true,
+			type: actualType,
+			negative
+		};
+		else return { valid: false };
+	} catch (_e) {
+		return { valid: false };
+	}
+};
+/**
+* Convert an ISO duration OR period string to an Interval object. So for example,
+* "P1Y2M3W4D" is fine, as is "PT1H2M3.456S". However, "P1Y2M3W4D1H2M3.456S" is not, since
+* it's a mix of both. We're more forgiving than the ISO standard, so we allow for missing parts.
+* Also, the string is allowed to be negative, so "-P1Y2M3W4D" is also valid.
+*
+* The string is required to have at least some content, so the strings "", "P", and "PT" are
+* considered invalid (also if they start with a -).
+*
+* @param isoString The ISO duration or period string.
+*/
+var parseISOIntervalString = (isoString) => {
+	isoString = isoString?.trim();
+	if ([
+		"",
+		"P",
+		"PT",
+		"-",
+		"-P",
+		"-PT"
+	].includes(isoString)) throw new Error("Empty ISO duration");
+	const periodRegex = /^-?P(?:(\d+)Y)?(?:(\d+)M)?(?:(\d+)W)?(?:(\d+)D)?$/;
+	const durationRegex = /^-?PT(?:(\d+)H)?(?:(\d+)M)?(?:(\d+)(?:[,.](\d{1,3}))?S)?$/;
+	const matchPeriod = periodRegex.exec(isoString);
+	const matchDuration = durationRegex.exec(isoString);
+	if (matchPeriod) return {
+		type: "DATE",
+		interval: extractPeriodFromRegexMatch(isoString.startsWith("-"), matchPeriod)
+	};
+	else if (matchDuration) return {
+		type: "TIME",
+		interval: extractDurationFromRegexMatch(isoString.startsWith("-"), matchDuration)
+	};
+	else throw new Error(`Invalid ISO duration: ${isoString}`);
+};
+/**
+* Check if the given string is a valid duration or period ISO string. The type parameter
+* specifies whether the string should be a date, time, or either.
+*
+* @param isoString the string to check
+* @param type the type of the string - either "DATE", "TIME", or "ANY"
+*/
+var isValidISOIntervalString = (isoString, type) => {
+	try {
+		const validationResult = parseISOIntervalString(isoString);
+		const actualType = validationResult.type;
+		const negative = validationResult.interval.negative;
+		if (actualType === type || type === "DATE_OR_TIME") return {
+			valid: true,
+			type: actualType,
+			negative
+		};
+		else return { valid: false };
+	} catch (_e) {
+		return { valid: false };
+	}
+};
+/**
+* Try to convert an interval string to an Interval object. The string can be either an ISO
+* duration/period string or a human readable string. If the string is not valid, an error is
+* thrown.
+*
+* @param time the time string, either ISO or human readable
+*/
+var parseGenericIntervalString = (time) => {
+	const validISO = isValidISOIntervalString(time, "DATE_OR_TIME");
+	const validHumanReadable = isValidHumanReadableIntervalString(time, "DATE_OR_TIME");
+	if (validISO.valid) return parseISOIntervalString(time);
+	else if (validHumanReadable.valid) return parseHumanReadableIntervalString(time);
+	else throw new Error(`Invalid interval string: ${time}`);
+};
+/**
+* Check if the given string is a valid interval string, either human readable or ISO. The type parameter
+* specifies whether the string should be a period, duration, or either.
+*
+* @param time the time string to check
+* @param type the type of the string - either "DATE", "TIME", or "ANY"
+*/
+var isValidIntervalString = (time, type) => {
+	const validISO = isValidISOIntervalString(time, type);
+	const validHumanReadable = isValidHumanReadableIntervalString(time, type);
+	if (validISO.valid) return validISO;
+	else if (validHumanReadable.valid) return validHumanReadable;
+	else return { valid: false };
+};
+//#endregion
+//#region src/numIntegerDigits.ts
+/**
+* Count the number of integer digits for a given number.
+*
+* @param input number.
+* @returns number of integer digits x has. 1234 = 4 but 1234.44 is also 4.
+*/
+var numIntegerDigits_default = (input) => Math.max(Math.floor(Math.log10(Math.abs(input))), 0) + 1;
+//#endregion
+//#region src/promise/createAbortablePromise.ts
+var AbortError = class extends Error {};
+/**
+* Helper to create an abortable promise. Returns an AbortController and a Function
+* that you can pass your async handler to. Whenever the AbortController signal is
+* aborted then the async handler's promise will reject with an AbortError
+*
+* Example:
+* ```
+* import { abortUtils } from "@knime/utils"
+* const myFetchCall = async (params...) => {...};
+*
+* try {
+*   const { runAbortablePromise, abortController } = createAbortablePromise(() =>
+*     myFetchCall(params...),
+*   );
+* } catch (e) {
+*   if (e instanceof abortUtils.AbortError) {
+*     console.info('ignore due to abort');
+*     return;
+*   }
+* }
+*
+* // somewhere else (while request is in-flight)
+* abortController.abort(new abortUtils.AbortError('reason here'))
+* ```
+*/
+var createAbortablePromise = () => {
+	const abortController = new AbortController();
+	const runAbortablePromise = (request) => {
+		return new Promise((resolve, reject) => {
+			const abortListener = ({ target }) => {
+				abortController.signal.removeEventListener("abort", abortListener);
+				const reason = target.reason;
+				reject(reason instanceof AbortError ? reason : new AbortError(reason));
+			};
+			request().then(resolve).catch((error) => {
+				if (error instanceof AbortError) return;
+				reject(error);
+			});
+			abortController.signal.addEventListener("abort", abortListener);
+		});
+	};
+	return {
+		abortController,
+		runAbortablePromise
+	};
+};
+//#endregion
+//#region src/promise/createUnwrappedPromise.ts
+var createUnwrappedPromise = () => {
+	let resolve = () => {};
+	let reject = () => {};
+	const promise = new Promise((res, rej) => {
+		resolve = res;
+		reject = rej;
+	});
+	return {
+		resolve,
+		reject,
+		promise
+	};
+};
+//#endregion
+//#region src/sleep.ts
+/**
+* Returns promise that resolves after ms.
+*/
 function sleep(ms) {
-  return new Promise((resolve) => setTimeout(resolve, ms));
+	return new Promise((resolve) => setTimeout(resolve, ms));
 }
-
-const DEFAULT_RETRY_DELAY_MS = 0;
-const DEFAULT_RETRY_COUNT = 5;
-async function retryPromise({
-  fn,
-  retryCount = DEFAULT_RETRY_COUNT,
-  retryDelayMS = DEFAULT_RETRY_DELAY_MS,
-  excludeError
-}) {
-  try {
-    return await fn();
-  } catch (error) {
-    if (excludeError?.(error)) {
-      throw error;
-    }
-    if (retryCount > 0) {
-      await sleep(retryDelayMS);
-      return await retryPromise({
-        fn,
-        retryCount: retryCount - 1,
-        retryDelayMS,
-        excludeError
-      });
-    }
-    throw error;
-  }
+/**
+* Helper to add retry capability to an async function
+* @param fn async function
+* @param retryCount max number of retries. defaults to 5
+* @param retryDelayMS delay in-between retries in millisecs. defaults to 0
+* @param excludeError predicate fn to exclude specific errors from causing a retry
+*/
+async function retryPromise({ fn, retryCount = 5, retryDelayMS = 0, excludeError }) {
+	try {
+		return await fn();
+	} catch (error) {
+		if (excludeError?.(error)) throw error;
+		if (retryCount > 0) {
+			await sleep(retryDelayMS);
+			return await retryPromise({
+				fn,
+				retryCount: retryCount - 1,
+				retryDelayMS,
+				excludeError
+			});
+		}
+		throw error;
+	}
 }
-
-const index = /*#__PURE__*/Object.freeze(/*#__PURE__*/Object.defineProperty({
-  __proto__: null,
-  AbortError,
-  DEFAULT_RETRY_COUNT,
-  DEFAULT_RETRY_DELAY_MS,
-  createAbortablePromise,
-  createUnwrappedPromise,
-  retryPromise
-}, Symbol.toStringTag, { value: 'Module' }));
-
-const ALLOWED_TAGS = [
-  "p",
-  "div",
-  "h1",
-  "h2",
-  "h3",
-  "h4",
-  "h5",
-  "h6",
-  "ul",
-  "ol",
-  "li",
-  "blockquote",
-  "b",
-  "i",
-  "s",
-  "u",
-  "sup",
-  "sub",
-  "ins",
-  "del",
-  "strong",
-  "strike",
-  "tt",
-  "code",
-  "big",
-  "small",
-  "br",
-  "span",
-  "em"
+//#endregion
+//#region src/promise/index.ts
+var promise_exports = /* @__PURE__ */ __exportAll({
+	AbortError: () => AbortError,
+	DEFAULT_RETRY_COUNT: () => 5,
+	DEFAULT_RETRY_DELAY_MS: () => 0,
+	createAbortablePromise: () => createAbortablePromise,
+	createUnwrappedPromise: () => createUnwrappedPromise,
+	retryPromise: () => retryPromise
+});
+//#endregion
+//#region src/sanitization.ts
+var ALLOWED_TAGS = [
+	"p",
+	"div",
+	"h1",
+	"h2",
+	"h3",
+	"h4",
+	"h5",
+	"h6",
+	"ul",
+	"ol",
+	"li",
+	"blockquote",
+	"b",
+	"i",
+	"s",
+	"u",
+	"sup",
+	"sub",
+	"ins",
+	"del",
+	"strong",
+	"strike",
+	"tt",
+	"code",
+	"big",
+	"small",
+	"br",
+	"span",
+	"em"
 ];
-const sanitizeHTML = (rawHTML, options = {
-  allowStyleAttribute: false,
-  allowHyperlinks: false
+/**
+* Sanitizes Raw HTML and only allow specific tags to be used, as per OWASP standards.
+* @param rawHTML
+* @param options.allowStyleAttribute - Allow the style attribute on elements
+* @param options.allowHyperlinks - Allow anchor tags with href attribute
+* @returns sanitized html
+*/
+var sanitizeHTML = (rawHTML, options = {
+	allowStyleAttribute: false,
+	allowHyperlinks: false
 }) => {
-  const { allowStyleAttribute, allowHyperlinks } = options;
-  const ALLOWED_ATTR = [
-    ...allowStyleAttribute ? ["style"] : [],
-    ...allowHyperlinks ? ["href"] : []
-  ];
-  const allowedTags = allowHyperlinks ? [...ALLOWED_TAGS, "a"] : ALLOWED_TAGS;
-  return DomPurify.sanitize(rawHTML, {
-    ALLOWED_TAGS: allowedTags,
-    ALLOWED_ATTR
-  });
-};
-const stripHTML = (rawHTML) => {
-  return DomPurify.sanitize(rawHTML, { ALLOWED_TAGS: [], ALLOWED_ATTR: [] });
-};
-const sanitization = { sanitizeHTML, stripHTML };
-
-const defaultMaxLength = 160;
-const truncateString = (string = "", maxLength = defaultMaxLength) => {
-  const dots = string.length > maxLength ? "…" : "";
-  return `${string.substring(0, maxLength - 1)}${dots}`;
-};
-
-const getFileExtension = (nameOrPath) => {
-  const basename = nameOrPath.split(/[\\/]/).pop() ?? "";
-  const parts = basename.split(".");
-  if (basename === "" || parts.length === 1) {
-    return "";
-  }
-  return parts.at(-1) ?? "";
-};
-const KNAR = Object.freeze({
-  extension: "knar",
-  mimeType: "application/vnd.knime.workflow-group+zip",
-  matches(file) {
-    const extension = getFileExtension(file.name);
-    return extension === this.extension;
-  }
+	const { allowStyleAttribute, allowHyperlinks } = options;
+	const ALLOWED_ATTR = [...allowStyleAttribute ? ["style"] : [], ...allowHyperlinks ? ["href"] : []];
+	const allowedTags = allowHyperlinks ? [...ALLOWED_TAGS, "a"] : ALLOWED_TAGS;
+	return DomPurify.sanitize(rawHTML, {
+		ALLOWED_TAGS: allowedTags,
+		ALLOWED_ATTR
+	});
+};
+/**
+* Removes any HTML tag from the input string. Keeps HTML entities
+* (e.g   because these can be considered plain text)
+* @param rawHTML
+* @returns plain text
+*/
+var stripHTML = (rawHTML) => {
+	return DomPurify.sanitize(rawHTML, {
+		ALLOWED_TAGS: [],
+		ALLOWED_ATTR: []
+	});
+};
+var sanitization = {
+	sanitizeHTML,
+	stripHTML
+};
+//#endregion
+//#region src/truncateString.ts
+var defaultMaxLength = 160;
+var truncateString_default = (string = "", maxLength = defaultMaxLength) => {
+	const dots = string.length > maxLength ? "…" : "";
+	return `${string.substring(0, maxLength - 1)}${dots}`;
+};
+//#endregion
+//#region src/fileExtensions.ts
+/**
+* Gets the file extension
+* @param nameOrPath can take a full file name (e.g "file.txt") or a path to a file
+* (e.g "file://path/to/file.txt" OR "/path/to/file.txt")
+* @returns just the file extension (e.g "txt")
+*/
+var getFileExtension = (nameOrPath) => {
+	const basename = nameOrPath.split(/[\\/]/).pop() ?? "";
+	const parts = basename.split(".");
+	if (basename === "" || parts.length === 1) return "";
+	return parts.at(-1) ?? "";
+};
+/**
+* Metadata for .knar files, which corresponds to exported KNIME Workflow Groups
+* or Components
+*/
+var KNAR = Object.freeze({
+	extension: "knar",
+	mimeType: "application/vnd.knime.workflow-group+zip",
+	matches(file) {
+		return getFileExtension(file.name) === this.extension;
+	}
 });
-const KNWF = Object.freeze({
-  extension: "knwf",
-  mimeType: "application/vnd.knime.workflow+zip",
-  matches(file) {
-    const extension = getFileExtension(file.name);
-    return extension === this.extension;
-  },
-  /**
-   * Gets the name of a .knwf file without the extension. If the file is not
-   * matched as a .knwf file then this function will return the default value,
-   * which is empty string ("") if param is not provided
-   */
-  getNameOrDefault(file, defaultValue = "") {
-    if (!this.matches(file)) {
-      return defaultValue;
-    }
-    return file.name.replace(`.${this.extension}`, "");
-  }
+/**
+* Metadata for .knwf files, which corresponds to exported KNIME Workflows
+*/
+var KNWF = Object.freeze({
+	extension: "knwf",
+	mimeType: "application/vnd.knime.workflow+zip",
+	matches(file) {
+		return getFileExtension(file.name) === this.extension;
+	},
+	/**
+	* Gets the name of a .knwf file without the extension. If the file is not
+	* matched as a .knwf file then this function will return the default value,
+	* which is empty string ("") if param is not provided
+	*/
+	getNameOrDefault(file, defaultValue = "") {
+		if (!this.matches(file)) return defaultValue;
+		return file.name.replace(`.${this.extension}`, "");
+	}
 });
-const knimeFileFormats = { KNAR, KNWF };
-const getFileMimeType = (file) => {
-  const DEFAULT_MIMETYPE = "application/octet-stream";
-  const extension = getFileExtension(file.name);
-  if (!extension) {
-    return DEFAULT_MIMETYPE;
-  }
-  if (KNWF.matches(file)) {
-    return KNWF.mimeType;
-  }
-  if (KNAR.matches(file)) {
-    return KNAR.mimeType;
-  }
-  if (!file.type) {
-    return DEFAULT_MIMETYPE;
-  }
-  return file.type;
-};
-
-const hotkeyPlatform = {
-  MAC_OS: "macOS",
-  OTHER: "other"
+var knimeFileFormats = {
+	KNAR,
+	KNWF
+};
+/**
+* Gets the mime type from a given file. Defaults to `application/octet-stream`
+* if mimeType cannot be detected
+* @param file File
+* @returns mimeType
+*/
+var getFileMimeType = (file) => {
+	const DEFAULT_MIMETYPE = "application/octet-stream";
+	if (!getFileExtension(file.name)) return DEFAULT_MIMETYPE;
+	if (KNWF.matches(file)) return KNWF.mimeType;
+	if (KNAR.matches(file)) return KNAR.mimeType;
+	if (!file.type) return DEFAULT_MIMETYPE;
+	return file.type;
+};
+//#endregion
+//#region src/hotkeys/enums.ts
+/**
+* Platforms that influence how modifier keys are rendered. macOS substitutes
+* dedicated glyphs (`⌘`, `⌥`, `⇧`, …), every other platform uses the textual
+* rendering (`Ctrl`, `Alt`, `Shift`, …).
+*/
+var hotkeyPlatform = {
+	MAC_OS: "macOS",
+	OTHER: "other"
 };
 Object.values(hotkeyPlatform);
+//#endregion
+//#region src/platform/navigator.ts
+var navigator_exports = /* @__PURE__ */ __exportAll({
+	isMac: () => isMac,
+	isWindows: () => isWindows
+});
+/**
+*
+* @returns true if the platform of the user is Mac
+*/
+var isMac = () => navigator?.userAgent?.toLowerCase()?.includes("mac");
+/**
+*
+* @returns true if the platform of the user is Windows
+*/
+var isWindows = () => navigator?.userAgent?.toLowerCase()?.includes("windows");
+//#endregion
+//#region src/hotkeys/format.ts
+var globalKeyMap = {
+	ArrowUp: "↑",
+	ArrowDown: "↓",
+	ArrowLeft: "←",
+	ArrowRight: "→",
+	Enter: "↵",
+	" ": "Space",
+	CtrlOrCmd: "Ctrl"
+};
+var MacOSkeyMap = {
+	Shift: "⇧",
+	Delete: "⌫",
+	CtrlOrCmd: "⌘",
+	Ctrl: "⌃",
+	Alt: "⌥",
+	Enter: "↩"
+};
+/**
+* Returns a string representation of a single hotkey. Replaces some special key names with symbols.
+*
+* By default the platform is auto-detected from the user agent via `isMac()`.
+* Pass `platform` to force a specific platform's glyphs — useful for SSR,
+* tests, or rendering multiple platforms on the same page.
+*/
+var formatHotkey = (hotkey, platform) => {
+	/**
+	* Returns the symbol corresponding to the `key` based on the given
+	* `formatMap`. Otherwise, if not found, returns the same `key` value given
+	*/
+	const mapSymbols = (formatMap) => (key) => formatMap[key] ?? key;
+	/**
+	* Pipe function implementation. Receives a list of functions to execute in order
+	* and will pipe the parameter passed at the end to each function returning the final output
+	*/
+	const pipe = (...fns) => fns.reduce((f, g) => (arg) => g(f(arg)), (arg) => arg);
+	const macKeyFormatter = pipe(mapSymbols(MacOSkeyMap), mapSymbols(globalKeyMap));
+	const generalKeyFormatter = mapSymbols(globalKeyMap);
+	return (platform === void 0 ? isMac() : platform === hotkeyPlatform.MAC_OS) ? macKeyFormatter(hotkey) : generalKeyFormatter(hotkey);
+};
+var getDefaultSeparator = () => isMac() ? " " : "+";
+/**
+* Returns a string representation of a list of hotkeys. Replaces some special key names with symbols
+*/
+var formatHotkeys = (hotkeys, getSeparator = getDefaultSeparator) => hotkeys.map((hotkey) => formatHotkey(hotkey)).join(getSeparator());
+/**
+* Appends a formatted hotkey shortcut to the given string. Useful for tooltips
+*/
+var textWithHotkeys = (text, hotkeys) => {
+	return `${text} – ${formatHotkeys(hotkeys)}`;
+};
+//#endregion
+//#region src/hotkeys/match.ts
+/**
+* Checks whether a pressed `Digit` key falls within a numeric hotkey range such
+* as `1-9`.
+* @param keyCode - The `KeyboardEvent.code` to check (e.g. `Digit5`).
+* @param hotkey - The hotkey token, expected to be a single-digit range like `1-9`.
+* @returns True if the pressed digit lies within the inclusive range.
+*/
+var isDigitKeyInRange = (keyCode, hotkey) => {
+	if (hotkey.length !== 3 || !keyCode?.startsWith("Digit")) return false;
+	const keyNumber = Number(keyCode.slice(5));
+	const [lower, upper] = hotkey.split("-");
+	return Boolean(lower) && Boolean(upper) && Number.parseInt(lower, 10) <= keyNumber && keyNumber <= Number.parseInt(upper, 10);
+};
+/**
+* Checks whether a keyboard event matches a hotkey definition. The last token is
+* treated as the character; any preceding tokens are modifiers. The special
+* `CtrlOrCmd` modifier resolves to the platform's primary modifier (Meta/`⌘` on
+* macOS, Ctrl elsewhere).
+* @param event - The keyboard event to check.
+* @param hotkeys - The ordered hotkey tokens (modifiers followed by the character).
+* @returns True if the event matches the given hotkey, otherwise false.
+*/
+var match = (event, hotkeys) => {
+	const { key, code, metaKey, ctrlKey, shiftKey, altKey } = event;
+	const modifiers = hotkeys.slice();
+	const character = modifiers.pop() ?? "";
+	const ctrlOrMeta = isMac() ? "Meta" : "Ctrl";
+	const platformModifiers = new Set(modifiers.map((modifier) => modifier === "CtrlOrCmd" ? ctrlOrMeta : modifier));
+	const metaMatches = Boolean(metaKey) === platformModifiers.has("Meta");
+	const ctrlMatches = Boolean(ctrlKey) === platformModifiers.has("Ctrl");
+	const shiftMatches = Boolean(shiftKey) === platformModifiers.has("Shift");
+	const altMatches = Boolean(altKey) === platformModifiers.has("Alt");
+	const keysMatch = key.toUpperCase() === character.toUpperCase() || character.includes("-") && isDigitKeyInRange(code, character) || isMac() && character === "Delete" && key === "Backspace";
+	return metaMatches && ctrlMatches && shiftMatches && altMatches && keysMatch;
+};
+//#endregion
+//#region src/hotkeys/modifiers.ts
+/**
+* Checks if any modifier key (Ctrl, Meta, Alt, or Shift) is pressed.
+* @param event - The keyboard event to check.
+* @returns True if a modifier key is pressed, otherwise false.
+*/
+var isModifierKeyPressed = (event) => {
+	return event.ctrlKey || event.metaKey || event.altKey || event.shiftKey;
+};
+/**
+* Checks if a specific key (or keys) were pressed without any modifier keys.
+* @param event - The keyboard event to check.
+* @param keys - The key or keys to check for.
+* @returns True if the specified key(s) were pressed without modifiers, otherwise false.
+*/
+var isKeyWithoutModifiers = (event, keys) => {
+	return (Array.isArray(keys) ? keys : [keys]).includes(event.key) && !isModifierKeyPressed(event);
+};
+/**
+* Returns the name of the primary modifier key for the current platform.
+*/
+var getMetaOrCtrlKey = () => {
+	return isMac() ? "metaKey" : "ctrlKey";
+};
+//#endregion
+//#region src/hotkeys/index.ts
+/**
+* Grouped keyboard-shortcut helpers, exposed as a single namespace for
+* ergonomic access (e.g. `hotkeys.formatHotkey`).
+*/
+var hotkeys = {
+	formatHotkeys,
+	formatHotkey,
+	getDefaultSeparator,
+	hotkeyPlatform,
+	textWithHotkeys,
+	match
+};
+//#endregion
+export { capitalize, caseFormatter, debounce, filters, formatDateString, formatDateTimeString, formatFileSize, formatLocalDateTimeString, formatTimeString, getDeepActiveElement, getFileExtension, getFileMimeType, localTimezone_default as getLocalTimeZone, getMetaOrCtrlKey, getWrappedAroundIndex_default as getWrappedAroundIndex, hotkeys, intervalUtils_exports as intervalUtils, isAfterMaxDate, isBeforeMinDate, isKeyWithoutModifiers, isModifierKeyPressed, knimeFileFormats, match, navigator_exports as navigatorUtils, numIntegerDigits_default as numIntegerDigits, promise_exports as promise, sanitization, sleep, truncateString_default as truncateString, updateDate_default as updateDate, updateTime_default as updateTime };
 
-const isMac = () => navigator?.userAgent?.toLowerCase()?.includes("mac");
-const isWindows = () => navigator?.userAgent?.toLowerCase()?.includes("windows");
-
-const navigator$1 = /*#__PURE__*/Object.freeze(/*#__PURE__*/Object.defineProperty({
-  __proto__: null,
-  isMac,
-  isWindows
-}, Symbol.toStringTag, { value: 'Module' }));
-
-const globalKeyMap = {
-  ArrowUp: "↑",
-  ArrowDown: "↓",
-  ArrowLeft: "←",
-  ArrowRight: "→",
-  Enter: "↵",
-  " ": "Space",
-  // we use event.key and there space is an actual space not the code "Space"
-  CtrlOrCmd: "Ctrl"
-};
-const MacOSkeyMap = {
-  Shift: "⇧",
-  Delete: "⌫",
-  CtrlOrCmd: "⌘",
-  Ctrl: "⌃",
-  Alt: "⌥",
-  Enter: "↩"
-};
-const formatHotkey = (hotkey, platform) => {
-  const mapSymbols = (formatMap) => (key) => formatMap[key] ?? key;
-  const pipe = (...fns) => fns.reduce(
-    (f, g) => (arg) => g(f(arg)),
-    (arg) => arg
-  );
-  const macKeyFormatter = pipe(
-    mapSymbols(MacOSkeyMap),
-    mapSymbols(globalKeyMap)
-  );
-  const generalKeyFormatter = mapSymbols(globalKeyMap);
-  const useMacFormatter = platform === void 0 ? isMac() : platform === hotkeyPlatform.MAC_OS;
-  return useMacFormatter ? macKeyFormatter(hotkey) : generalKeyFormatter(hotkey);
-};
-const getDefaultSeparator = () => isMac() ? " " : "+";
-const formatHotkeys = (hotkeys, getSeparator = getDefaultSeparator) => hotkeys.map((hotkey) => formatHotkey(hotkey)).join(getSeparator());
-const textWithHotkeys = (text, hotkeys) => {
-  return `${text} – ${formatHotkeys(hotkeys)}`;
-};
-
-const isDigitKeyInRange = (keyCode, hotkey) => {
-  const digitRangeLength = 3;
-  if (hotkey.length !== digitRangeLength || !keyCode?.startsWith("Digit")) {
-    return false;
-  }
-  const keyNumber = Number(keyCode.slice("Digit".length));
-  const [lower, upper] = hotkey.split("-");
-  return Boolean(lower) && Boolean(upper) && Number.parseInt(lower, 10) <= keyNumber && keyNumber <= Number.parseInt(upper, 10);
-};
-const match = (event, hotkeys) => {
-  const { key, code, metaKey, ctrlKey, shiftKey, altKey } = event;
-  const modifiers = hotkeys.slice();
-  const character = modifiers.pop() ?? "";
-  const ctrlOrMeta = isMac() ? "Meta" : "Ctrl";
-  const platformModifiers = new Set(
-    modifiers.map(
-      (modifier) => modifier === "CtrlOrCmd" ? ctrlOrMeta : modifier
-    )
-  );
-  const metaMatches = Boolean(metaKey) === platformModifiers.has("Meta");
-  const ctrlMatches = Boolean(ctrlKey) === platformModifiers.has("Ctrl");
-  const shiftMatches = Boolean(shiftKey) === platformModifiers.has("Shift");
-  const altMatches = Boolean(altKey) === platformModifiers.has("Alt");
-  const keysMatch = (
-    // keys are matched case insensitively
-    key.toUpperCase() === character.toUpperCase() || character.includes("-") && isDigitKeyInRange(code, character) || // on mac 'backspace' can be used instead of delete
-    isMac() && character === "Delete" && key === "Backspace"
-  );
-  return metaMatches && ctrlMatches && shiftMatches && altMatches && keysMatch;
-};
-
-const isModifierKeyPressed = (event) => {
-  return event.ctrlKey || event.metaKey || event.altKey || event.shiftKey;
-};
-const isKeyWithoutModifiers = (event, keys) => {
-  const keyList = Array.isArray(keys) ? keys : [keys];
-  return keyList.includes(event.key) && !isModifierKeyPressed(event);
-};
-const getMetaOrCtrlKey = () => {
-  return isMac() ? "metaKey" : "ctrlKey";
-};
-
-const hotkeys = {
-  formatHotkeys,
-  formatHotkey,
-  getDefaultSeparator,
-  hotkeyPlatform,
-  textWithHotkeys,
-  match
-};
-
-export { capitalize, caseFormatter, debounce, filters, formatDateString, formatDateTimeString, formatFileSize, formatLocalDateTimeString, formatTimeString, getDeepActiveElement, getFileExtension, getFileMimeType, getLocalTimeZone, getMetaOrCtrlKey, getWrappedAroundIndex, hotkeys, intervalUtils, isAfterMaxDate, isBeforeMinDate, isKeyWithoutModifiers, isModifierKeyPressed, knimeFileFormats, match, navigator$1 as navigatorUtils, numIntegerDigits, index as promise, sanitization, sleep, truncateString, updateDate, updateTime };
-//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map