'use strict';

const adoptedStyleSheets = require('adopted-style-sheets');
const querySelectorAllShadowRoot = require('query-selector-all-shadow-root');
const querySelectorShadowRoot = require('query-selector-shadow-root');
const rgbaConvert = require('rgba-convert');
const wcagContrast = require('wcag-contrast');
const colorRgba = require('color-rgba');

function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'default' in e ? e.default : e; }

const rgbaConvert__default = /*#__PURE__*/_interopDefaultCompat(rgbaConvert);
const colorRgba__default = /*#__PURE__*/_interopDefaultCompat(colorRgba);

var KeyEnum = /* @__PURE__ */ ((KeyEnum2) => {
  KeyEnum2[KeyEnum2["error"] = 0] = "error";
  KeyEnum2[KeyEnum2["warning"] = 1] = "warning";
  KeyEnum2[KeyEnum2["info"] = 2] = "info";
  KeyEnum2[KeyEnum2["success"] = 3] = "success";
  KeyEnum2[KeyEnum2["message"] = 4] = "message";
  KeyEnum2[KeyEnum2["close"] = 5] = "close";
  KeyEnum2[KeyEnum2["form-description"] = 6] = "form-description";
  KeyEnum2[KeyEnum2["of"] = 7] = "of";
  KeyEnum2[KeyEnum2["characters"] = 8] = "characters";
  KeyEnum2[KeyEnum2["new"] = 9] = "new";
  KeyEnum2[KeyEnum2["no-entries"] = 10] = "no-entries";
  KeyEnum2[KeyEnum2["change-order"] = 11] = "change-order";
  KeyEnum2[KeyEnum2["action-running"] = 12] = "action-running";
  KeyEnum2[KeyEnum2["action-done"] = 13] = "action-done";
  KeyEnum2[KeyEnum2["page-first"] = 14] = "page-first";
  KeyEnum2[KeyEnum2["page-back"] = 15] = "page-back";
  KeyEnum2[KeyEnum2["page-next"] = 16] = "page-next";
  KeyEnum2[KeyEnum2["page-last"] = 17] = "page-last";
  KeyEnum2[KeyEnum2["entries-per-site"] = 18] = "entries-per-site";
  KeyEnum2[KeyEnum2["page-current"] = 19] = "page-current";
  KeyEnum2[KeyEnum2["page-selected"] = 20] = "page-selected";
  KeyEnum2[KeyEnum2["page-per-site"] = 21] = "page-per-site";
  KeyEnum2[KeyEnum2["logo-description"] = 22] = "logo-description";
  KeyEnum2[KeyEnum2["open-link-in-tab"] = 23] = "open-link-in-tab";
  KeyEnum2[KeyEnum2["kolibri-logo"] = 24] = "kolibri-logo";
  return KeyEnum2;
})(KeyEnum || {});

var TagEnum = /* @__PURE__ */ ((TagEnum2) => {
  TagEnum2[TagEnum2["abbr"] = 0] = "abbr";
  TagEnum2[TagEnum2["accordion"] = 1] = "accordion";
  TagEnum2[TagEnum2["accordion-group"] = 2] = "accordion-group";
  TagEnum2[TagEnum2["alert"] = 3] = "alert";
  TagEnum2[TagEnum2["avatar"] = 4] = "avatar";
  TagEnum2[TagEnum2["badge"] = 5] = "badge";
  TagEnum2[TagEnum2["breadcrumb"] = 6] = "breadcrumb";
  TagEnum2[TagEnum2["button"] = 7] = "button";
  TagEnum2[TagEnum2["button-group"] = 8] = "button-group";
  TagEnum2[TagEnum2["button-link"] = 9] = "button-link";
  TagEnum2[TagEnum2["card"] = 10] = "card";
  TagEnum2[TagEnum2["details"] = 11] = "details";
  TagEnum2[TagEnum2["form"] = 12] = "form";
  TagEnum2[TagEnum2["heading"] = 13] = "heading";
  TagEnum2[TagEnum2["icon"] = 14] = "icon";
  TagEnum2[TagEnum2["image"] = 15] = "image";
  TagEnum2[TagEnum2["indented-text"] = 16] = "indented-text";
  TagEnum2[TagEnum2["input-checkbox"] = 17] = "input-checkbox";
  TagEnum2[TagEnum2["input-color"] = 18] = "input-color";
  TagEnum2[TagEnum2["input-date"] = 19] = "input-date";
  TagEnum2[TagEnum2["input-email"] = 20] = "input-email";
  TagEnum2[TagEnum2["input-file"] = 21] = "input-file";
  TagEnum2[TagEnum2["input-number"] = 22] = "input-number";
  TagEnum2[TagEnum2["input-password"] = 23] = "input-password";
  TagEnum2[TagEnum2["input-radio"] = 24] = "input-radio";
  TagEnum2[TagEnum2["input-range"] = 25] = "input-range";
  TagEnum2[TagEnum2["input-text"] = 26] = "input-text";
  TagEnum2[TagEnum2["kolibri"] = 27] = "kolibri";
  TagEnum2[TagEnum2["link"] = 28] = "link";
  TagEnum2[TagEnum2["link-button"] = 29] = "link-button";
  TagEnum2[TagEnum2["link-group"] = 30] = "link-group";
  TagEnum2[TagEnum2["logo"] = 31] = "logo";
  TagEnum2[TagEnum2["modal"] = 32] = "modal";
  TagEnum2[TagEnum2["nav"] = 33] = "nav";
  TagEnum2[TagEnum2["pagination"] = 34] = "pagination";
  TagEnum2[TagEnum2["progress"] = 35] = "progress";
  TagEnum2[TagEnum2["select"] = 36] = "select";
  TagEnum2[TagEnum2["separator"] = 37] = "separator";
  TagEnum2[TagEnum2["skip-nav"] = 38] = "skip-nav";
  TagEnum2[TagEnum2["spin"] = 39] = "spin";
  TagEnum2[TagEnum2["split-button"] = 40] = "split-button";
  TagEnum2[TagEnum2["symbol"] = 41] = "symbol";
  TagEnum2[TagEnum2["table"] = 42] = "table";
  TagEnum2[TagEnum2["table-stateless"] = 43] = "table-stateless";
  TagEnum2[TagEnum2["table-stateful"] = 44] = "table-stateful";
  TagEnum2[TagEnum2["tabs"] = 45] = "tabs";
  TagEnum2[TagEnum2["textarea"] = 46] = "textarea";
  TagEnum2[TagEnum2["toast-container"] = 47] = "toast-container";
  TagEnum2[TagEnum2["toolbar"] = 48] = "toolbar";
  TagEnum2[TagEnum2["tooltip"] = 49] = "tooltip";
  TagEnum2[TagEnum2["tree"] = 50] = "tree";
  TagEnum2[TagEnum2["tree-item"] = 51] = "tree-item";
  return TagEnum2;
})(TagEnum || {});

const alertTypeOptions = ["default", "info", "success", "warning", "error"];
const alertVariantOptions = ["card", "msg"];

