@knime/utils 1.11.1 → 1.12.0

package/dist/index.js

@@ -0,0 +1,751 @@
+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 };
+};
+
+function sleep(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;
+  }
+}
+
+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"
+];
+const 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 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}`, "");
+  }
+});
+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"
+};
+Object.values(hotkeyPlatform);
+
+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 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,
+  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