const inputCheckboxVariantOptions = ["button", "default", "switch"];

const koliBriQuoteVariantOptions = ["block", "inline"];

const cssResizeOptions = ["both", "horizontal", "vertical", "none"];

let WINDOW = null;
let DOCUMENT = null;
const getWindow = () => WINDOW || typeof window === "undefined" ? null : window;
const setWindow = (value) => {
  WINDOW = value;
};
const getDocument = () => DOCUMENT || typeof getWindow().document === "undefined" ? null : getWindow().document;
const setDocument = (value) => {
  DOCUMENT = value;
};
let DEV_MODE = null;
let EXPERIMENTAL_MODE = null;
let COLOR_CONTRAST_ANALYSIS = null;
const getDevMode = () => DEV_MODE === true;
const setDevMode = (value) => {
  DEV_MODE = value;
};
const getExperimentalMode = () => EXPERIMENTAL_MODE === true;
const setExperimentalMode = (value) => {
  EXPERIMENTAL_MODE = value;
};
const getColorContrastAnalysis = () => COLOR_CONTRAST_ANALYSIS === true;
const setColorContrastAnalysis = (value) => {
  COLOR_CONTRAST_ANALYSIS = value;
};
const LOG_STYLE = "color: white; background: #666; font-weight: bold; padding: .25em .5em; border-radius: 3px; border: 1px solid #000";
const mapToArray = (msg) => {
  return Array.isArray(msg) ? msg : [msg];
};
const getLogLabel = (label) => {
  return `%c${label}`;
};
const handleClassifier = (label, classifier) => {
  if (typeof classifier === "string" && classifier.length > 0) {
    return `${getLogLabel(label)} | ${classifier}`;
  } else {
    return getLogLabel(label);
  }
};
const getShield = (label, options) => {
  return [handleClassifier(label, options?.classifier), `${LOG_STYLE};${options?.overwriteStyle || ""}`];
};
const isDevModeOrForceLog = (devMode, forceLog) => devMode() || forceLog === true;
class Logger {
  constructor(label, devMode) {
    this.label = label;
    this.devMode = devMode;
  }
  debug(msg, options) {
    if (isDevModeOrForceLog(this.devMode, options?.forceLog)) {
      console.debug(...getShield(this.label, options), ...mapToArray(msg));
    }
  }
  info(msg, options) {
    if (isDevModeOrForceLog(this.devMode, options?.forceLog)) {
      console.info(...getShield(this.label, options), ...mapToArray(msg));
    }
  }
  trace(msg, options) {
    if (isDevModeOrForceLog(this.devMode, options?.forceLog)) {
      console.trace(...getShield(this.label, options), ...mapToArray(msg));
    }
  }
  warn(msg, options) {
    if (isDevModeOrForceLog(this.devMode, options?.forceLog)) {
      console.warn(...getShield(this.label, options), ...mapToArray(msg));
    }
  }
  error(msg, options) {
    if (isDevModeOrForceLog(this.devMode, options?.forceLog)) {
      console.error(...getShield(this.label, options), ...mapToArray(msg));
    }
  }
  throw(msg, options) {
    if (isDevModeOrForceLog(this.devMode, options?.forceLog)) {
      throw new Error(...getShield(this.label, options), ...mapToArray(msg));
    }
  }
}
const Log = new Logger("KoliBri", getDevMode);

const a11yCache = /* @__PURE__ */ new Set();
const a11yHint = (msg, options) => {
  if (a11yCache.has(msg) === false || !!options?.force) {
    a11yCache.add(msg);
    Log.debug([msg].concat(options?.details || []), {
      classifier: `\u270B a11y`,
      forceLog: !!options?.force,
      overwriteStyle: "; background-color: #09f"
    });
  }
};
const devCache = /* @__PURE__ */ new Set();
const devHint = (msg, options) => {
  if (devCache.has(msg) === false || !!options?.force) {
    devCache.add(msg);
    Log.debug([msg].concat(options?.details || []), {
      classifier: `\u{1F4BB} dev`,
      forceLog: !!options?.force,
      overwriteStyle: "; background-color: #f09"
    });
  }
};
const devWarning = (msg, options) => {
  if (devCache.has(msg) === false || !!options?.force) {
    devCache.add(msg);
    Log.warn([msg].concat(options?.details || []), {
      classifier: `\u26A0\uFE0F dev`,
      forceLog: !!options?.force,
      overwriteStyle: "; background-color: #f09"
    });
  }
};
const featureCache = /* @__PURE__ */ new Set();
const featureHint = (msg, done = false, options) => {
  if (featureCache.has(msg) === false || !!options?.force) {
    featureCache.add(msg);
    msg += done === true ? " \u2705" : "";
    Log.debug([msg].concat(options?.details || []), {
      classifier: `\u{1F31F} feature`,
      forceLog: !!options?.force,
      overwriteStyle: "; background-color: #309"
    });
  }
};
devHint(
  `Wir freuen uns \xFCber jedes Feedback, Kommentare, Screenshots oder Demo-Links von einer auf KoliBri-basierenden Anwendung (kolibri@itzbund.de). Vielen Dank!`
);
const uiUxCache = /* @__PURE__ */ new Set();
const uiUxHint = (msg, options) => {
  if (uiUxCache.has(msg) === false || !!options?.force) {
    uiUxCache.add(msg);
    Log.debug([msg].concat(options?.details || []), {
      classifier: `\u{1F4D1} ui/ux`,
      forceLog: !!options?.force,
      overwriteStyle: "; background-color: #060;"
    });
  }
};
const a11yHintDisabled = () => {
  a11yHint(
    `"Disabled" schr\xE4nkt die Zug\xE4nglichkeit und Sichtbarkeit ein. Wir empfehlen aus Sicht der Barrierefreiheit readonly- statt disabled-Attribut zu verwenden.
- https://uxdesign.cc/is-it-ok-to-grey-out-disabled-buttons-8afa74a0fae`
  );
};
const a11yHintLabelingLandmarks = (value) => {
  if (typeof value !== "string" || value === "") {
    a11yHint(
      `Manche Strukturelemente, wie bspw. der nav-Tag, k\xF6nnen mehrfach in einer Webseite verwendet werden. Damit die gleichnamigen Strukturelemente voneinander unterschieden werden k\xF6nnen, ist es erforderlich ein Aria-Label zu setzen.
- https://developer.mozilla.org/en-US/docs/Web/Accessibility/ARIA/Roles/Navigation_Role#accessibility_concerns`
    );
  }
};
const uiUxHintMillerscheZahl = (className, length = 8) => {
  if (length > 7) {
    uiUxHint(
      `[${className}] Innerhalb von Navigationsstrukturen wird empfohlen nicht mehr als 7 Men\xFCpunkte zu verwenden.

Links:
- https://de.ryte.com/wiki/Millersche_Zahl
- https://de.wikipedia.org/wiki/Millersche_Zahl`
    );
  }
};

const getContrastYIQ = (r, g, b) => {
  const yiq = (r * 299 + g * 587 + b * 114) / 1e3;
  return yiq >= 128 ? -1 : 1;
};
const calcColorContrast = (baseColor, contrastColor, ratio, dir = 1) => {
  const color = [
    Math.max(Math.min(Math.round(contrastColor[0] + dir * Math.max(1, contrastColor[0] / 100)), 255), 0),
    Math.max(Math.min(Math.round(contrastColor[1] + dir * Math.max(1, contrastColor[1] / 100)), 255), 0),
    Math.max(Math.min(Math.round(contrastColor[2] + dir * Math.max(1, contrastColor[2] / 100)), 255), 0)
  ];
  const contrast = wcagContrast.hex(rgbaConvert__default.hex(`rgba(${baseColor.join(",")},1)`), rgbaConvert__default.hex(`rgba(${color.join(",")},1)`));
  const summe = color[0] + color[1] + color[2];
  if (summe === 0 || summe === 765 || contrast > ratio) {
    return {
      background: baseColor,
      foreground: color,
      contrast
    };
  } else {
    return calcColorContrast(baseColor, color, ratio, dir);
  }
};
const cache = /* @__PURE__ */ new Map();
const getColorContrast = (baseColor, contrastColor, ratio, dir = 1) => {
  if (cache.has(baseColor)) {
    return cache.get(baseColor);
  }
  const color = calcColorContrast(baseColor, contrastColor, ratio, dir);
  cache.set(baseColor, color);
  return color;
};
const createContrastColorPair = (color, contrastRatio = 7) => {
  let baseColor = [0, 0, 0, 1];
  let contrastColor = [255, 255, 255, 1];
  if (typeof color === "string") {
    baseColor = colorRgba__default(color);
    contrastColor = baseColor;
  } else if (typeof color === "object" && color !== null && typeof color.background === "string" && typeof color.foreground === "string") {
    baseColor = colorRgba__default(color.background);
    if (typeof color.foreground === "string") {
      contrastColor = colorRgba__default(color.foreground);
    } else {
      contrastColor = baseColor;
    }
  }
  const yiq = getContrastYIQ(baseColor[0], baseColor[1], baseColor[2]);
  const colorContrast = getColorContrast(
    [baseColor[0], baseColor[1], baseColor[2]],
    [contrastColor[0], contrastColor[1], contrastColor[2]],
    contrastRatio,
    yiq
  );
  contrastColor = [...colorContrast.foreground, 1];
  return {
    background: rgbaConvert__default.hex(`rgba(${baseColor.join(",")})`),
    foreground: rgbaConvert__default.hex(`rgba(${contrastColor.join(",")})`),
    contrast: colorContrast.contrast
  };
};

const OBJECT_OBJECT = /\[object Object\]/;
const objectObjectHandler = (value, cb) => {
  if (typeof value === "string" && OBJECT_OBJECT.test(value)) {
    return;
  }
  cb();
};
const emptyStringByArrayHandler = (value, cb) => {
  if (typeof value === "string" && value === "") {
    return;
  }
  cb();
};
const setEventTarget = (event, target) => {
  if (getExperimentalMode()) {
    Log.debug([event, target]);
    Log.debug(`\u2191 We propagate the (submit) event to this target.`);
  }
  Object.defineProperty(event, "target", {
    value: target,
    writable: false
  });
};
const patchState = (component) => {
  component.nextHooks?.forEach((hooks, key) => {
    const beforePatch = hooks.get("beforePatch");
    if (typeof beforePatch === "function") {
      beforePatch(component.nextState?.get(key), component.nextState, component, key);
    }
  });
  if (component.nextState?.size > 0) {
    component.state = {
      ...component.state,
      ...Object.fromEntries(component.nextState)
    };
    delete component.nextState;
    component.nextHooks?.forEach((hooks, key) => {
      const afterPatch = hooks.get("afterPatch");
      if (typeof afterPatch === "function") {
        afterPatch(component.state[key], component.state, component, key);
      }
    });
  }
  delete component.nextHooks;
};
const setState = (component, propName, value, hooks = {}) => {
  if (component.nextHooks === void 0) {
    component.nextHooks = /* @__PURE__ */ new Map();
  }
  if (component.nextState === void 0) {
    component.nextState = /* @__PURE__ */ new Map();
  }
  const nextHooks = component.nextHooks.get(propName);
  if (nextHooks instanceof Map === false) {
    component.nextHooks.set(propName, /* @__PURE__ */ new Map());
  }
  if (typeof hooks.afterPatch === "function") {
    component.nextHooks.get(propName)?.set("afterPatch", hooks.afterPatch);
  }
  if (typeof hooks.beforePatch === "function") {
    component.nextHooks.get(propName)?.set("beforePatch", hooks.beforePatch);
  }
  component.nextState.set(propName, value);
  patchState(component);
};
const logWarn = (component, propName, value, requiredGeneric) => {
  devHint(
    `[${component.constructor.name}] Der Property-Wert (${value}) f\xFCr '${propName}' ist nicht valide. Folgende Werte sind erlaubt: ${Array.from(
      requiredGeneric
    ).join(", ")}`
  );
};
function watchValidator(component, propName, validationFunction, requiredGeneric, value, options = {}) {
  if (validationFunction(value)) {
    setState(component, propName, value, options.hooks);
  } else if (value === void 0 && options.required !== true && validationFunction(options.defaultValue)) {
    setState(component, propName, options.defaultValue, options.hooks);
  } else {
    if (!options.required) {
      requiredGeneric.add(null);
    }
    logWarn(component, propName, value, requiredGeneric);
  }
}
const watchBoolean = (component, propName, value, options) => {
  watchValidator(component, propName, (value2) => typeof value2 === "boolean", /* @__PURE__ */ new Set(["Boolean {true, false}"]), value, options);
};
const watchString = (component, propName, value, options = {}) => {
  const minLength = typeof options.minLength === "number" ? options?.minLength : 0;
  watchValidator(
    component,
    propName,
    (value2) => typeof value2 === "string" && value2.length >= minLength && (typeof options?.maxLength === "undefined" || value2.length <= options.maxLength),
    /* @__PURE__ */ new Set([`String`]),
    value,
    options
  );
};
const watchNumber = (component, propName, value, options) => {
  watchValidator(
    component,
    propName,
    (value2) => typeof value2 === "number" && (typeof options?.min === "undefined" || typeof options?.min === "number" && value2 >= options.min) && (typeof options?.max === "undefined" || typeof options?.max === "number" && value2 <= options.max),
    /* @__PURE__ */ new Set(["Number"]),
    value,
    options
  );
};
const watchJsonArrayString = (component, propName, itemValidation, value, arrayValidation = (items) => items === items, options = {}) => {
  emptyStringByArrayHandler(value, () => {
    objectObjectHandler(value, () => {
      if (typeof value === "undefined") {
        value = [];
      }
      try {
        try {
          value = parseJson(value);
        } catch (e) {
        }
        if (Array.isArray(value)) {
          const invalid = value.find((item) => !itemValidation(item));
          if (invalid === void 0 && arrayValidation(value)) {
            setState(component, propName, value, options.hooks);
          } else {
            objectObjectHandler(invalid, () => {
              Log.debug(invalid);
              throw new Error(`\u2191 Das Schema f\xFCr das Property (_options) ist nicht valide. Der Wert wird nicht ge\xE4ndert.`);
            });
          }
        } else {
          objectObjectHandler(value, () => {
            Log.debug(value);
            throw new Error(`\u2191 Das Schema f\xFCr das Property (_options) ist nicht valide. Der Wert wird nicht ge\xE4ndert.`);
          });
        }
      } catch (error) {
        Log.debug(error);
      }
    });
  });
};
const BOOLEAN = /^(true|false)$/;
const INTEGER = /^-?(0|[1-9]\d*)$/;
const FLOAT = /^-?(0.|[1-9]\d*.)\d*[1-9]$/;
const mapString2Unknown = (value) => {
  const typeStr = typeof value;
  const oldValue = `${value}`;
  if (typeof value === "string") {
    if (BOOLEAN.test(value)) {
      value = value === "true";
    } else if (INTEGER.test(value)) {
      value = parseInt(value);
    } else if (FLOAT.test(value)) {
      value = parseFloat(value);
    } else if (JSON_CHARS.test(value)) {
      try {
        value = parseJson(value);
      } catch (e) {
      }
    }
  }
  if (typeStr !== typeof value) {
    devHint(`You have used a stringified property value (${oldValue} to ${JSON.stringify(value)}) which type switched from ${typeStr} to ${typeof value}!`);
  }
  return value;
};
const stringifyJson = (value) => {
  try {
    return JSON.stringify(value).replace(/"/g, "'");
  } catch (error) {
    Log.warn(["stringifyJson", value]);
    Log.error(`\u2191 Das JSON konnte nicht in einen String umgewandelt werden. Es wird ein stringifizierbares JSON erwartet.`);
    throw new Error();
  }
};
const JSON_CHARS = /^[{[]/;
const parseJson = (value) => {
  if (typeof value === "string") {
    try {
      return JSON.parse(value);
    } catch (error) {
      if (JSON_CHARS.test(value)) {
        try {
          return JSON.parse(value.replace(/'/g, '"'));
        } catch (error2) {
          Log.warn(["parseJson", value]);
          Log.error(`\u2191 Der JSON-String konnte nicht geparsed werden. Achten Sie darauf, dass einfache Anf\xFChrungszeichen im Text maskiert werden (&#8216;).`);
        }
      }
    }
  }
  throw new Error();
};
const mapBoolean2String = (value) => {
  return typeof value === "boolean" ? value === true ? "true" : "false" : void 0;
};
const mapStringOrBoolean2String = (value) => {
  return typeof value === "string" ? value : mapBoolean2String(value);
};
const koliBriQuerySelector = (selector, node) => querySelectorShadowRoot.querySelector(selector, node || getDocument());
const koliBriQuerySelectorAll = (selector, node) => querySelectorAllShadowRoot.querySelectorAll(selector, node || getDocument());
let DEFAULT_COLOR_CONTRAST = null;
const getDefaultColorContrast = () => {
  DEFAULT_COLOR_CONTRAST = DEFAULT_COLOR_CONTRAST || {
    backgroundColor: "#00000000",
    color: "#00000000",
    domNode: getDocument().body,
    level: "Fail",
    score: 1
  };
  return DEFAULT_COLOR_CONTRAST;
};
const TRANSPARENT_REGEXP = /(\d+, ){3}0\)/;
const koliBriA11yColorContrast = (domNode, a11yColorContrast = getDefaultColorContrast()) => {
  const computedStyle = getComputedStyle(domNode);
  const hexBG = TRANSPARENT_REGEXP.test(computedStyle.backgroundColor) ? a11yColorContrast.backgroundColor : rgbaConvert__default.hex(computedStyle.backgroundColor);
  const hexC = TRANSPARENT_REGEXP.test(computedStyle.color) ? a11yColorContrast.color : rgbaConvert__default.hex(computedStyle.color);
  const diff = wcagContrast.hex(hexBG, hexC);
  const contrast = {
    backgroundColor: hexBG,
    color: hexC,
    domNode,
    level: wcagContrast.score(diff),
    score: diff
  };
  if (diff < 4.5) {
    Log.error([
      "Color-Contrast-Error",
      {
        backgroundColor: contrast.backgroundColor,
        color: contrast.color,
        level: contrast.level,
        score: contrast.score
      },
      contrast.domNode
    ]);
  }
  return contrast;
};
const koliBriQuerySelectorColors = (selector, a11yColorContrast = getDefaultColorContrast()) => {
  if (a11yColorContrast.domNode instanceof HTMLElement) {
    a11yColorContrast = koliBriA11yColorContrast(a11yColorContrast.domNode, a11yColorContrast);
  }
  const selectedNode = a11yColorContrast.domNode.querySelector(selector);
  if (selectedNode === null) {
    const nodeList = a11yColorContrast.domNode.querySelectorAll('[class="hydrated"]');
    for (let i = 0; i < nodeList.length; i++) {
      a11yColorContrast.domNode = nodeList[i];
      a11yColorContrast = koliBriQuerySelectorColors(selector, a11yColorContrast);
      if (a11yColorContrast.domNode !== null) {
        break;
      }
    }
    return a11yColorContrast;
  } else {
    return koliBriA11yColorContrast(selectedNode, a11yColorContrast);
  }
};
const _KoliBriUtils = class {
  static queryHtmlElementColors(targetNode, a11yColorContrast, recursion = false, log = true) {
    let returnValue = null;
    if (recursion === true || _KoliBriUtils.executionLock === false) {
      if (recursion === false) {
        _KoliBriUtils.cache.clear();
        _KoliBriUtils.cache.set(a11yColorContrast.domNode, a11yColorContrast);
        _KoliBriUtils.executionLock = true;
        if (log === true) {
          Log.debug(`[KoliBriUtils] Color contrast analysis started...`);
        }
      }
      if (targetNode === a11yColorContrast.domNode) {
        returnValue = a11yColorContrast;
      } else {
        const children = /* @__PURE__ */ new Set();
        if (a11yColorContrast.domNode.shadowRoot) {
          const shadowChildren = a11yColorContrast.domNode.shadowRoot.children;
          for (let i = 0; i < shadowChildren.length; i++) {
            children.add(shadowChildren[i]);
          }
        }
        const slotElement = a11yColorContrast.domNode;
        if (typeof slotElement.assignedNodes === "function") {
          const slotChildren = slotElement.assignedNodes();
          for (let i = 0; i < slotChildren.length; i++) {
            if (slotChildren[i] instanceof HTMLElement) {
              children.add(slotChildren[i]);
            }
          }
        }
        const domChildren = a11yColorContrast.domNode.children;
        for (let i = 0; i < domChildren.length; i++) {
          children.add(domChildren[i]);
        }
        const arrayChildren = Array.from(children);
        for (let i = 0; i < arrayChildren.length; i++) {
          let colorContrast = _KoliBriUtils.cache.get(arrayChildren[i]);
          if (colorContrast === void 0) {
            colorContrast = koliBriA11yColorContrast(arrayChildren[i], a11yColorContrast);
          }
          _KoliBriUtils.cache.set(arrayChildren[i], colorContrast);
          const colors = _KoliBriUtils.queryHtmlElementColors(targetNode, colorContrast, true, false);
          if (colors !== null) {
            returnValue = colors;
            break;
          }
        }
      }
    } else {
      Log.debug(`[KoliBriUtils] Call aborted because a color contrast analysis is currently being executed.`);
    }
    if (recursion === false) {
      if (log === true) {
        Log.debug(`[KoliBriUtils] Color contrast analysis finished (${_KoliBriUtils.cache.size} DOM elements are analysed).`);
      }
      _KoliBriUtils.executionLock = false;
      _KoliBriUtils.cache.clear();
    }
    return returnValue;
  }
};
let KoliBriUtils = _KoliBriUtils;
KoliBriUtils.executionLock = false;
KoliBriUtils.cache = /* @__PURE__ */ new Map();
class KoliBriDevHelper {
}
KoliBriDevHelper.patchTheme = adoptedStyleSheets.patchTheme;
KoliBriDevHelper.patchThemeTag = adoptedStyleSheets.patchThemeTag;
KoliBriDevHelper.querySelector = koliBriQuerySelector;
KoliBriDevHelper.querySelectorAll = koliBriQuerySelectorAll;
KoliBriDevHelper.stringifyJson = stringifyJson;

const validateAlignment = (component, propName, value) => {
  watchValidator(component, propName, (value2) => typeof value2 === "string" && alignPropTypeOptions.includes(value2), new Set(alignPropTypeOptions), value, {
    defaultValue: "top"
  });
};

const isObject = (value) => typeof value === "object" && value !== null;
const isString = (value, minLength = 0) => typeof value === "string" && value.length >= minLength;
const isStyle = (style) => {
  if (typeof style === "object" && style !== null) {
    for (const property in style) {
      if (isString(property, 1) === false) {
        return false;
      }
    }
  } else {
    return isString(style, 1);
  }
  return true;
};
const STATE_CHANGE_EVENT = new Event("StateChange");

const validateInputSelectOptions = (option) => {
  if (typeof option === "object" && option !== null) {
    if (typeof option.label === "string" && option.label.length > 0) {
      option.disabled = option.disabled === true;
      option.label = `${option.label}`.trim();
      if (hasEnoughReadableChars(option.label, 3) === false && containsOnlyNumbers(option.label) === false) {
        a11yHint(
          `Ein abweichendes Aria-Label (${option.label}) ist nicht barrierefrei. Ein abweichendes Aria-Label sollte aus mindestens drei lesbaren Zeichen bestehen.`
        );
      }
      if (Array.isArray(option.options)) {
        return option.options.find((item) => {
          return validateInputSelectOptions(item) === false;
        }) === void 0;
      }
      return true;
    } else if (typeof option.label === "number") {
      return true;
    }
  }
  return false;
};

const options = {
  hooks: {
    afterPatch: (value) => {
      if (value !== -1 && value !== 0) {
        a11yHint(`Don't Use Tabindex Greater than 0: https://adrianroselli.com/2014/11/dont-use-tabindex-greater-than-0.html`);
      }
    }
  }
};
const validateTabIndex = (component, value) => {
  watchNumber(component, "_tabIndex", value, options);
};

const propagateFocus = (host, ref) => {
  if (isObject(host) && host) {
    host.focus = (ops) => ref?.focus(ops);
  }
};
exports.processEnv = "development";
try {
  exports.processEnv = process.env.NODE_ENV;
} catch (e) {
  exports.processEnv = "production";
}
const handleSlotContent = (hostRef, slotRef, slotName) => {
  if (hostRef && slotRef && typeof slotName === "string") {
    const content = hostRef.querySelector(`[slot="${slotName}"]`);
    if (content) {
      slotRef.appendChild(content);
    }
  }
};
const showExpertSlot = (label) => label === "";

const validateAccessKey = (component, value) => {
  watchString(component, "_accessKey", value);
};

const validateActive = (component, value, options) => {
  watchBoolean(component, "_active", value, options);
};

const validateAdjustHeight = (component, value) => {
  watchBoolean(component, "_adjustHeight", value);
};

const validateAlert = (component, value) => {
  watchBoolean(component, "_alert", value);
};

const horizontalAlignOptions = ["left", "right"];
const verticalAlignOptions = ["top", "bottom"];
const alignPropTypeOptions = [...horizontalAlignOptions, ...verticalAlignOptions];
const validateAlign = (component, value) => {
  validateAlignment(component, "_align", value);
};

const validateAlternativeButtonLinkRole = (component, value) => {
  watchString(component, "_role", value);
};

const validateAriaControls = (component, value) => {
  watchString(component, "_ariaControls", value);
};

const ariaCurrentValuePropTypeOptions = ["date", "location", "page", "step", "time", "true", "false"];
const validateAriaCurrentValue = (component, value) => {
  watchValidator(
    component,
    `_ariaCurrentValue`,
    (value2) => typeof value2 === "string" && ariaCurrentValuePropTypeOptions.includes(value2),
    /* @__PURE__ */ new Set([`AriaCurrentValue {${ariaCurrentValuePropTypeOptions.join(", ")}`]),
    value,
    {
      defaultValue: "page"
    }
  );
};

const validateAriaExpanded = (component, value) => {
  watchBoolean(component, "_ariaExpanded", value);
};

const validateAriaSelected = (component, value) => {
  watchBoolean(component, "_ariaSelected", value);
};

const validateButtonCallbacks = (component, value) => {
  watchValidator(
    component,
    `_on`,
    (value2) => typeof value2 === "object" && value2 !== null,
    /* @__PURE__ */ new Set(["ButtonCallbacksPropType {Events.onClick, Events.onMouseDown}"]),
    value
  );
};

const buttonTypePropTypeOptions = ["button", "reset", "submit"];
const validateButtonType = (component, value) => {
  watchValidator(
    component,
    `_type`,
    (value2) => typeof value2 === "string" && buttonTypePropTypeOptions.includes(value2),
    /* @__PURE__ */ new Set([`KoliBriButtonType {${buttonTypePropTypeOptions.join(", ")}`]),
    value
  );
};

const buttonVariantPropTypeOptions = ["primary", "secondary", "normal", "tertiary", "danger", "ghost", "custom"];
const validateButtonVariant = (component, value) => {
  watchValidator(
    component,
    `_variant`,
    (value2) => typeof value2 === "string" && buttonVariantPropTypeOptions.includes(value2),
    /* @__PURE__ */ new Set([`KoliBriButtonVariant {${buttonVariantPropTypeOptions.join(", ")}`]),
    value,
    {
      defaultValue: "normal"
    }
  );
};

const validateChecked = (component, value) => {
  watchBoolean(component, "_checked", value);
};

const validateCollapsible = (component, value) => {
  watchBoolean(component, "_collapsible", value);
};

const HEX_REGEX = /^#((\d|[a-f]){8}|(\d|[a-f]){6}|(\d|[a-f]){3,4})$/i;
function isHexString(value) {
  return HEX_REGEX.test(value);
}
function isColorObjectString(value) {
  if (value.startsWith("{")) {
    try {
      const parsed = JSON.parse(value);
      if (isValidColorPair(parsed))
        return { type: "ColorPair", value: parsed };
    } catch (error) {
      return { type: null, value: null };
    }
  }
  return { type: null, value: null };
}
function typeOfColor(value) {
  if (value) {
    if (typeof value === "string") {
      if (isHexString(value))
        return { type: "string", valid: true, value };
      else {
        const colorObject = isColorObjectString(value);
        if (colorObject.value)
          return { type: colorObject.type, valid: true, value: colorObject.value };
      }
    } else {
      const asColorPair = value;
      if (isValidColorPair(asColorPair))
        return { type: "ColorPair", valid: true, value: asColorPair };
    }
  }
  return { type: null, valid: false, value: "" };
}
function isValidColorPair(value) {
  return !!(typeof value === "object" && value && typeof value.backgroundColor === "string" && (typeof value.foregroundColor === "string" || value.foregroundColor && typeof value.foregroundColor.primary === "string" && typeof value.foregroundColor.secondary === "string" && typeof value.foregroundColor.neutral === "string"));
}
function validatorFunction(value) {
  const valueType = typeOfColor(value);
  switch (valueType.type) {
    case null:
      return false;
    case "string":
    case "ColorPair":
      return valueType.valid;
  }
}
const validateColor = (component, value, options) => {
  watchValidator(component, "_color", validatorFunction, /* @__PURE__ */ new Set(["rgb in hex", "ColorPair"]), value, options);
};
const handleColorChange = (value) => {
  let colorContrast;
  const valueType = typeOfColor(value);
  switch (valueType.type) {
    case "string":
      colorContrast = createContrastColorPair(valueType.value);
      break;
    case "ColorPair": {
      const asColorPair = valueType.value;
      let foreground = "";
      if (typeof asColorPair.foregroundColor === "string")
        foreground = asColorPair.foregroundColor;
      else if (asColorPair.foregroundColor?.primary)
        foreground = asColorPair.foregroundColor.primary;
      if (!foreground || typeof foreground !== "string")
        foreground = "#fff";
      colorContrast = createContrastColorPair({
        background: asColorPair.backgroundColor,
        foreground
      });
      break;
    }
    case null:
      console.warn(`_color was empty or invalid (${JSON.stringify(value)})`);
      colorContrast = createContrastColorPair({
        background: "#000",
        foreground: "#000"
      });
  }
  if (colorContrast.contrast < 7) {
    a11yHint(
      `[KolBadge] The contrast of ${colorContrast.contrast} (\u22657, AAA) is to low, between the color pair ${colorContrast.background} and ${colorContrast.foreground}.`
    );
  }
  return {
    backgroundColor: colorContrast.background,
    foregroundColor: colorContrast.foreground
  };
};

const validateCustomClass = (component, value) => {
  watchString(component, "_customClass", value, {
    defaultValue: void 0
  });
};

const validateDisabled = (component, value) => {
  watchBoolean(component, "_disabled", value, {
    hooks: {
      afterPatch: (value2) => {
        if (value2 === true) {
          a11yHintDisabled();
        }
      }
    }
  });
};

const validateDownload = (component, value) => {
  watchString(component, "_download", value);
};

const validateErrorList = (component, value) => {
  watchValidator(component, "errorList", (value2) => typeof value2 === "object", /* @__PURE__ */ new Set(["Object"]), value);
};

const validateHasCloser = (component, value) => {
  watchBoolean(component, "_hasCloser", value);
};

const validateHasCompactButton = (component, value) => {
  watchBoolean(component, "_hasCompactButton", value);
};

const validateHasCounter = (component, value) => {
  watchBoolean(component, "_hasCounter", value);
};

const validateHasIconsWhenExpanded = (component, value) => {
  watchBoolean(component, "_hasIconsWhenExpanded", value);
};

const headingVariantPropTypeOptions = ["h1", "h2", "h3", "h4", "h5", "h6", "strong"];
const validateHeadingVariant = (component, value) => {
  watchValidator(
    component,
    `_variant`,
    (value2) => typeof value2 === "string" && headingVariantPropTypeOptions.includes(value2),
    /* @__PURE__ */ new Set([`KoliBriHeadingVariant {${headingVariantPropTypeOptions.join(", ")}`]),
    value
  );
};

const validateHideError = (component, value, options) => {
  watchBoolean(component, "_hideError", value, options);
};

const validateHideLabel = (component, value, options = {}) => {
  watchBoolean(component, "_hideLabel", value, options);
};

const validateHref = (component, value, options = {}) => {
  watchString(component, "_href", value, options);
};

const mapCustomIcon = (state, alignment, icon) => {
  if (isObject(icon)) {
    state[alignment] = icon;
  } else if (isString(icon, 1)) {
    state[alignment] = {
      icon
    };
  }
};
const mapIconProp2State = (icon) => {
  let state = {};
  if (isString(icon, 1)) {
    state = {
      left: {
        icon
      }
    };
  } else if (typeof icon === "object" && icon !== null) {
    mapCustomIcon(state, "top", icon.top);
    mapCustomIcon(state, "right", icon.right);
    mapCustomIcon(state, "bottom", icon.bottom);
    mapCustomIcon(state, "left", icon.left);
  }
  return state;
};
const beforePatchIcon = (component) => {
  if (component.nextState?.has("_icons")) {
    const icons = component.nextState?.get("_icons");
    component.nextState?.set("_icons", mapIconProp2State(icons));
  }
};
const isIcon = (value) => typeof value === "object" && value !== null && (typeof value.style === "undefined" || isStyle(value.style)) && (typeof value.label === "undefined" || isString(value.label)) && isString(value.icon, 1);
const validateIcons = (component, value, options = {}) => {
  objectObjectHandler(value, () => {
    try {
      value = parseJson(value);
    } catch (e) {
    }
    watchValidator(
      component,
      "_icons",
      (value2) => {
        const valueIsEmptyObject = typeof value2 === "object" && value2 !== null && Object.keys(value2).length === 0;
        return value2 === null || valueIsEmptyObject || isString(value2, 1) || typeof value2 === "object" && value2 !== null && (isString(value2.left, 1) || isIcon(value2.left) || isString(value2.right, 1) || isIcon(value2.right) || isString(value2.top, 1) || isIcon(value2.top) || isString(value2.bottom, 1) || isIcon(value2.bottom));
      },
      /* @__PURE__ */ new Set(["KoliBriIcon"]),
      value,
      {
        ...options,
        defaultValue: {},
        hooks: {
          afterPatch: options.hooks?.afterPatch,
          beforePatch: (nextValue, nextState, component2, key) => {
            if (typeof options.hooks?.beforePatch === "function") {
              options.hooks?.beforePatch(nextValue, nextState, component2, key);
            }
            beforePatchIcon(component2);
          }
        }
      }
    );
  });
};

const validateId = (component, value) => {
  watchString(component, "_id", value);
};

const validateImageSource = (component, value, options) => {
  watchString(component, "_src", value, options);
};

const validateIndeterminate = (component, value) => {
  watchBoolean(component, "_indeterminate", value);
};

const headingLevelOptions = [0, 1, 2, 3, 4, 5, 6];
const READABLE_CHARS = /[a-zA-Z0-9äöüÄÖÜß]/g;
const ONLY_NUMBERS = /^\d+$/;
function countReadableChars(str) {
  return typeof str === "string" ? str.match(READABLE_CHARS)?.length || 0 : 0;
}
function hasEnoughReadableChars(str, min = 1) {
  return countReadableChars(str) >= min;
}
function containsOnlyNumbers(str) {
  return ONLY_NUMBERS.test(str);
}
function getValidationOptions(options) {
  return {
    ...options,
    hooks: {
      afterPatch: (value, state, component, key) => {
        if (typeof options.hooks?.afterPatch === "function") {
          options.hooks?.afterPatch(value, state, component, key);
        }
        if (typeof value === "string" && hasEnoughReadableChars(value, 3) === false && containsOnlyNumbers(value) === false) {
          a11yHint(`The heading or label ("${value}") is not accessible. A label should consist of at least three readable characters.`);
        }
        if (typeof value === "string" && value.length > 80) {
          uiUxHint(`A heading or label should not be longer than 80 characters.`);
        }
      },
      beforePatch: options.hooks?.beforePatch
    }
  };
}
const LABEL_VALUES = /* @__PURE__ */ new Set(["string"]);
const validateLabel = (component, value, options = {}) => {
  watchValidator(component, "_label", (value2) => typeof value2 === "string", LABEL_VALUES, value, getValidationOptions(options));
};
const validateLabelWithExpertSlot = validateLabel;

const validateLinkCallbacks = (component, value) => {
  if (typeof value === "object" && typeof value?.onClick === "function") {
    component.state = {
      ...component.state,
      _on: value
    };
  }
};

const validateLinkTarget = (component, value) => {
  watchString(component, "_target", value);
};

const loadingOptions = ["eager", "lazy"];
function validateLoading(component, value) {
  watchValidator(component, "_loading", (value2) => typeof value2 === "string" && loadingOptions.includes(value2), new Set(loadingOptions), value);
}

const validateMax = (component, value, options) => {
  watchNumber(component, "_max", value, options);
};

const validateMsg = (component, value) => {
  watchValidator(component, `_msg`, (value2) => typeof value2 === "object", /* @__PURE__ */ new Set(["Object"]), value);
};

const validateMultiple = (component, value) => {
  watchBoolean(component, "_multiple", value);
};

const validateName = (component, value, options) => {
  watchString(component, "_name", value, options);
};

const validateOpen = (component, value, options) => {
  watchBoolean(component, "_open", value, options);
};

const validateOptions = (component, value, options = {}) => {
  watchJsonArrayString(
    component,
    "_options",
    (item) => typeof item === "object" && item !== null && typeof item.label === "string" && item.label.length > 0,
    value,
    void 0,
    options
  );
};
const validateOptionsWithOptgroup = (component, value, options = {}) => {
  watchJsonArrayString(component, "_options", validateInputSelectOptions, value, void 0, options);
};

const paginationPositionPropTypeOptions = ["top", "bottom", "both"];
const validatePaginationPosition = (component, value) => {
  watchValidator(
    component,
    `_paginationPosition`,
    (value2) => typeof value2 === "string" && paginationPositionPropTypeOptions.includes(value2),
    /* @__PURE__ */ new Set([`PaginationPositionPropType {${paginationPositionPropTypeOptions.join(", ")}`]),
    value,
    {
      defaultValue: "bottom"
    }
  );
};

const validateReadOnly = (component, value) => {
  watchBoolean(component, "_readOnly", value);
};

const validateRequired = (component, value) => {
  watchBoolean(component, "_required", value);
};

const validateRows = (component, value) => {
  watchNumber(component, `_rows`, value, { min: 1 });
};

const validateShow = (component, value, hooks) => {
  watchBoolean(component, "_show", value, hooks);
};

const validateSuggestions = (component, value) => {
  watchJsonArrayString(component, "_suggestions", (item) => typeof item === "string" || typeof item === "number", value, void 0, {
    hooks: {
      afterPatch: (value2) => {
        if (Array.isArray(value2) && value2.length) {
          a11yHint("Property suggestions: Options have accessibility issues in how browsers implemented them and should not be used for now.");
        }
      }
    }
  });
};

const validateTableCallbacks = (component, value) => {
  watchValidator(component, `_on`, (value2) => typeof value2 === "object" && value2 !== null, /* @__PURE__ */ new Set(["TableCallbacksPropType {Events.onSort}"]), value);
};

const validateTableData = (component, value, setStateHooks) => {
  emptyStringByArrayHandler(value, () => {
    objectObjectHandler(value, () => {
      if (typeof value === "undefined") {
        value = [];
      }
      try {
        value = parseJson(value);
      } catch (e) {
      }
      if (Array.isArray(value) && value.every((data) => typeof data === "object" && data !== null)) {
        setState(component, "_data", value, setStateHooks);
      }
    });
  });
};

const validateTableDataFoot = (component, value, setStateHooks) => {
  emptyStringByArrayHandler(value, () => {
    objectObjectHandler(value, () => {
      if (typeof value === "undefined") {
        value = [];
      }
      try {
        value = parseJson(value);
      } catch (e) {
      }
      if (Array.isArray(value) && value.every((data) => typeof data === "object" && data !== null)) {
        setState(component, "_dataFoot", value, setStateHooks);
      }
    });
  });
};

const validateTableHeaderCells = (component, value) => {
  emptyStringByArrayHandler(value, () => {
    objectObjectHandler(value, () => {
      try {
        value = parseJson(value);
      } catch (e) {
      }
      watchValidator(component, "_headerCells", (value2) => typeof value2 === "object" && value2 !== null, /* @__PURE__ */ new Set(["TableHeaderCellsPropType"]), value);
    });
  });
};

const validateTooltipAlign = (component, value) => {
  validateAlignment(component, "_tooltipAlign", value);
};

const validateTouched = (component, value) => {
  watchBoolean(component, "_touched", value);
};

const spinVariantPropTypeOptions = ["cycle", "dot", "none"];
const validateSpinVariant = (component, value) => {
  watchValidator(
    component,
    "_variant",
    (value2) => typeof value2 === "string" && spinVariantPropTypeOptions.includes(value2),
    new Set(spinVariantPropTypeOptions),
    value
  );
};

const inputDateTypeOptions = ["date", "datetime-local", "month", "time", "week"];

const inputTextTypeOptions = ["text", "search", "url", "tel"];

const inputTypeOnOffOptions = ["on", "off"];

const orientationOptions = ["horizontal", "vertical"];

var KoliBriProgressVariantEnum = /* @__PURE__ */ ((KoliBriProgressVariantEnum2) => {
  KoliBriProgressVariantEnum2["bar"] = "bar";
  KoliBriProgressVariantEnum2["cycle"] = "cycle";
  return KoliBriProgressVariantEnum2;
})(KoliBriProgressVariantEnum || {});

const KoliBri = new adoptedStyleSheets.Theme("kol", KeyEnum, TagEnum);

exports.rgbaConvert = rgbaConvert__default;
exports.colorRgba = colorRgba__default;
exports.KoliBri = KoliBri;
exports.KoliBriDevHelper = KoliBriDevHelper;
exports.KoliBriProgressVariantEnum = KoliBriProgressVariantEnum;
exports.KoliBriUtils = KoliBriUtils;
exports.Log = Log;
exports.Logger = Logger;
exports.STATE_CHANGE_EVENT = STATE_CHANGE_EVENT;
exports.a11yHint = a11yHint;
exports.a11yHintDisabled = a11yHintDisabled;
exports.a11yHintLabelingLandmarks = a11yHintLabelingLandmarks;
exports.alertTypeOptions = alertTypeOptions;
exports.alertVariantOptions = alertVariantOptions;
exports.alignPropTypeOptions = alignPropTypeOptions;
exports.calcColorContrast = calcColorContrast;
exports.containsOnlyNumbers = containsOnlyNumbers;
exports.createContrastColorPair = createContrastColorPair;
exports.cssResizeOptions = cssResizeOptions;
exports.devHint = devHint;
exports.devWarning = devWarning;
exports.emptyStringByArrayHandler = emptyStringByArrayHandler;
exports.featureHint = featureHint;
exports.getColorContrast = getColorContrast;
exports.getColorContrastAnalysis = getColorContrastAnalysis;
exports.getContrastYIQ = getContrastYIQ;
exports.getDevMode = getDevMode;
exports.getDocument = getDocument;
exports.getExperimentalMode = getExperimentalMode;
exports.getWindow = getWindow;
exports.handleColorChange = handleColorChange;
exports.handleSlotContent = handleSlotContent;
exports.hasEnoughReadableChars = hasEnoughReadableChars;
exports.headingLevelOptions = headingLevelOptions;
exports.inputCheckboxVariantOptions = inputCheckboxVariantOptions;
exports.inputDateTypeOptions = inputDateTypeOptions;
exports.inputTextTypeOptions = inputTextTypeOptions;
exports.inputTypeOnOffOptions = inputTypeOnOffOptions;
exports.isIcon = isIcon;
exports.isObject = isObject;
exports.isString = isString;
exports.isStyle = isStyle;
exports.koliBriA11yColorContrast = koliBriA11yColorContrast;
exports.koliBriQuerySelector = koliBriQuerySelector;
exports.koliBriQuerySelectorAll = koliBriQuerySelectorAll;
exports.koliBriQuerySelectorColors = koliBriQuerySelectorColors;
exports.koliBriQuoteVariantOptions = koliBriQuoteVariantOptions;
exports.mapBoolean2String = mapBoolean2String;
exports.mapIconProp2State = mapIconProp2State;
exports.mapString2Unknown = mapString2Unknown;
exports.mapStringOrBoolean2String = mapStringOrBoolean2String;
exports.objectObjectHandler = objectObjectHandler;
exports.orientationOptions = orientationOptions;
exports.parseJson = parseJson;
exports.propagateFocus = propagateFocus;
exports.setColorContrastAnalysis = setColorContrastAnalysis;
exports.setDevMode = setDevMode;
exports.setDocument = setDocument;
exports.setEventTarget = setEventTarget;
exports.setExperimentalMode = setExperimentalMode;
exports.setState = setState;
exports.setWindow = setWindow;
exports.showExpertSlot = showExpertSlot;
exports.stringifyJson = stringifyJson;
exports.uiUxHint = uiUxHint;
exports.uiUxHintMillerscheZahl = uiUxHintMillerscheZahl;
exports.validateAccessKey = validateAccessKey;
exports.validateActive = validateActive;
exports.validateAdjustHeight = validateAdjustHeight;
exports.validateAlert = validateAlert;
exports.validateAlign = validateAlign;
exports.validateAlignment = validateAlignment;
exports.validateAlternativeButtonLinkRole = validateAlternativeButtonLinkRole;
exports.validateAriaControls = validateAriaControls;
exports.validateAriaCurrentValue = validateAriaCurrentValue;
exports.validateAriaExpanded = validateAriaExpanded;
exports.validateAriaSelected = validateAriaSelected;
exports.validateButtonCallbacks = validateButtonCallbacks;
exports.validateButtonType = validateButtonType;
exports.validateButtonVariant = validateButtonVariant;
exports.validateChecked = validateChecked;
exports.validateCollapsible = validateCollapsible;
exports.validateColor = validateColor;
exports.validateCustomClass = validateCustomClass;
exports.validateDisabled = validateDisabled;
exports.validateDownload = validateDownload;
exports.validateErrorList = validateErrorList;
exports.validateHasCloser = validateHasCloser;
exports.validateHasCompactButton = validateHasCompactButton;
exports.validateHasCounter = validateHasCounter;
exports.validateHasIconsWhenExpanded = validateHasIconsWhenExpanded;
exports.validateHeadingVariant = validateHeadingVariant;
exports.validateHideError = validateHideError;
exports.validateHideLabel = validateHideLabel;
exports.validateHref = validateHref;
exports.validateIcons = validateIcons;
exports.validateId = validateId;
exports.validateImageSource = validateImageSource;
exports.validateIndeterminate = validateIndeterminate;
exports.validateInputSelectOptions = validateInputSelectOptions;
exports.validateLabel = validateLabel;
exports.validateLabelWithExpertSlot = validateLabelWithExpertSlot;
exports.validateLinkCallbacks = validateLinkCallbacks;
exports.validateLinkTarget = validateLinkTarget;
exports.validateLoading = validateLoading;
exports.validateMax = validateMax;
exports.validateMsg = validateMsg;
exports.validateMultiple = validateMultiple;
exports.validateName = validateName;
exports.validateOpen = validateOpen;
exports.validateOptions = validateOptions;
exports.validateOptionsWithOptgroup = validateOptionsWithOptgroup;
exports.validatePaginationPosition = validatePaginationPosition;
exports.validateReadOnly = validateReadOnly;
exports.validateRequired = validateRequired;
exports.validateRows = validateRows;
exports.validateShow = validateShow;
exports.validateSpinVariant = validateSpinVariant;
exports.validateSuggestions = validateSuggestions;
exports.validateTabIndex = validateTabIndex;
exports.validateTableCallbacks = validateTableCallbacks;
exports.validateTableData = validateTableData;
exports.validateTableDataFoot = validateTableDataFoot;
exports.validateTableHeaderCells = validateTableHeaderCells;
exports.validateTooltipAlign = validateTooltipAlign;
exports.validateTouched = validateTouched;
exports.watchBoolean = watchBoolean;
exports.watchJsonArrayString = watchJsonArrayString;
exports.watchNumber = watchNumber;
exports.watchString = watchString;
exports.watchValidator = watchValidator;