@helpwave/hightide 0.1.26 → 0.1.28

package/dist/components/properties/index.js

@@ -0,0 +1,2983 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/components/properties/index.ts
+var properties_exports = {};
+__export(properties_exports, {
+  CheckboxProperty: () => CheckboxProperty,
+  DateProperty: () => DateProperty,
+  MultiSelectProperty: () => MultiSelectProperty,
+  NumberProperty: () => NumberProperty,
+  PropertyBase: () => PropertyBase,
+  SingleSelectProperty: () => SingleSelectProperty,
+  TextProperty: () => TextProperty
+});
+module.exports = __toCommonJS(properties_exports);
+
+// src/components/properties/CheckboxProperty.tsx
+var import_lucide_react3 = require("lucide-react");
+
+// src/utils/noop.ts
+var noop = () => void 0;
+
+// src/components/user-action/Checkbox.tsx
+var import_react = require("react");
+var import_lucide_react = require("lucide-react");
+var import_clsx = __toESM(require("clsx"));
+
+// node_modules/@radix-ui/react-checkbox/dist/index.mjs
+var React10 = __toESM(require("react"), 1);
+
+// node_modules/@radix-ui/react-compose-refs/dist/index.mjs
+var React = __toESM(require("react"), 1);
+function setRef(ref, value) {
+  if (typeof ref === "function") {
+    return ref(value);
+  } else if (ref !== null && ref !== void 0) {
+    ref.current = value;
+  }
+}
+function composeRefs(...refs) {
+  return (node) => {
+    let hasCleanup = false;
+    const cleanups = refs.map((ref) => {
+      const cleanup = setRef(ref, node);
+      if (!hasCleanup && typeof cleanup == "function") {
+        hasCleanup = true;
+      }
+      return cleanup;
+    });
+    if (hasCleanup) {
+      return () => {
+        for (let i = 0; i < cleanups.length; i++) {
+          const cleanup = cleanups[i];
+          if (typeof cleanup == "function") {
+            cleanup();
+          } else {
+            setRef(refs[i], null);
+          }
+        }
+      };
+    }
+  };
+}
+function useComposedRefs(...refs) {
+  return React.useCallback(composeRefs(...refs), refs);
+}
+
+// node_modules/@radix-ui/react-context/dist/index.mjs
+var React2 = __toESM(require("react"), 1);
+var import_jsx_runtime = require("react/jsx-runtime");
+function createContextScope(scopeName, createContextScopeDeps = []) {
+  let defaultContexts = [];
+  function createContext32(rootComponentName, defaultContext) {
+    const BaseContext = React2.createContext(defaultContext);
+    const index = defaultContexts.length;
+    defaultContexts = [...defaultContexts, defaultContext];
+    const Provider = (props) => {
+      const { scope, children, ...context } = props;
+      const Context = scope?.[scopeName]?.[index] || BaseContext;
+      const value = React2.useMemo(() => context, Object.values(context));
+      return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(Context.Provider, { value, children });
+    };
+    Provider.displayName = rootComponentName + "Provider";
+    function useContext22(consumerName, scope) {
+      const Context = scope?.[scopeName]?.[index] || BaseContext;
+      const context = React2.useContext(Context);
+      if (context) return context;
+      if (defaultContext !== void 0) return defaultContext;
+      throw new Error(`\`${consumerName}\` must be used within \`${rootComponentName}\``);
+    }
+    return [Provider, useContext22];
+  }
+  const createScope = () => {
+    const scopeContexts = defaultContexts.map((defaultContext) => {
+      return React2.createContext(defaultContext);
+    });
+    return function useScope(scope) {
+      const contexts = scope?.[scopeName] || scopeContexts;
+      return React2.useMemo(
+        () => ({ [`__scope${scopeName}`]: { ...scope, [scopeName]: contexts } }),
+        [scope, contexts]
+      );
+    };
+  };
+  createScope.scopeName = scopeName;
+  return [createContext32, composeContextScopes(createScope, ...createContextScopeDeps)];
+}
+function composeContextScopes(...scopes) {
+  const baseScope = scopes[0];
+  if (scopes.length === 1) return baseScope;
+  const createScope = () => {
+    const scopeHooks = scopes.map((createScope2) => ({
+      useScope: createScope2(),
+      scopeName: createScope2.scopeName
+    }));
+    return function useComposedScopes(overrideScopes) {
+      const nextScopes = scopeHooks.reduce((nextScopes2, { useScope, scopeName }) => {
+        const scopeProps = useScope(overrideScopes);
+        const currentScope = scopeProps[`__scope${scopeName}`];
+        return { ...nextScopes2, ...currentScope };
+      }, {});
+      return React2.useMemo(() => ({ [`__scope${baseScope.scopeName}`]: nextScopes }), [nextScopes]);
+    };
+  };
+  createScope.scopeName = baseScope.scopeName;
+  return createScope;
+}
+
+// node_modules/@radix-ui/primitive/dist/index.mjs
+function composeEventHandlers(originalEventHandler, ourEventHandler, { checkForDefaultPrevented = true } = {}) {
+  return function handleEvent(event) {
+    originalEventHandler?.(event);
+    if (checkForDefaultPrevented === false || !event.defaultPrevented) {
+      return ourEventHandler?.(event);
+    }
+  };
+}
+
+// node_modules/@radix-ui/react-use-controllable-state/dist/index.mjs
+var React4 = __toESM(require("react"), 1);
+
+// node_modules/@radix-ui/react-use-layout-effect/dist/index.mjs
+var React3 = __toESM(require("react"), 1);
+var useLayoutEffect2 = globalThis?.document ? React3.useLayoutEffect : () => {
+};
+
+// node_modules/@radix-ui/react-use-controllable-state/dist/index.mjs
+var React22 = __toESM(require("react"), 1);
+var useInsertionEffect = React4[" useInsertionEffect ".trim().toString()] || useLayoutEffect2;
+function useControllableState({
+  prop,
+  defaultProp,
+  onChange = () => {
+  },
+  caller
+}) {
+  const [uncontrolledProp, setUncontrolledProp, onChangeRef] = useUncontrolledState({
+    defaultProp,
+    onChange
+  });
+  const isControlled = prop !== void 0;
+  const value = isControlled ? prop : uncontrolledProp;
+  if (true) {
+    const isControlledRef = React4.useRef(prop !== void 0);
+    React4.useEffect(() => {
+      const wasControlled = isControlledRef.current;
+      if (wasControlled !== isControlled) {
+        const from = wasControlled ? "controlled" : "uncontrolled";
+        const to = isControlled ? "controlled" : "uncontrolled";
+        console.warn(
+          `${caller} is changing from ${from} to ${to}. Components should not switch from controlled to uncontrolled (or vice versa). Decide between using a controlled or uncontrolled value for the lifetime of the component.`
+        );
+      }
+      isControlledRef.current = isControlled;
+    }, [isControlled, caller]);
+  }
+  const setValue = React4.useCallback(
+    (nextValue) => {
+      if (isControlled) {
+        const value2 = isFunction(nextValue) ? nextValue(prop) : nextValue;
+        if (value2 !== prop) {
+          onChangeRef.current?.(value2);
+        }
+      } else {
+        setUncontrolledProp(nextValue);
+      }
+    },
+    [isControlled, prop, setUncontrolledProp, onChangeRef]
+  );
+  return [value, setValue];
+}
+function useUncontrolledState({
+  defaultProp,
+  onChange
+}) {
+  const [value, setValue] = React4.useState(defaultProp);
+  const prevValueRef = React4.useRef(value);
+  const onChangeRef = React4.useRef(onChange);
+  useInsertionEffect(() => {
+    onChangeRef.current = onChange;
+  }, [onChange]);
+  React4.useEffect(() => {
+    if (prevValueRef.current !== value) {
+      onChangeRef.current?.(value);
+      prevValueRef.current = value;
+    }
+  }, [value, prevValueRef]);
+  return [value, setValue, onChangeRef];
+}
+function isFunction(value) {
+  return typeof value === "function";
+}
+var SYNC_STATE = Symbol("RADIX:SYNC_STATE");
+
+// node_modules/@radix-ui/react-use-previous/dist/index.mjs
+var React5 = __toESM(require("react"), 1);
+function usePrevious(value) {
+  const ref = React5.useRef({ value, previous: value });
+  return React5.useMemo(() => {
+    if (ref.current.value !== value) {
+      ref.current.previous = ref.current.value;
+      ref.current.value = value;
+    }
+    return ref.current.previous;
+  }, [value]);
+}
+
+// node_modules/@radix-ui/react-use-size/dist/index.mjs
+var React6 = __toESM(require("react"), 1);
+function useSize(element) {
+  const [size, setSize] = React6.useState(void 0);
+  useLayoutEffect2(() => {
+    if (element) {
+      setSize({ width: element.offsetWidth, height: element.offsetHeight });
+      const resizeObserver = new ResizeObserver((entries) => {
+        if (!Array.isArray(entries)) {
+          return;
+        }
+        if (!entries.length) {
+          return;
+        }
+        const entry = entries[0];
+        let width;
+        let height;
+        if ("borderBoxSize" in entry) {
+          const borderSizeEntry = entry["borderBoxSize"];
+          const borderSize = Array.isArray(borderSizeEntry) ? borderSizeEntry[0] : borderSizeEntry;
+          width = borderSize["inlineSize"];
+          height = borderSize["blockSize"];
+        } else {
+          width = element.offsetWidth;
+          height = element.offsetHeight;
+        }
+        setSize({ width, height });
+      });
+      resizeObserver.observe(element, { box: "border-box" });
+      return () => resizeObserver.unobserve(element);
+    } else {
+      setSize(void 0);
+    }
+  }, [element]);
+  return size;
+}
+
+// node_modules/@radix-ui/react-presence/dist/index.mjs
+var React23 = __toESM(require("react"), 1);
+var React7 = __toESM(require("react"), 1);
+function useStateMachine(initialState, machine) {
+  return React7.useReducer((state, event) => {
+    const nextState = machine[state][event];
+    return nextState ?? state;
+  }, initialState);
+}
+var Presence = (props) => {
+  const { present, children } = props;
+  const presence = usePresence(present);
+  const child = typeof children === "function" ? children({ present: presence.isPresent }) : React23.Children.only(children);
+  const ref = useComposedRefs(presence.ref, getElementRef(child));
+  const forceMount = typeof children === "function";
+  return forceMount || presence.isPresent ? React23.cloneElement(child, { ref }) : null;
+};
+Presence.displayName = "Presence";
+function usePresence(present) {
+  const [node, setNode] = React23.useState();
+  const stylesRef = React23.useRef(null);
+  const prevPresentRef = React23.useRef(present);
+  const prevAnimationNameRef = React23.useRef("none");
+  const initialState = present ? "mounted" : "unmounted";
+  const [state, send] = useStateMachine(initialState, {
+    mounted: {
+      UNMOUNT: "unmounted",
+      ANIMATION_OUT: "unmountSuspended"
+    },
+    unmountSuspended: {
+      MOUNT: "mounted",
+      ANIMATION_END: "unmounted"
+    },
+    unmounted: {
+      MOUNT: "mounted"
+    }
+  });
+  React23.useEffect(() => {
+    const currentAnimationName = getAnimationName(stylesRef.current);
+    prevAnimationNameRef.current = state === "mounted" ? currentAnimationName : "none";
+  }, [state]);
+  useLayoutEffect2(() => {
+    const styles = stylesRef.current;
+    const wasPresent = prevPresentRef.current;
+    const hasPresentChanged = wasPresent !== present;
+    if (hasPresentChanged) {
+      const prevAnimationName = prevAnimationNameRef.current;
+      const currentAnimationName = getAnimationName(styles);
+      if (present) {
+        send("MOUNT");
+      } else if (currentAnimationName === "none" || styles?.display === "none") {
+        send("UNMOUNT");
+      } else {
+        const isAnimating = prevAnimationName !== currentAnimationName;
+        if (wasPresent && isAnimating) {
+          send("ANIMATION_OUT");
+        } else {
+          send("UNMOUNT");
+        }
+      }
+      prevPresentRef.current = present;
+    }
+  }, [present, send]);
+  useLayoutEffect2(() => {
+    if (node) {
+      let timeoutId;
+      const ownerWindow = node.ownerDocument.defaultView ?? window;
+      const handleAnimationEnd = (event) => {
+        const currentAnimationName = getAnimationName(stylesRef.current);
+        const isCurrentAnimation = currentAnimationName.includes(event.animationName);
+        if (event.target === node && isCurrentAnimation) {
+          send("ANIMATION_END");
+          if (!prevPresentRef.current) {
+            const currentFillMode = node.style.animationFillMode;
+            node.style.animationFillMode = "forwards";
+            timeoutId = ownerWindow.setTimeout(() => {
+              if (node.style.animationFillMode === "forwards") {
+                node.style.animationFillMode = currentFillMode;
+              }
+            });
+          }
+        }
+      };
+      const handleAnimationStart = (event) => {
+        if (event.target === node) {
+          prevAnimationNameRef.current = getAnimationName(stylesRef.current);
+        }
+      };
+      node.addEventListener("animationstart", handleAnimationStart);
+      node.addEventListener("animationcancel", handleAnimationEnd);
+      node.addEventListener("animationend", handleAnimationEnd);
+      return () => {
+        ownerWindow.clearTimeout(timeoutId);
+        node.removeEventListener("animationstart", handleAnimationStart);
+        node.removeEventListener("animationcancel", handleAnimationEnd);
+        node.removeEventListener("animationend", handleAnimationEnd);
+      };
+    } else {
+      send("ANIMATION_END");
+    }
+  }, [node, send]);
+  return {
+    isPresent: ["mounted", "unmountSuspended"].includes(state),
+    ref: React23.useCallback((node2) => {
+      stylesRef.current = node2 ? getComputedStyle(node2) : null;
+      setNode(node2);
+    }, [])
+  };
+}
+function getAnimationName(styles) {
+  return styles?.animationName || "none";
+}
+function getElementRef(element) {
+  let getter = Object.getOwnPropertyDescriptor(element.props, "ref")?.get;
+  let mayWarn = getter && "isReactWarning" in getter && getter.isReactWarning;
+  if (mayWarn) {
+    return element.ref;
+  }
+  getter = Object.getOwnPropertyDescriptor(element, "ref")?.get;
+  mayWarn = getter && "isReactWarning" in getter && getter.isReactWarning;
+  if (mayWarn) {
+    return element.props.ref;
+  }
+  return element.props.ref || element.ref;
+}
+
+// node_modules/@radix-ui/react-primitive/dist/index.mjs
+var React9 = __toESM(require("react"), 1);
+var ReactDOM = __toESM(require("react-dom"), 1);
+
+// node_modules/@radix-ui/react-slot/dist/index.mjs
+var React8 = __toESM(require("react"), 1);
+var import_jsx_runtime2 = require("react/jsx-runtime");
+// @__NO_SIDE_EFFECTS__
+function createSlot(ownerName) {
+  const SlotClone = /* @__PURE__ */ createSlotClone(ownerName);
+  const Slot2 = React8.forwardRef((props, forwardedRef) => {
+    const { children, ...slotProps } = props;
+    const childrenArray = React8.Children.toArray(children);
+    const slottable = childrenArray.find(isSlottable);
+    if (slottable) {
+      const newElement = slottable.props.children;
+      const newChildren = childrenArray.map((child) => {
+        if (child === slottable) {
+          if (React8.Children.count(newElement) > 1) return React8.Children.only(null);
+          return React8.isValidElement(newElement) ? newElement.props.children : null;
+        } else {
+          return child;
+        }
+      });
+      return /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(SlotClone, { ...slotProps, ref: forwardedRef, children: React8.isValidElement(newElement) ? React8.cloneElement(newElement, void 0, newChildren) : null });
+    }
+    return /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(SlotClone, { ...slotProps, ref: forwardedRef, children });
+  });
+  Slot2.displayName = `${ownerName}.Slot`;
+  return Slot2;
+}
+// @__NO_SIDE_EFFECTS__
+function createSlotClone(ownerName) {
+  const SlotClone = React8.forwardRef((props, forwardedRef) => {
+    const { children, ...slotProps } = props;
+    if (React8.isValidElement(children)) {
+      const childrenRef = getElementRef2(children);
+      const props2 = mergeProps(slotProps, children.props);
+      if (children.type !== React8.Fragment) {
+        props2.ref = forwardedRef ? composeRefs(forwardedRef, childrenRef) : childrenRef;
+      }
+      return React8.cloneElement(children, props2);
+    }
+    return React8.Children.count(children) > 1 ? React8.Children.only(null) : null;
+  });
+  SlotClone.displayName = `${ownerName}.SlotClone`;
+  return SlotClone;
+}
+var SLOTTABLE_IDENTIFIER = Symbol("radix.slottable");
+function isSlottable(child) {
+  return React8.isValidElement(child) && typeof child.type === "function" && "__radixId" in child.type && child.type.__radixId === SLOTTABLE_IDENTIFIER;
+}
+function mergeProps(slotProps, childProps) {
+  const overrideProps = { ...childProps };
+  for (const propName in childProps) {
+    const slotPropValue = slotProps[propName];
+    const childPropValue = childProps[propName];
+    const isHandler = /^on[A-Z]/.test(propName);
+    if (isHandler) {
+      if (slotPropValue && childPropValue) {
+        overrideProps[propName] = (...args) => {
+          const result = childPropValue(...args);
+          slotPropValue(...args);
+          return result;
+        };
+      } else if (slotPropValue) {
+        overrideProps[propName] = slotPropValue;
+      }
+    } else if (propName === "style") {
+      overrideProps[propName] = { ...slotPropValue, ...childPropValue };
+    } else if (propName === "className") {
+      overrideProps[propName] = [slotPropValue, childPropValue].filter(Boolean).join(" ");
+    }
+  }
+  return { ...slotProps, ...overrideProps };
+}
+function getElementRef2(element) {
+  let getter = Object.getOwnPropertyDescriptor(element.props, "ref")?.get;
+  let mayWarn = getter && "isReactWarning" in getter && getter.isReactWarning;
+  if (mayWarn) {
+    return element.ref;
+  }
+  getter = Object.getOwnPropertyDescriptor(element, "ref")?.get;
+  mayWarn = getter && "isReactWarning" in getter && getter.isReactWarning;
+  if (mayWarn) {
+    return element.props.ref;
+  }
+  return element.props.ref || element.ref;
+}
+
+// node_modules/@radix-ui/react-primitive/dist/index.mjs
+var import_jsx_runtime3 = require("react/jsx-runtime");
+var NODES = [
+  "a",
+  "button",
+  "div",
+  "form",
+  "h2",
+  "h3",
+  "img",
+  "input",
+  "label",
+  "li",
+  "nav",
+  "ol",
+  "p",
+  "select",
+  "span",
+  "svg",
+  "ul"
+];
+var Primitive = NODES.reduce((primitive, node) => {
+  const Slot = createSlot(`Primitive.${node}`);
+  const Node2 = React9.forwardRef((props, forwardedRef) => {
+    const { asChild, ...primitiveProps } = props;
+    const Comp = asChild ? Slot : node;
+    if (typeof window !== "undefined") {
+      window[Symbol.for("radix-ui")] = true;
+    }
+    return /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(Comp, { ...primitiveProps, ref: forwardedRef });
+  });
+  Node2.displayName = `Primitive.${node}`;
+  return { ...primitive, [node]: Node2 };
+}, {});
+
+// node_modules/@radix-ui/react-checkbox/dist/index.mjs
+var import_jsx_runtime4 = require("react/jsx-runtime");
+var CHECKBOX_NAME = "Checkbox";
+var [createCheckboxContext, createCheckboxScope] = createContextScope(CHECKBOX_NAME);
+var [CheckboxProviderImpl, useCheckboxContext] = createCheckboxContext(CHECKBOX_NAME);
+function CheckboxProvider(props) {
+  const {
+    __scopeCheckbox,
+    checked: checkedProp,
+    children,
+    defaultChecked,
+    disabled,
+    form,
+    name,
+    onCheckedChange,
+    required,
+    value = "on",
+    // @ts-expect-error
+    internal_do_not_use_render
+  } = props;
+  const [checked, setChecked] = useControllableState({
+    prop: checkedProp,
+    defaultProp: defaultChecked ?? false,
+    onChange: onCheckedChange,
+    caller: CHECKBOX_NAME
+  });
+  const [control, setControl] = React10.useState(null);
+  const [bubbleInput, setBubbleInput] = React10.useState(null);
+  const hasConsumerStoppedPropagationRef = React10.useRef(false);
+  const isFormControl = control ? !!form || !!control.closest("form") : (
+    // We set this to true by default so that events bubble to forms without JS (SSR)
+    true
+  );
+  const context = {
+    checked,
+    disabled,
+    setChecked,
+    control,
+    setControl,
+    name,
+    form,
+    value,
+    hasConsumerStoppedPropagationRef,
+    required,
+    defaultChecked: isIndeterminate(defaultChecked) ? false : defaultChecked,
+    isFormControl,
+    bubbleInput,
+    setBubbleInput
+  };
+  return /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(
+    CheckboxProviderImpl,
+    {
+      scope: __scopeCheckbox,
+      ...context,
+      children: isFunction2(internal_do_not_use_render) ? internal_do_not_use_render(context) : children
+    }
+  );
+}
+var TRIGGER_NAME = "CheckboxTrigger";
+var CheckboxTrigger = React10.forwardRef(
+  ({ __scopeCheckbox, onKeyDown, onClick, ...checkboxProps }, forwardedRef) => {
+    const {
+      control,
+      value,
+      disabled,
+      checked,
+      required,
+      setControl,
+      setChecked,
+      hasConsumerStoppedPropagationRef,
+      isFormControl,
+      bubbleInput
+    } = useCheckboxContext(TRIGGER_NAME, __scopeCheckbox);
+    const composedRefs = useComposedRefs(forwardedRef, setControl);
+    const initialCheckedStateRef = React10.useRef(checked);
+    React10.useEffect(() => {
+      const form = control?.form;
+      if (form) {
+        const reset = () => setChecked(initialCheckedStateRef.current);
+        form.addEventListener("reset", reset);
+        return () => form.removeEventListener("reset", reset);
+      }
+    }, [control, setChecked]);
+    return /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(
+      Primitive.button,
+      {
+        type: "button",
+        role: "checkbox",
+        "aria-checked": isIndeterminate(checked) ? "mixed" : checked,
+        "aria-required": required,
+        "data-state": getState(checked),
+        "data-disabled": disabled ? "" : void 0,
+        disabled,
+        value,
+        ...checkboxProps,
+        ref: composedRefs,
+        onKeyDown: composeEventHandlers(onKeyDown, (event) => {
+          if (event.key === "Enter") event.preventDefault();
+        }),
+        onClick: composeEventHandlers(onClick, (event) => {
+          setChecked((prevChecked) => isIndeterminate(prevChecked) ? true : !prevChecked);
+          if (bubbleInput && isFormControl) {
+            hasConsumerStoppedPropagationRef.current = event.isPropagationStopped();
+            if (!hasConsumerStoppedPropagationRef.current) event.stopPropagation();
+          }
+        })
+      }
+    );
+  }
+);
+CheckboxTrigger.displayName = TRIGGER_NAME;
+var Checkbox = React10.forwardRef(
+  (props, forwardedRef) => {
+    const {
+      __scopeCheckbox,
+      name,
+      checked,
+      defaultChecked,
+      required,
+      disabled,
+      value,
+      onCheckedChange,
+      form,
+      ...checkboxProps
+    } = props;
+    return /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(
+      CheckboxProvider,
+      {
+        __scopeCheckbox,
+        checked,
+        defaultChecked,
+        disabled,
+        required,
+        onCheckedChange,
+        name,
+        form,
+        value,
+        internal_do_not_use_render: ({ isFormControl }) => /* @__PURE__ */ (0, import_jsx_runtime4.jsxs)(import_jsx_runtime4.Fragment, { children: [
+          /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(
+            CheckboxTrigger,
+            {
+              ...checkboxProps,
+              ref: forwardedRef,
+              __scopeCheckbox
+            }
+          ),
+          isFormControl && /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(
+            CheckboxBubbleInput,
+            {
+              __scopeCheckbox
+            }
+          )
+        ] })
+      }
+    );
+  }
+);
+Checkbox.displayName = CHECKBOX_NAME;
+var INDICATOR_NAME = "CheckboxIndicator";
+var CheckboxIndicator = React10.forwardRef(
+  (props, forwardedRef) => {
+    const { __scopeCheckbox, forceMount, ...indicatorProps } = props;
+    const context = useCheckboxContext(INDICATOR_NAME, __scopeCheckbox);
+    return /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(
+      Presence,
+      {
+        present: forceMount || isIndeterminate(context.checked) || context.checked === true,
+        children: /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(
+          Primitive.span,
+          {
+            "data-state": getState(context.checked),
+            "data-disabled": context.disabled ? "" : void 0,
+            ...indicatorProps,
+            ref: forwardedRef,
+            style: { pointerEvents: "none", ...props.style }
+          }
+        )
+      }
+    );
+  }
+);
+CheckboxIndicator.displayName = INDICATOR_NAME;
+var BUBBLE_INPUT_NAME = "CheckboxBubbleInput";
+var CheckboxBubbleInput = React10.forwardRef(
+  ({ __scopeCheckbox, ...props }, forwardedRef) => {
+    const {
+      control,
+      hasConsumerStoppedPropagationRef,
+      checked,
+      defaultChecked,
+      required,
+      disabled,
+      name,
+      value,
+      form,
+      bubbleInput,
+      setBubbleInput
+    } = useCheckboxContext(BUBBLE_INPUT_NAME, __scopeCheckbox);
+    const composedRefs = useComposedRefs(forwardedRef, setBubbleInput);
+    const prevChecked = usePrevious(checked);
+    const controlSize = useSize(control);
+    React10.useEffect(() => {
+      const input = bubbleInput;
+      if (!input) return;
+      const inputProto = window.HTMLInputElement.prototype;
+      const descriptor = Object.getOwnPropertyDescriptor(
+        inputProto,
+        "checked"
+      );
+      const setChecked = descriptor.set;
+      const bubbles = !hasConsumerStoppedPropagationRef.current;
+      if (prevChecked !== checked && setChecked) {
+        const event = new Event("click", { bubbles });
+        input.indeterminate = isIndeterminate(checked);
+        setChecked.call(input, isIndeterminate(checked) ? false : checked);
+        input.dispatchEvent(event);
+      }
+    }, [bubbleInput, prevChecked, checked, hasConsumerStoppedPropagationRef]);
+    const defaultCheckedRef = React10.useRef(isIndeterminate(checked) ? false : checked);
+    return /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(
+      Primitive.input,
+      {
+        type: "checkbox",
+        "aria-hidden": true,
+        defaultChecked: defaultChecked ?? defaultCheckedRef.current,
+        required,
+        disabled,
+        name,
+        value,
+        form,
+        ...props,
+        tabIndex: -1,
+        ref: composedRefs,
+        style: {
+          ...props.style,
+          ...controlSize,
+          position: "absolute",
+          pointerEvents: "none",
+          opacity: 0,
+          margin: 0,
+          // We transform because the input is absolutely positioned but we have
+          // rendered it **after** the button. This pulls it back to sit on top
+          // of the button.
+          transform: "translateX(-100%)"
+        }
+      }
+    );
+  }
+);
+CheckboxBubbleInput.displayName = BUBBLE_INPUT_NAME;
+function isFunction2(value) {
+  return typeof value === "function";
+}
+function isIndeterminate(checked) {
+  return checked === "indeterminate";
+}
+function getState(checked) {
+  return isIndeterminate(checked) ? "indeterminate" : checked ? "checked" : "unchecked";
+}
+
+// src/components/user-action/Checkbox.tsx
+var import_jsx_runtime5 = require("react/jsx-runtime");
+var checkboxSizeMapping = {
+  sm: "size-5 border-1",
+  md: "size-6 border-1",
+  lg: "size-8 border-2"
+};
+var checkboxIconSizeMapping = {
+  sm: "size-4 stroke-3",
+  md: "size-5 stroke-3",
+  lg: "size-7 stroke-3"
+};
+var Checkbox2 = ({
+  disabled,
+  checked = false,
+  indeterminate = false,
+  onChange,
+  size = "md",
+  className = "",
+  ...props
+}) => {
+  const usedSizeClass = checkboxSizeMapping[size];
+  const innerIconSize = checkboxIconSizeMapping[size];
+  return /* @__PURE__ */ (0, import_jsx_runtime5.jsx)(
+    Checkbox,
+    {
+      ...props,
+      disabled,
+      checked: indeterminate ? "indeterminate" : checked,
+      onCheckedChange: onChange,
+      className: (0, import_clsx.default)(
+        usedSizeClass,
+        `flex-col-0 items-center justify-center rounded outline-none`,
+        {
+          "text-disabled-text border-disabled-outline bg-disabled-background cursor-not-allowed": disabled,
+          "hover:border-primary": !disabled,
+          "bg-input-background": !disabled && !checked,
+          "bg-primary/30 border-primary text-primary": !disabled && (checked || indeterminate)
+        },
+        className
+      ),
+      children: /* @__PURE__ */ (0, import_jsx_runtime5.jsxs)(CheckboxIndicator, { children: [
+        !checked && !indeterminate && /* @__PURE__ */ (0, import_jsx_runtime5.jsx)("div", { className: (0, import_clsx.default)("bg-input-background", innerIconSize) }),
+        checked && !indeterminate && /* @__PURE__ */ (0, import_jsx_runtime5.jsx)(import_lucide_react.Check, { className: innerIconSize }),
+        indeterminate && /* @__PURE__ */ (0, import_jsx_runtime5.jsx)(import_lucide_react.Minus, { className: innerIconSize })
+      ] })
+    }
+  );
+};
+
+// src/localization/LanguageProvider.tsx
+var import_react3 = require("react");
+
+// src/hooks/useLocalStorage.ts
+var import_react2 = require("react");
+
+// src/localization/util.ts
+var languages = ["en", "de"];
+var languagesLocalNames = {
+  en: "English",
+  de: "Deutsch"
+};
+var DEFAULT_LANGUAGE = "en";
+var LanguageUtil = {
+  languages,
+  DEFAULT_LANGUAGE,
+  languagesLocalNames
+};
+
+// src/localization/LanguageProvider.tsx
+var import_jsx_runtime6 = require("react/jsx-runtime");
+var LanguageContext = (0, import_react3.createContext)({
+  language: LanguageUtil.DEFAULT_LANGUAGE,
+  setLanguage: (v) => v
+});
+var useLanguage = () => (0, import_react3.useContext)(LanguageContext);
+
+// src/localization/useTranslation.ts
+var TranslationPluralCount = {
+  zero: 0,
+  one: 1,
+  two: 2,
+  few: 3,
+  many: 11,
+  other: -1
+};
+var useTranslation = (translations, overwriteTranslation = {}) => {
+  const { language: languageProp, translation: overwrite } = overwriteTranslation;
+  const { language: inferredLanguage } = useLanguage();
+  const usedLanguage = languageProp ?? inferredLanguage;
+  const usedTranslations = [...translations];
+  if (overwrite) {
+    usedTranslations.push(overwrite);
+  }
+  return (key, options) => {
+    const { count, replacements } = { ...{ count: 0, replacements: {} }, ...options };
+    try {
+      for (let i = translations.length - 1; i >= 0; i--) {
+        const translation = translations[i];
+        const localizedTranslation = translation[usedLanguage];
+        if (!localizedTranslation) {
+          continue;
+        }
+        const value = localizedTranslation[key];
+        if (!value) {
+          continue;
+        }
+        let forProcessing;
+        if (typeof value !== "string") {
+          if (count === TranslationPluralCount.zero && value?.zero) {
+            forProcessing = value.zero;
+          } else if (count === TranslationPluralCount.one && value?.one) {
+            forProcessing = value.one;
+          } else if (count === TranslationPluralCount.two && value?.two) {
+            forProcessing = value.two;
+          } else if (TranslationPluralCount.few <= count && count < TranslationPluralCount.many && value?.few) {
+            forProcessing = value.few;
+          } else if (count > TranslationPluralCount.many && value?.many) {
+            forProcessing = value.many;
+          } else {
+            forProcessing = value.other;
+          }
+        } else {
+          forProcessing = value;
+        }
+        forProcessing = forProcessing.replace(/\{\{(\w+)}}/g, (_, placeholder) => {
+          return replacements[placeholder] ?? `{{key:${placeholder}}}`;
+        });
+        return forProcessing;
+      }
+    } catch (e) {
+      console.error(e);
+    }
+    return `{{${usedLanguage}:${key}}}`;
+  };
+};
+
+// src/components/properties/PropertyBase.tsx
+var import_lucide_react2 = require("lucide-react");
+var import_clsx3 = __toESM(require("clsx"));
+
+// src/components/user-action/Button.tsx
+var import_react4 = require("react");
+var import_clsx2 = __toESM(require("clsx"));
+var import_jsx_runtime7 = require("react/jsx-runtime");
+var ButtonColorUtil = {
+  solid: ["primary", "secondary", "tertiary", "positive", "warning", "negative", "neutral"],
+  text: ["primary", "negative", "neutral"],
+  outline: ["primary"]
+};
+var IconButtonUtil = {
+  icon: [...ButtonColorUtil.solid, "transparent"]
+};
+var paddingMapping = {
+  small: "btn-sm",
+  medium: "btn-md",
+  large: "btn-lg"
+};
+var iconPaddingMapping = {
+  tiny: "icon-btn-xs",
+  small: "icon-btn-sm",
+  medium: "icon-btn-md",
+  large: "icon-btn-lg"
+};
+var ButtonUtil = {
+  paddingMapping,
+  iconPaddingMapping
+};
+var SolidButton = (0, import_react4.forwardRef)(function SolidButton2({
+  children,
+  color = "primary",
+  size = "medium",
+  startIcon,
+  endIcon,
+  onClick,
+  className,
+  ...restProps
+}, ref) {
+  const colorClasses = {
+    primary: "not-disabled:bg-button-solid-primary-background not-disabled:text-button-solid-primary-text",
+    secondary: "not-disabled:bg-button-solid-secondary-background not-disabled:text-button-solid-secondary-text",
+    tertiary: "not-disabled:bg-button-solid-tertiary-background not-disabled:text-button-solid-tertiary-text",
+    positive: "not-disabled:bg-button-solid-positive-background not-disabled:text-button-solid-positive-text",
+    warning: "not-disabled:bg-button-solid-warning-background not-disabled:text-button-solid-warning-text",
+    negative: "not-disabled:bg-button-solid-negative-background not-disabled:text-button-solid-negative-text",
+    neutral: "not-disabled:bg-button-solid-neutral-background not-disabled:text-button-solid-neutral-text"
+  }[color];
+  const iconColorClasses = {
+    primary: "not-group-disabled:text-button-solid-primary-icon",
+    secondary: "not-group-disabled:text-button-solid-secondary-icon",
+    tertiary: "not-group-disabled:text-button-solid-tertiary-icon",
+    positive: "not-group-disabled:text-button-solid-positive-icon",
+    warning: "not-group-disabled:text-button-solid-warning-icon",
+    negative: "not-group-disabled:text-button-solid-negative-icon",
+    neutral: "not-group-disabled:text-button-solid-neutral-icon"
+  }[color];
+  return /* @__PURE__ */ (0, import_jsx_runtime7.jsxs)(
+    "button",
+    {
+      ref,
+      onClick,
+      className: (0, import_clsx2.default)(
+        "group font-semibold",
+        colorClasses,
+        "not-disabled:hover:brightness-90",
+        "disabled:text-disabled-text disabled:bg-disabled-background",
+        ButtonUtil.paddingMapping[size],
+        className
+      ),
+      ...restProps,
+      children: [
+        startIcon && /* @__PURE__ */ (0, import_jsx_runtime7.jsx)(
+          "span",
+          {
+            className: (0, import_clsx2.default)(
+              iconColorClasses,
+              "group-disabled:text-disabled-icon"
+            ),
+            children: startIcon
+          }
+        ),
+        children,
+        endIcon && /* @__PURE__ */ (0, import_jsx_runtime7.jsx)(
+          "span",
+          {
+            className: (0, import_clsx2.default)(
+              iconColorClasses,
+              "group-disabled:text-disabled-icon"
+            ),
+            children: endIcon
+          }
+        )
+      ]
+    }
+  );
+});
+var TextButton = ({
+  children,
+  color = "neutral",
+  size = "medium",
+  startIcon,
+  endIcon,
+  onClick,
+  coloredHoverBackground = true,
+  className,
+  ...restProps
+}) => {
+  const colorClasses = {
+    primary: "not-disabled:bg-transparent not-disabled:text-button-text-primary-text focus-style-none focus-visible:ring-2 not-disabled:focus-visible:ring-button-text-primary-text",
+    negative: "not-disabled:bg-transparent not-disabled:text-button-text-negative-text focus-style-none focus-visible:ring-2 not-disabled:focus-visible:ring-button-text-negative-text",
+    neutral: "not-disabled:bg-transparent not-disabled:text-button-text-neutral-text focus-style-none focus-visible:ring-2 not-disabled:focus-visible:ring-button-text-neutral-text"
+  }[color];
+  const backgroundColor = {
+    primary: "not-disabled:hover:bg-button-text-primary-text/20 not-disabled:focus-visible:bg-button-text-primary-text/20",
+    negative: "not-disabled:hover:bg-button-text-negative-text/20 not-disabled:focus-visible:bg-button-text-negative-text/20",
+    neutral: "not-disabled:hover:bg-button-text-neutral-text/20 not-disabled:focus-visible:bg-button-text-neutral-text/20"
+  }[color];
+  const iconColorClasses = {
+    primary: "not-group-disabled:text-button-text-primary-icon",
+    negative: "not-group-disabled:text-button-text-negative-icon",
+    neutral: "not-group-disabled:text-button-text-neutral-icon"
+  }[color];
+  return /* @__PURE__ */ (0, import_jsx_runtime7.jsxs)(
+    "button",
+    {
+      onClick,
+      className: (0, import_clsx2.default)(
+        "group font-semibold",
+        "disabled:text-disabled-text",
+        colorClasses,
+        {
+          [backgroundColor]: coloredHoverBackground,
+          "not-disabled:hover:bg-button-text-hover-background": !coloredHoverBackground
+        },
+        ButtonUtil.paddingMapping[size],
+        className
+      ),
+      ...restProps,
+      children: [
+        startIcon && /* @__PURE__ */ (0, import_jsx_runtime7.jsx)(
+          "span",
+          {
+            className: (0, import_clsx2.default)(
+              iconColorClasses,
+              "group-disabled:text-disabled-icon"
+            ),
+            children: startIcon
+          }
+        ),
+        children,
+        endIcon && /* @__PURE__ */ (0, import_jsx_runtime7.jsx)(
+          "span",
+          {
+            className: (0, import_clsx2.default)(
+              iconColorClasses,
+              "group-disabled:text-disabled-icon"
+            ),
+            children: endIcon
+          }
+        )
+      ]
+    }
+  );
+};
+var IconButton = (0, import_react4.forwardRef)(function IconButton2({
+  children,
+  color = "primary",
+  size = "medium",
+  className,
+  ...restProps
+}, ref) {
+  const colorClasses = {
+    primary: "not-disabled:bg-button-solid-primary-background not-disabled:text-button-solid-primary-text",
+    secondary: "not-disabled:bg-button-solid-secondary-background not-disabled:text-button-solid-secondary-text",
+    tertiary: "not-disabled:bg-button-solid-tertiary-background not-disabled:text-button-solid-tertiary-text",
+    positive: "not-disabled:bg-button-solid-positive-background not-disabled:text-button-solid-positive-text",
+    warning: "not-disabled:bg-button-solid-warning-background not-disabled:text-button-solid-warning-text",
+    negative: "not-disabled:bg-button-solid-negative-background not-disabled:text-button-solid-negative-text",
+    neutral: "not-disabled:bg-button-solid-neutral-background not-disabled:text-button-solid-neutral-text",
+    transparent: "not-disabled:bg-transparent"
+  }[color];
+  return /* @__PURE__ */ (0, import_jsx_runtime7.jsx)(
+    "button",
+    {
+      ref,
+      className: (0, import_clsx2.default)(
+        colorClasses,
+        "not-disabled:hover:brightness-90",
+        "disabled:text-disabled-text",
+        {
+          "disabled:bg-disabled-background": color !== "transparent",
+          "disabled:opacity-70": color === "transparent",
+          "not-disabled:hover:bg-button-text-hover-background": color === "transparent"
+        },
+        ButtonUtil.iconPaddingMapping[size],
+        className
+      ),
+      ...restProps,
+      children
+    }
+  );
+});
+
+// src/localization/defaults/form.ts
+var formTranslation = {
+  en: {
+    add: "Add",
+    all: "All",
+    apply: "Apply",
+    back: "Back",
+    cancel: "Cancel",
+    change: "Change",
+    clear: "Clear",
+    click: "Click",
+    clickToCopy: "Click to Copy",
+    close: "Close",
+    confirm: "Confirm",
+    copy: "Copy",
+    copied: "Copied",
+    create: "Create",
+    decline: "Decline",
+    delete: "Delete",
+    discard: "Discard",
+    discardChanges: "Discard Changes",
+    done: "Done",
+    edit: "Edit",
+    enterText: "Enter text here",
+    error: "Error",
+    exit: "Exit",
+    fieldRequiredError: "This field is required.",
+    invalidEmailError: "Please enter a valid email address.",
+    less: "Less",
+    loading: "Loading",
+    maxLengthError: "Maximum length exceeded.",
+    minLengthError: "Minimum length not met.",
+    more: "More",
+    next: "Next",
+    no: "No",
+    none: "None",
+    nothingFound: "Nothing found",
+    of: "of",
+    optional: "Optional",
+    pleaseWait: "Please wait...",
+    previous: "Previous",
+    remove: "Remove",
+    required: "Required",
+    reset: "Reset",
+    save: "Save",
+    saved: "Saved",
+    search: "Search",
+    select: "Select",
+    selectOption: "Select an option",
+    show: "Show",
+    showMore: "Show more",
+    showLess: "Show less",
+    submit: "Submit",
+    success: "Success",
+    update: "Update",
+    unsavedChanges: "Unsaved Changes",
+    unsavedChangesSaveQuestion: "Do you want to save your changes?",
+    yes: "Yes"
+  },
+  de: {
+    add: "Hinzuf\xFCgen",
+    all: "Alle",
+    apply: "Anwenden",
+    back: "Zur\xFCck",
+    cancel: "Abbrechen",
+    change: "\xC4ndern",
+    clear: "L\xF6schen",
+    click: "Klicken",
+    clickToCopy: "Zum kopieren klicken",
+    close: "Schlie\xDFen",
+    confirm: "Best\xE4tigen",
+    copy: "Kopieren",
+    copied: "Kopiert",
+    create: "Erstellen",
+    decline: "Ablehnen",
+    delete: "L\xF6schen",
+    discard: "Verwerfen",
+    discardChanges: "\xC4nderungen Verwerfen",
+    done: "Fertig",
+    edit: "Bearbeiten",
+    enterText: "Text hier eingeben",
+    error: "Fehler",
+    exit: "Beenden",
+    fieldRequiredError: "Dieses Feld ist erforderlich.",
+    invalidEmailError: "Bitte geben Sie eine g\xFCltige E-Mail-Adresse ein.",
+    less: "Weniger",
+    loading: "L\xE4dt",
+    maxLengthError: "Maximale L\xE4nge \xFCberschritten.",
+    minLengthError: "Mindestl\xE4nge nicht erreicht.",
+    more: "Mehr",
+    next: "Weiter",
+    no: "Nein",
+    none: "Nichts",
+    nothingFound: "Nichts gefunden",
+    of: "von",
+    optional: "Optional",
+    pleaseWait: "Bitte warten...",
+    previous: "Vorherige",
+    remove: "Entfernen",
+    required: "Erforderlich",
+    reset: "Zur\xFCcksetzen",
+    save: "Speichern",
+    saved: "Gespeichert",
+    search: "Suche",
+    select: "Select",
+    selectOption: "Option ausw\xE4hlen",
+    show: "Anzeigen",
+    showMore: "Mehr anzeigen",
+    showLess: "Weniger anzeigen",
+    submit: "Abschicken",
+    success: "Erfolg",
+    update: "Update",
+    unsavedChanges: "Ungespeicherte \xC4nderungen",
+    unsavedChangesSaveQuestion: "M\xF6chtest du die \xC4nderungen speichern?",
+    yes: "Ja"
+  }
+};
+
+// src/components/properties/PropertyBase.tsx
+var import_jsx_runtime8 = require("react/jsx-runtime");
+var PropertyBase = ({
+  overwriteTranslation,
+  name,
+  input,
+  softRequired = false,
+  hasValue,
+  icon,
+  readOnly,
+  onRemove,
+  className = ""
+}) => {
+  const translation = useTranslation([formTranslation], overwriteTranslation);
+  const requiredAndNoValue = softRequired && !hasValue;
+  return /* @__PURE__ */ (0, import_jsx_runtime8.jsxs)("div", { className: (0, import_clsx3.default)("flex-row-0 group", className), children: [
+    /* @__PURE__ */ (0, import_jsx_runtime8.jsxs)(
+      "div",
+      {
+        className: (0, import_clsx3.default)(
+          "flex-row-2 max-w-48 min-w-48 px-3 py-2 items-center rounded-l-xl border-2 border-r-0",
+          {
+            "bg-property-title-background text-property-title-text group-hover:border-primary": !requiredAndNoValue,
+            "bg-warning text-surface-warning group-hover:border-warning border-warning/90": requiredAndNoValue
+          },
+          className
+        ),
+        children: [
+          /* @__PURE__ */ (0, import_jsx_runtime8.jsx)("div", { className: "max-w-6 min-w-6 text-text-primary", children: icon }),
+          /* @__PURE__ */ (0, import_jsx_runtime8.jsx)("span", { className: "font-semibold", children: name })
+        ]
+      }
+    ),
+    /* @__PURE__ */ (0, import_jsx_runtime8.jsxs)(
+      "div",
+      {
+        className: (0, import_clsx3.default)(
+          "flex-row-2 grow px-3 py-2 justify-between items-center rounded-r-xl border-2 border-l-0 min-h-15",
+          {
+            "bg-input-background text-input-text group-hover:border-primary": !requiredAndNoValue,
+            "bg-surface-warning group-hover:border-warning border-warning/90": requiredAndNoValue
+          },
+          className
+        ),
+        children: [
+          input({ softRequired, hasValue }),
+          requiredAndNoValue && /* @__PURE__ */ (0, import_jsx_runtime8.jsx)("div", { className: "text-warning", children: /* @__PURE__ */ (0, import_jsx_runtime8.jsx)(import_lucide_react2.AlertTriangle, { size: 24 }) }),
+          onRemove && !readOnly && /* @__PURE__ */ (0, import_jsx_runtime8.jsx)(
+            TextButton,
+            {
+              onClick: onRemove,
+              color: "negative",
+              className: (0, import_clsx3.default)("items-center"),
+              disabled: !hasValue,
+              children: translation("remove")
+            }
+          )
+        ]
+      }
+    )
+  ] });
+};
+
+// src/components/properties/CheckboxProperty.tsx
+var import_react5 = require("react");
+
+// src/components/user-action/Label.tsx
+var import_clsx4 = __toESM(require("clsx"));
+var import_jsx_runtime9 = require("react/jsx-runtime");
+var styleMapping = {
+  sm: "typography-label-xs color-label-text",
+  md: "typography-label-md color-label-text"
+};
+var Label = ({
+  children,
+  size = "md",
+  className,
+  ...props
+}) => {
+  return /* @__PURE__ */ (0, import_jsx_runtime9.jsx)("label", { ...props, className: (0, import_clsx4.default)(styleMapping[size], className), children });
+};
+
+// src/components/properties/CheckboxProperty.tsx
+var import_jsx_runtime10 = require("react/jsx-runtime");
+var CheckboxProperty = ({
+  overwriteTranslation,
+  value,
+  onChange = noop,
+  readOnly,
+  ...baseProps
+}) => {
+  const translation = useTranslation([formTranslation], overwriteTranslation);
+  const id = (0, import_react5.useId)();
+  return /* @__PURE__ */ (0, import_jsx_runtime10.jsx)(
+    PropertyBase,
+    {
+      ...baseProps,
+      hasValue: true,
+      readOnly,
+      icon: /* @__PURE__ */ (0, import_jsx_runtime10.jsx)(import_lucide_react3.Check, { size: 24 }),
+      input: () => /* @__PURE__ */ (0, import_jsx_runtime10.jsxs)("div", { className: "flex-row-2 items-center", children: [
+        /* @__PURE__ */ (0, import_jsx_runtime10.jsx)(
+          Checkbox2,
+          {
+            id,
+            checked: value ?? true,
+            disabled: readOnly,
+            onChange,
+            "aria-labelledby": id + "label"
+          }
+        ),
+        /* @__PURE__ */ (0, import_jsx_runtime10.jsx)(Label, { id: id + "label", children: `${translation("yes")}/${translation("no")}` })
+      ] })
+    }
+  );
+};
+
+// src/components/properties/DateProperty.tsx
+var import_lucide_react4 = require("lucide-react");
+var import_clsx6 = __toESM(require("clsx"));
+
+// src/utils/date.ts
+var formatDate = (date) => {
+  const year = date.getFullYear().toString().padStart(4, "0");
+  const month = (date.getMonth() + 1).toString().padStart(2, "0");
+  const day = date.getDate().toString().padStart(2, "0");
+  return `${year}-${month}-${day}`;
+};
+var formatDateTime = (date) => {
+  const dateString = formatDate(date);
+  const hours = date.getHours().toString().padStart(2, "0");
+  const minutes = date.getMinutes().toString().padStart(2, "0");
+  return `${dateString}T${hours}:${minutes}`;
+};
+
+// src/components/user-action/input/Input.tsx
+var import_react8 = require("react");
+var import_clsx5 = __toESM(require("clsx"));
+
+// src/hooks/useDelay.ts
+var import_react6 = require("react");
+var defaultOptions = {
+  delay: 3e3,
+  disabled: false
+};
+function useDelay(options) {
+  const [timer, setTimer] = (0, import_react6.useState)(void 0);
+  const { delay, disabled } = {
+    ...defaultOptions,
+    ...options
+  };
+  const clearTimer = () => {
+    clearTimeout(timer);
+    setTimer(void 0);
+  };
+  const restartTimer = (onDelayFinish) => {
+    if (disabled) {
+      return;
+    }
+    clearTimeout(timer);
+    setTimer(setTimeout(() => {
+      onDelayFinish();
+      setTimer(void 0);
+    }, delay));
+  };
+  (0, import_react6.useEffect)(() => {
+    return () => {
+      clearTimeout(timer);
+    };
+  }, [timer]);
+  (0, import_react6.useEffect)(() => {
+    if (disabled) {
+      clearTimeout(timer);
+      setTimer(void 0);
+    }
+  }, [disabled, timer]);
+  return { restartTimer, clearTimer, hasActiveTimer: !!timer };
+}
+
+// src/hooks/focus/useFocusManagement.ts
+var import_react7 = require("react");
+function useFocusManagement() {
+  const getFocusableElements = (0, import_react7.useCallback)(() => {
+    return Array.from(
+      document.querySelectorAll(
+        'input, button, select, textarea, a[href], [tabindex]:not([tabindex="-1"])'
+      )
+    ).filter(
+      (el) => el instanceof HTMLElement && !el.hasAttribute("disabled") && !el.hasAttribute("hidden") && el.tabIndex !== -1
+    );
+  }, []);
+  const getNextFocusElement = (0, import_react7.useCallback)(() => {
+    const elements = getFocusableElements();
+    if (elements.length === 0) {
+      return void 0;
+    }
+    let nextElement = elements[0];
+    if (document.activeElement instanceof HTMLElement) {
+      const currentIndex = elements.indexOf(document.activeElement);
+      nextElement = elements[(currentIndex + 1) % elements.length];
+    }
+    return nextElement;
+  }, [getFocusableElements]);
+  const focusNext = (0, import_react7.useCallback)(() => {
+    const nextElement = getNextFocusElement();
+    nextElement?.focus();
+  }, [getNextFocusElement]);
+  const getPreviousFocusElement = (0, import_react7.useCallback)(() => {
+    const elements = getFocusableElements();
+    if (elements.length === 0) {
+      return void 0;
+    }
+    let previousElement = elements[0];
+    if (document.activeElement instanceof HTMLElement) {
+      const currentIndex = elements.indexOf(document.activeElement);
+      if (currentIndex === 0) {
+        previousElement = elements[elements.length - 1];
+      } else {
+        previousElement = elements[currentIndex - 1];
+      }
+    }
+    return previousElement;
+  }, [getFocusableElements]);
+  const focusPrevious = (0, import_react7.useCallback)(() => {
+    const previousElement = getPreviousFocusElement();
+    if (previousElement) previousElement.focus();
+  }, [getPreviousFocusElement]);
+  return {
+    getFocusableElements,
+    getNextFocusElement,
+    getPreviousFocusElement,
+    focusNext,
+    focusPrevious
+  };
+}
+
+// src/components/user-action/input/Input.tsx
+var import_jsx_runtime11 = require("react/jsx-runtime");
+var defaultEditCompleteOptions = {
+  allowEnterComplete: false,
+  onBlur: true,
+  afterDelay: true,
+  delay: 2500
+};
+var Input = (0, import_react8.forwardRef)(function Input2({
+  value,
+  onChange,
+  onChangeText,
+  onEditCompleted,
+  editCompleteOptions,
+  disabled = false,
+  invalid = false,
+  defaultStyle = true,
+  className,
+  ...props
+}, forwardedRef) {
+  const {
+    onBlur: allowEditCompleteOnBlur,
+    afterDelay,
+    delay,
+    allowEnterComplete
+  } = { ...defaultEditCompleteOptions, ...editCompleteOptions };
+  const {
+    restartTimer,
+    clearTimer
+  } = useDelay({ delay, disabled: !afterDelay });
+  const innerRef = (0, import_react8.useRef)(null);
+  (0, import_react8.useImperativeHandle)(forwardedRef, () => innerRef.current);
+  const { focusNext } = useFocusManagement();
+  return /* @__PURE__ */ (0, import_jsx_runtime11.jsx)(
+    "input",
+    {
+      ...props,
+      ref: innerRef,
+      value,
+      disabled,
+      className: defaultStyle ? (0, import_clsx5.default)(
+        "px-2.5 py-1.75 rounded-md border-1 text-sm",
+        {
+          "bg-input-background text-input-text hover:border-primary focus:border-primary": !disabled && !invalid,
+          "bg-on-negative text-negative border-negative-border hover:border-negative-border-hover focus-visible:ring-negative-border": !disabled && invalid,
+          "bg-disabled-background text-disabled-text border-disabled-border": disabled
+        },
+        className
+      ) : className,
+      onKeyDown: (event) => {
+        props.onKeyDown?.(event);
+        if (!allowEnterComplete) {
+          return;
+        }
+        if (event.key === "Enter" && !event.shiftKey) {
+          event.preventDefault();
+          innerRef.current?.blur();
+          onEditCompleted?.(event.target.value);
+          focusNext();
+        }
+      },
+      onBlur: (event) => {
+        props.onBlur?.(event);
+        if (allowEditCompleteOnBlur) {
+          onEditCompleted?.(event.target.value);
+          clearTimer();
+        }
+      },
+      onChange: (event) => {
+        onChange?.(event);
+        const value2 = event.target.value;
+        restartTimer(() => {
+          innerRef.current?.blur();
+          onEditCompleted?.(value2);
+        });
+        onChangeText?.(value2);
+      },
+      "aria-invalid": props["aria-invalid"] ?? invalid,
+      "aria-disabled": props["aria-disabled"] ?? disabled
+    }
+  );
+});
+
+// src/components/properties/DateProperty.tsx
+var import_jsx_runtime12 = require("react/jsx-runtime");
+var DateProperty = ({
+  value,
+  onChange = noop,
+  onEditComplete = noop,
+  readOnly,
+  type = "dateTime",
+  ...baseProps
+}) => {
+  const hasValue = !!value;
+  const dateText = value ? type === "dateTime" ? formatDateTime(value) : formatDate(value) : "";
+  return /* @__PURE__ */ (0, import_jsx_runtime12.jsx)(
+    PropertyBase,
+    {
+      ...baseProps,
+      hasValue,
+      icon: /* @__PURE__ */ (0, import_jsx_runtime12.jsx)(import_lucide_react4.CalendarDays, { size: 24 }),
+      input: ({ softRequired }) => /* @__PURE__ */ (0, import_jsx_runtime12.jsx)(
+        Input,
+        {
+          className: (0, import_clsx6.default)("!ring-0 !border-0 !outline-0 !p-0 !m-0 !shadow-none !w-fit !rounded-none", { "bg-surface-warning": softRequired && !hasValue }),
+          value: dateText,
+          type: type === "dateTime" ? "datetime-local" : "date",
+          readOnly,
+          onChange: (event) => {
+            const value2 = event.target.value;
+            if (!value2) {
+              event.preventDefault();
+              return;
+            }
+            const dueDate = new Date(value2);
+            onChange(dueDate);
+          },
+          onEditCompleted: (value2) => onEditComplete(new Date(value2))
+        }
+      )
+    }
+  );
+};
+
+// src/components/properties/MultiSelectProperty.tsx
+var import_lucide_react7 = require("lucide-react");
+var import_clsx10 = __toESM(require("clsx"));
+
+// src/components/user-action/select/Select.tsx
+var import_react13 = require("react");
+var import_clsx9 = __toESM(require("clsx"));
+
+// src/components/layout/Expandable.tsx
+var import_react9 = require("react");
+var import_lucide_react5 = require("lucide-react");
+var import_clsx7 = __toESM(require("clsx"));
+var import_jsx_runtime13 = require("react/jsx-runtime");
+var ExpansionIcon = ({ isExpanded, className }) => {
+  return /* @__PURE__ */ (0, import_jsx_runtime13.jsx)(
+    import_lucide_react5.ChevronDown,
+    {
+      "aria-hidden": true,
+      className: (0, import_clsx7.default)(
+        "min-w-6 w-6 min-h-6 h-6 transition-transform motion-safe:duration-200 motion-reduce:duration-0 ease-in-out",
+        { "rotate-180": isExpanded },
+        className
+      )
+    }
+  );
+};
+var Expandable = (0, import_react9.forwardRef)(function Expandable2({
+  children,
+  id: providedId,
+  label,
+  icon,
+  isExpanded = false,
+  onChange = noop,
+  clickOnlyOnHeader = true,
+  disabled = false,
+  className,
+  headerClassName,
+  contentClassName,
+  contentExpandedClassName
+}, ref) {
+  const defaultIcon = (0, import_react9.useCallback)((expanded) => /* @__PURE__ */ (0, import_jsx_runtime13.jsx)(ExpansionIcon, { isExpanded: expanded }), []);
+  icon ??= defaultIcon;
+  const generatedId = (0, import_react9.useId)();
+  const id = providedId ?? generatedId;
+  return /* @__PURE__ */ (0, import_jsx_runtime13.jsxs)(
+    "div",
+    {
+      ref,
+      onClick: () => !clickOnlyOnHeader && !disabled && onChange(!isExpanded),
+      className: (0, import_clsx7.default)(
+        "flex-col-0 bg-surface text-on-surface group rounded-lg shadow-sm",
+        { "cursor-pointer": !clickOnlyOnHeader && !disabled },
+        className
+      ),
+      children: [
+        /* @__PURE__ */ (0, import_jsx_runtime13.jsxs)(
+          "button",
+          {
+            onClick: () => clickOnlyOnHeader && !disabled && onChange(!isExpanded),
+            className: (0, import_clsx7.default)(
+              "flex-row-2 py-2 px-4 rounded-lg justify-between items-center bg-surface text-on-surface select-none",
+              {
+                "group-hover:brightness-97": !isExpanded,
+                "hover:brightness-97": isExpanded && !disabled,
+                "cursor-pointer": clickOnlyOnHeader && !disabled
+              },
+              headerClassName
+            ),
+            "aria-expanded": isExpanded,
+            "aria-controls": `${id}-content`,
+            "aria-disabled": disabled ?? void 0,
+            children: [
+              label,
+              icon(isExpanded)
+            ]
+          }
+        ),
+        /* @__PURE__ */ (0, import_jsx_runtime13.jsx)(
+          "div",
+          {
+            id: `${id}-content`,
+            className: (0, import_clsx7.default)(
+              "flex-col-2 px-4 transition-all duration-300 ease-in-out",
+              {
+                [(0, import_clsx7.default)("max-h-96 opacity-100 pb-2 overflow-y-auto", contentExpandedClassName)]: isExpanded,
+                "max-h-0 opacity-0 overflow-hidden": !isExpanded
+              },
+              contentClassName
+            ),
+            role: "region",
+            children
+          }
+        )
+      ]
+    }
+  );
+});
+var ExpandableUncontrolled = (0, import_react9.forwardRef)(function ExpandableUncontrolled2({
+  isExpanded,
+  onChange = noop,
+  ...props
+}, ref) {
+  const [usedIsExpanded, setUsedIsExpanded] = (0, import_react9.useState)(isExpanded);
+  (0, import_react9.useEffect)(() => {
+    setUsedIsExpanded(isExpanded);
+  }, [isExpanded]);
+  return /* @__PURE__ */ (0, import_jsx_runtime13.jsx)(
+    Expandable,
+    {
+      ...props,
+      ref,
+      isExpanded: usedIsExpanded,
+      onChange: (value) => {
+        onChange(value);
+        setUsedIsExpanded(value);
+      }
+    }
+  );
+});
+
+// src/hooks/focus/useFocusTrap.ts
+var import_react11 = require("react");
+
+// src/hooks/focus/useIsMounted.ts
+var import_react10 = require("react");
+var isClient = typeof window !== "undefined" && typeof document !== "undefined";
+var useIsomorphicEffect = isClient ? import_react10.useLayoutEffect : import_react10.useEffect;
+var useIsMounted = () => {
+  const [isMounted, setIsMounted] = (0, import_react10.useState)(false);
+  useIsomorphicEffect(() => {
+    setIsMounted(true);
+    return () => {
+      setIsMounted(false);
+    };
+  }, []);
+  return isMounted;
+};
+
+// src/hooks/focus/useFocusTrap.ts
+var createFocusGuard = () => {
+  const div = document.createElement("div");
+  Object.assign(div.style, {
+    opacity: "0",
+    outline: "none",
+    boxShadow: "none",
+    position: "fixed",
+    pointerEvents: "none",
+    touchAction: "none"
+  });
+  div.tabIndex = 0;
+  div.setAttribute("data-hw-focus-guard", "");
+  document.body.appendChild(div);
+  return div;
+};
+function getContainedFocusableElements(element) {
+  return element?.querySelectorAll('button, [href], input, select, textarea, [tabindex]:not([tabindex="-1"])');
+}
+var FocusTrapService = class {
+  constructor() {
+    // The last entry is always the active one
+    this.listeners = [];
+    this.onFocusIn = (event) => {
+      const active = this.getActive();
+      if (!active || !active.container.current) return;
+      const { container } = active;
+      if (!container.current.contains(event.target)) {
+        this.focusElement();
+      }
+    };
+  }
+  getActive() {
+    if (this.listeners.length === 0) return void 0;
+    return this.listeners[this.listeners.length - 1];
+  }
+  focusElement() {
+    const active = this.getActive();
+    if (!active) return;
+    const { container, initialFocusElement } = active;
+    const containerElement = container.current;
+    if (initialFocusElement?.current) {
+      initialFocusElement.current.focus();
+    } else {
+      const elements = getContainedFocusableElements(containerElement);
+      if (elements && elements.length > 0) {
+        const first = elements.item(0);
+        first.focus();
+      } else {
+        containerElement.focus();
+      }
+    }
+  }
+  removeGuards() {
+    document.querySelectorAll("[data-hw-focus-guard]").forEach((node) => node.remove());
+  }
+  addGuards() {
+    document.body.insertAdjacentElement("afterbegin", createFocusGuard());
+    document.body.insertAdjacentElement("beforeend", createFocusGuard());
+  }
+  activate() {
+    document.addEventListener("focusin", this.onFocusIn);
+    this.addGuards();
+  }
+  deactivate() {
+    document.removeEventListener("focusin", this.onFocusIn);
+    this.removeGuards();
+  }
+  register(listener) {
+    this.listeners.push(listener);
+    if (this.listeners.length === 1) {
+      this.activate();
+    }
+    const active = listener;
+    this.listeners.forEach((listener2) => {
+      const { focus, pause } = listener2;
+      if (listener2 === active) {
+        focus();
+      } else {
+        pause();
+      }
+    });
+  }
+  unregister(id) {
+    const index = this.listeners.findIndex((trap) => trap.id === id);
+    if (index !== -1) {
+      const isActive = index === this.listeners.length - 1;
+      const listener = this.listeners[index];
+      this.listeners = this.listeners.filter((listener2) => listener2.id !== id);
+      if (isActive) {
+        this.deactivate();
+        listener.focusLast();
+        const active = this.getActive();
+        this.listeners.forEach((listener2) => {
+          const { pause, unpause } = listener2;
+          if (listener2 === active) {
+            unpause();
+          } else {
+            pause();
+          }
+        });
+        if (this.listeners.length > 0) {
+          this.activate();
+        }
+      }
+    } else {
+      console.warn(`Unable to unregister id ${id}: not found`);
+    }
+  }
+};
+var service = new FocusTrapService();
+var useFocusTrap = ({
+  container,
+  active = true,
+  initialFocus,
+  focusFirst = true
+}) => {
+  const lastFocusRef = (0, import_react11.useRef)(null);
+  const [paused, setPaused] = (0, import_react11.useState)(false);
+  const isMounted = useIsMounted();
+  const id = (0, import_react11.useId)();
+  const focusElement = (0, import_react11.useCallback)(() => {
+    const containerElement = container.current;
+    if (initialFocus?.current) {
+      initialFocus.current.focus();
+    } else {
+      const elements = getContainedFocusableElements(containerElement);
+      if (elements && elements.length > 0) {
+        const first = elements.item(0);
+        first.focus();
+      } else {
+        containerElement.focus();
+      }
+    }
+  }, [container, initialFocus]);
+  (0, import_react11.useEffect)(() => {
+    if (active && isMounted) {
+      let pause = function() {
+        setPaused(true);
+      }, unpause = function() {
+        setPaused(false);
+        if (!container.current.contains(document.activeElement)) {
+          focusElement();
+        }
+      }, focus = function() {
+        focusElement();
+        setPaused(false);
+      }, focusLast = function() {
+        lastFocusRef.current?.focus();
+      };
+      if (!lastFocusRef.current) {
+        lastFocusRef.current = document.activeElement;
+      }
+      service.register({ id, pause, focus, focusLast, unpause, container, initialFocusElement: initialFocus });
+      return () => {
+        service.unregister(id);
+        lastFocusRef.current = void 0;
+      };
+    }
+  }, [active, container, focusElement, id, initialFocus, isMounted]);
+  (0, import_react11.useEffect)(() => {
+    if (active && !paused && isMounted) {
+      let onKeyDown = function(event) {
+        const key = event.key;
+        const elements = getContainedFocusableElements(containerElement);
+        const active2 = document.activeElement;
+        const index = [...elements].findIndex((value) => value === active2);
+        if (index === -1 || event.altKey || event.ctrlKey || event.metaKey) {
+          return;
+        }
+        if (key === "Tab") {
+          const next = event.shiftKey ? -1 : 1;
+          const nextIndex = (index + next + elements.length) % elements.length;
+          const nextElement = elements[nextIndex];
+          nextElement.focus();
+          event.preventDefault();
+        }
+      };
+      const containerElement = container.current;
+      containerElement.addEventListener("keydown", onKeyDown);
+      return () => {
+        containerElement.removeEventListener("keydown", onKeyDown);
+      };
+    }
+  }, [active, paused, isMounted, container, initialFocus, focusFirst, focusElement]);
+};
+
+// src/utils/match.ts
+var match = (key, values) => {
+  return values[key];
+};
+
+// src/components/user-action/select/Select.tsx
+var import_lucide_react6 = require("lucide-react");
+
+// src/components/layout/Chip.tsx
+var import_clsx8 = __toESM(require("clsx"));
+var import_jsx_runtime14 = require("react/jsx-runtime");
+var Chip = ({
+  children,
+  trailingIcon,
+  color = "default",
+  size = "md",
+  icon = false,
+  variant = "normal",
+  className = "",
+  ...restProps
+}) => {
+  const colorMapping = {
+    default: "text-tag-default-text bg-tag-default-background",
+    dark: "text-tag-dark-text bg-tag-dark-background",
+    red: "text-tag-red-text bg-tag-red-background",
+    yellow: "text-tag-yellow-text bg-tag-yellow-background",
+    green: "text-tag-green-text bg-tag-green-background",
+    blue: "text-tag-blue-text bg-tag-blue-background",
+    pink: "text-tag-pink-text bg-tag-pink-background",
+    orange: "text-tag-orange-text bg-tag-orange-background"
+  }[color];
+  const colorMappingIcon = {
+    default: "text-tag-default-icon",
+    dark: "text-tag-dark-icon",
+    red: "text-tag-red-icon",
+    yellow: "text-tag-yellow-icon",
+    green: "text-tag-green-icon",
+    blue: "text-tag-blue-icon",
+    pink: "text-tag-pink-icon",
+    orange: "text-tag-orange-icon"
+  }[color];
+  return /* @__PURE__ */ (0, import_jsx_runtime14.jsxs)(
+    "div",
+    {
+      ...restProps,
+      className: (0, import_clsx8.default)(
+        `flex-row-0 w-fit font-semibold`,
+        colorMapping,
+        !icon ? {
+          "px-1 py-0.5": size === "sm",
+          "px-2 py-1": size === "md",
+          "px-4 py-2": size === "lg"
+        } : {
+          "p-0.5": size === "sm",
+          "p-1": size === "md",
+          "p-2": size === "lg"
+        },
+        {
+          "rounded-md": variant === "normal",
+          "rounded-full": variant === "fullyRounded"
+        },
+        className
+      ),
+      children: [
+        children,
+        trailingIcon && /* @__PURE__ */ (0, import_jsx_runtime14.jsx)("span", { className: colorMappingIcon, children: trailingIcon })
+      ]
+    }
+  );
+};
+
+// src/hooks/useFloatingElement.ts
+var import_react12 = require("react");
+
+// src/utils/math.ts
+var clamp = (value, range = [0, 1]) => {
+  const [min, max] = range;
+  return Math.min(Math.max(value, min), max);
+};
+
+// src/hooks/useFloatingElement.ts
+function calculatePosition({
+  windowRect,
+  containerRect,
+  anchorRect,
+  options
+}) {
+  const { verticalAlignment, horizontalAlignment, gap, screenPadding } = options;
+  const windowWidth = windowRect.width;
+  const windowHeight = windowRect.height;
+  const maxWidth = windowWidth - 2 * screenPadding;
+  const maxHeight = windowHeight - 2 * screenPadding;
+  const width = Math.min(containerRect.width, maxWidth);
+  const height = Math.min(containerRect.height, maxHeight);
+  const leftSuggestion = {
+    beforeStart: anchorRect.left - width - gap,
+    afterStart: anchorRect.left,
+    center: anchorRect.left + anchorRect.width / 2 - width / 2,
+    beforeEnd: anchorRect.right - width,
+    afterEnd: anchorRect.right + gap
+  }[horizontalAlignment];
+  const topSuggestion = {
+    beforeStart: anchorRect.top - height - gap,
+    afterStart: anchorRect.top,
+    center: anchorRect.top + anchorRect.height / 2 - height / 2,
+    beforeEnd: anchorRect.bottom - height,
+    afterEnd: anchorRect.bottom + gap
+  }[verticalAlignment];
+  const left = clamp(leftSuggestion, [
+    screenPadding,
+    windowWidth - screenPadding - width
+  ]);
+  const top = clamp(topSuggestion, [
+    screenPadding,
+    windowHeight - screenPadding - height
+  ]);
+  return {
+    left,
+    top,
+    maxWidth,
+    maxHeight
+  };
+}
+function useFloatingElement({
+  active = true,
+  windowRef,
+  anchorRef,
+  containerRef,
+  isPolling = false,
+  pollingInterval = 100,
+  verticalAlignment = "afterEnd",
+  horizontalAlignment = "afterStart",
+  screenPadding = 16,
+  gap = 4
+}) {
+  const [style, setStyle] = (0, import_react12.useState)();
+  const isMounted = useIsMounted();
+  const calculate = (0, import_react12.useCallback)(() => {
+    const containerRect = containerRef.current.getBoundingClientRect();
+    const windowRect = windowRef?.current.getBoundingClientRect() ?? {
+      top: 0,
+      bottom: window.innerHeight,
+      left: 0,
+      right: window.innerWidth,
+      width: window.innerWidth,
+      height: window.innerHeight
+    };
+    const anchorElement = anchorRef?.current;
+    if (anchorRef && !anchorElement) {
+      console.warn("FloatingContainer anchor provided, but its value is undefined");
+    }
+    const anchorRect = anchorElement?.getBoundingClientRect() ?? windowRect;
+    const calculateProps = {
+      windowRect,
+      anchorRect,
+      containerRect,
+      options: {
+        horizontalAlignment,
+        verticalAlignment,
+        screenPadding,
+        gap
+      }
+    };
+    setStyle(calculatePosition(calculateProps));
+  }, [anchorRef, containerRef, gap, horizontalAlignment, screenPadding, verticalAlignment, windowRef]);
+  const height = containerRef.current?.getBoundingClientRect().height;
+  const width = containerRef.current?.getBoundingClientRect().width;
+  (0, import_react12.useEffect)(() => {
+    if (active && isMounted) {
+      calculate();
+    } else {
+      setStyle(void 0);
+    }
+  }, [calculate, active, isMounted, height, width]);
+  (0, import_react12.useEffect)(() => {
+    window.addEventListener("resize", calculate);
+    let timeout;
+    if (isPolling) {
+      timeout = setInterval(calculate, pollingInterval);
+    }
+    return () => {
+      window.removeEventListener("resize", calculate);
+      if (timeout) {
+        clearInterval(timeout);
+      }
+    };
+  }, [calculate, isPolling, pollingInterval]);
+  return style;
+}
+
+// src/components/user-action/select/Select.tsx
+var import_react_dom = require("react-dom");
+var import_jsx_runtime15 = require("react/jsx-runtime");
+var defaultToggleOpenOptions = {
+  highlightStartPosition: "first"
+};
+var SelectContext = (0, import_react13.createContext)(null);
+function useSelectContext() {
+  const ctx = (0, import_react13.useContext)(SelectContext);
+  if (!ctx) {
+    throw new Error("SelectContext must be used within a ListBoxPrimitive");
+  }
+  return ctx;
+}
+var SelectRoot = ({
+  children,
+  id,
+  value,
+  onValueChanged,
+  values,
+  onValuesChanged,
+  isOpen = false,
+  disabled = false,
+  invalid = false,
+  isMultiSelect = false,
+  iconAppearance = "left"
+}) => {
+  const optionsRef = (0, import_react13.useRef)([]);
+  const triggerRef = (0, import_react13.useRef)(null);
+  const generatedId = (0, import_react13.useId)();
+  const usedId = id ?? generatedId;
+  const [internalState, setInternalState] = (0, import_react13.useState)({
+    isOpen
+  });
+  const state = {
+    ...internalState,
+    id: usedId,
+    disabled,
+    invalid,
+    value: isMultiSelect ? values ?? [] : [value].filter(Boolean)
+  };
+  const config = {
+    isMultiSelect,
+    iconAppearance
+  };
+  const registerItem = (0, import_react13.useCallback)((item) => {
+    optionsRef.current.push(item);
+    optionsRef.current.sort((a, b) => {
+      const aEl = a.ref.current;
+      const bEl = b.ref.current;
+      if (!aEl || !bEl) return 0;
+      return aEl.compareDocumentPosition(bEl) & Node.DOCUMENT_POSITION_FOLLOWING ? -1 : 1;
+    });
+  }, []);
+  const unregisterItem = (0, import_react13.useCallback)((value2) => {
+    optionsRef.current = optionsRef.current.filter((i) => i.value !== value2);
+  }, []);
+  const toggleSelection = (value2, isSelected) => {
+    if (disabled) {
+      return;
+    }
+    const option = optionsRef.current.find((i) => i.value === value2);
+    if (!option) {
+      console.error(`SelectOption with value: ${value2} not found`);
+      return;
+    }
+    let newValue;
+    if (isMultiSelect) {
+      const isSelectedBefore = state.value.includes(value2);
+      const isSelectedAfter = isSelected ?? !isSelectedBefore;
+      if (!isSelectedAfter) {
+        newValue = state.value.filter((v) => v !== value2);
+      } else {
+        newValue = [...state.value, value2];
+      }
+    } else {
+      newValue = [value2];
+    }
+    if (!isMultiSelect) {
+      onValueChanged?.(newValue[0]);
+    } else {
+      onValuesChanged?.(newValue);
+    }
+    setInternalState((prevState) => ({
+      ...prevState,
+      highlightedValue: value2
+    }));
+  };
+  const highlightItem = (value2) => {
+    if (disabled) {
+      return;
+    }
+    setInternalState((prevState) => ({
+      ...prevState,
+      highlightedValue: value2
+    }));
+  };
+  const registerTrigger = (0, import_react13.useCallback)((ref) => {
+    triggerRef.current = ref.current;
+  }, []);
+  const unregisterTrigger = (0, import_react13.useCallback)(() => {
+    triggerRef.current = null;
+  }, []);
+  const toggleOpen = (isOpen2, options) => {
+    const { highlightStartPosition } = { ...defaultToggleOpenOptions, ...options };
+    let highlightedIndex;
+    if (highlightStartPosition === "first") {
+      highlightedIndex = optionsRef.current.findIndex((option) => !option.disabled);
+    } else {
+      highlightedIndex = optionsRef.current.length - 1 - [...optionsRef.current].reverse().findIndex((option) => !option.disabled);
+    }
+    if (highlightedIndex === -1 || highlightedIndex === optionsRef.current.length) {
+      highlightedIndex = 0;
+    }
+    setInternalState((prevState) => ({
+      ...prevState,
+      isOpen: isOpen2 ?? !prevState.isOpen,
+      highlightedValue: optionsRef.current[highlightedIndex].value
+    }));
+  };
+  const moveHighlightedIndex = (delta) => {
+    let highlightedIndex = optionsRef.current.findIndex((value2) => value2.value === internalState.highlightedValue);
+    if (highlightedIndex === -1) {
+      highlightedIndex = 0;
+    }
+    const optionLength = optionsRef.current.length;
+    const startIndex = (highlightedIndex + delta % optionLength + optionLength) % optionLength;
+    const isForward = delta >= 0;
+    let highlightedValue = optionsRef.current[startIndex].value;
+    for (let i = 0; i < optionsRef.current.length; i++) {
+      const index = (startIndex + (isForward ? i : -i) + optionLength) % optionLength;
+      if (!optionsRef.current[index].disabled) {
+        highlightedValue = optionsRef.current[index].value;
+        break;
+      }
+    }
+    setInternalState((prevState) => ({
+      ...prevState,
+      highlightedValue
+    }));
+  };
+  (0, import_react13.useEffect)(() => {
+    if (!internalState.highlightedValue) return;
+    const highlighted = optionsRef.current.find((value2) => value2.value === internalState.highlightedValue);
+    if (highlighted) {
+      highlighted.ref.current.scrollIntoView({ behavior: "instant", block: "nearest" });
+    } else {
+      console.error(`SelectRoot: Could not find highlighted value (${internalState.highlightedValue})`);
+    }
+  }, [internalState.highlightedValue]);
+  const contextValue = {
+    state,
+    config,
+    item: {
+      register: registerItem,
+      unregister: unregisterItem,
+      toggleSelection,
+      highlightItem,
+      moveHighlightedIndex
+    },
+    trigger: {
+      ref: triggerRef,
+      register: registerTrigger,
+      unregister: unregisterTrigger,
+      toggleOpen
+    }
+  };
+  return /* @__PURE__ */ (0, import_jsx_runtime15.jsx)(SelectContext.Provider, { value: contextValue, children });
+};
+var SelectOption = (0, import_react13.forwardRef)(
+  function SelectOption2({ children, value, disabled = false, iconAppearance, className, ...restProps }, ref) {
+    const { state, config, item, trigger } = useSelectContext();
+    const { register, unregister, toggleSelection, highlightItem } = item;
+    const itemRef = (0, import_react13.useRef)(null);
+    iconAppearance ??= config.iconAppearance;
+    (0, import_react13.useEffect)(() => {
+      register({
+        value,
+        disabled,
+        ref: itemRef
+      });
+      return () => unregister(value);
+    }, [value, disabled, register, unregister, children]);
+    const isHighlighted = state.highlightedValue === value;
+    const isSelected = state.value.includes(value);
+    return /* @__PURE__ */ (0, import_jsx_runtime15.jsxs)(
+      "li",
+      {
+        ...restProps,
+        ref: (node) => {
+          itemRef.current = node;
+          if (typeof ref === "function") ref(node);
+          else if (ref) ref.current = node;
+        },
+        id: value,
+        role: "option",
+        "aria-disabled": disabled,
+        "aria-selected": isSelected,
+        "data-highlighted": isHighlighted ? "" : void 0,
+        "data-selected": isSelected ? "" : void 0,
+        "data-disabled": disabled ? "" : void 0,
+        className: (0, import_clsx9.default)(
+          "flex-row-1 items-center px-2 py-1 rounded-md",
+          "data-highlighted:bg-primary/20",
+          "data-disabled:text-disabled data-disabled:cursor-not-allowed",
+          "not-data-disabled:cursor-pointer",
+          className
+        ),
+        onClick: (event) => {
+          if (!disabled) {
+            toggleSelection(value);
+            if (!config.isMultiSelect) {
+              trigger.toggleOpen(false);
+            }
+            restProps.onClick?.(event);
+          }
+        },
+        onMouseEnter: (event) => {
+          if (!disabled) {
+            highlightItem(value);
+            restProps.onMouseEnter?.(event);
+          }
+        },
+        children: [
+          iconAppearance === "left" && /* @__PURE__ */ (0, import_jsx_runtime15.jsx)(
+            import_lucide_react6.CheckIcon,
+            {
+              className: (0, import_clsx9.default)("w-4 h-4", { "opacity-0": !isSelected || disabled }),
+              "aria-hidden": true
+            }
+          ),
+          children ?? value,
+          iconAppearance === "right" && /* @__PURE__ */ (0, import_jsx_runtime15.jsx)(
+            import_lucide_react6.CheckIcon,
+            {
+              className: (0, import_clsx9.default)("w-4 h-4", { "opacity-0": !isSelected || disabled }),
+              "aria-hidden": true
+            }
+          )
+        ]
+      }
+    );
+  }
+);
+var defaultSelectButtonTranslation = {
+  en: {
+    clickToSelect: "Click to select"
+  },
+  de: {
+    clickToSelect: "Zum ausw\xE4hlen dr\xFCcken"
+  }
+};
+var SelectButton = (0, import_react13.forwardRef)(function SelectButton2({ placeholder, selectedDisplay, ...props }, ref) {
+  const translation = useTranslation([defaultSelectButtonTranslation]);
+  const { state, trigger } = useSelectContext();
+  const { register, unregister, toggleOpen } = trigger;
+  const innerRef = (0, import_react13.useRef)(null);
+  (0, import_react13.useImperativeHandle)(ref, () => innerRef.current);
+  (0, import_react13.useEffect)(() => {
+    register(innerRef);
+    return () => unregister();
+  }, [register, unregister]);
+  const disabled = !!props?.disabled || !!state.disabled;
+  const invalid = state.invalid;
+  const hasValue = state.value.length > 0;
+  return /* @__PURE__ */ (0, import_jsx_runtime15.jsxs)(
+    "button",
+    {
+      ...props,
+      ref: innerRef,
+      id: state.id,
+      className: (0, import_clsx9.default)(
+        "flex-row-2 items-center justify-between bg-input-background text-input-text rounded-md px-2.5 py-2.5",
+        "data-placeholder:text-description",
+        props.className
+      ),
+      onClick: () => toggleOpen(!state.isOpen),
+      onKeyDown: (event) => {
+        switch (event.key) {
+          case "ArrowDown":
+            toggleOpen(true, { highlightStartPosition: "first" });
+            break;
+          case "ArrowUp":
+            toggleOpen(true, { highlightStartPosition: "last" });
+            break;
+        }
+      },
+      "data-placeholder": !hasValue ? "" : void 0,
+      "data-disabled": disabled ? "" : void 0,
+      "data-invalid": invalid ? "" : void 0,
+      "aria-invalid": invalid,
+      "aria-disabled": disabled,
+      "aria-haspopup": "listbox",
+      "aria-expanded": state.isOpen,
+      "aria-controls": state.isOpen ? `${state.id}-listbox` : void 0,
+      children: [
+        hasValue ? selectedDisplay?.(state.value) ?? state.value.join(", ") : placeholder ?? translation("clickToSelect"),
+        /* @__PURE__ */ (0, import_jsx_runtime15.jsx)(ExpansionIcon, { isExpanded: state.isOpen })
+      ]
+    }
+  );
+});
+var SelectChipDisplay = (0, import_react13.forwardRef)(function SelectChipDisplay2({ ...props }, ref) {
+  const { state, trigger, item } = useSelectContext();
+  const { register, unregister, toggleOpen } = trigger;
+  const innerRef = (0, import_react13.useRef)(null);
+  (0, import_react13.useImperativeHandle)(ref, () => innerRef.current);
+  (0, import_react13.useEffect)(() => {
+    register(innerRef);
+    return () => unregister();
+  }, [register, unregister]);
+  const disabled = !!props?.disabled || !!state.disabled;
+  const invalid = state.invalid;
+  return /* @__PURE__ */ (0, import_jsx_runtime15.jsxs)(
+    "div",
+    {
+      ...props,
+      ref: innerRef,
+      className: (0, import_clsx9.default)(
+        "flex flex-wrap flex-row gap-2 items-center bg-input-background text-input-text rounded-md px-2.5 py-2.5",
+        props.className
+      ),
+      "data-disabled": disabled ? "" : void 0,
+      "data-invalid": invalid ? "" : void 0,
+      "aria-invalid": invalid,
+      "aria-disabled": disabled,
+      children: [
+        state.value.map((value) => /* @__PURE__ */ (0, import_jsx_runtime15.jsxs)(Chip, { className: "gap-x-2", children: [
+          value,
+          /* @__PURE__ */ (0, import_jsx_runtime15.jsx)(
+            "button",
+            {
+              onClick: () => {
+                item.toggleSelection(value, false);
+              },
+              className: "focus-within:text-negative hover:bg-negative/20 hover:text-negative rounded-md focus-style-none focus-visible:ring-2 focus-visible:ring-negative focus-visible:bg-negative/20",
+              children: /* @__PURE__ */ (0, import_jsx_runtime15.jsx)(import_lucide_react6.XIcon, {})
+            }
+          )
+        ] }, value)),
+        /* @__PURE__ */ (0, import_jsx_runtime15.jsx)(
+          IconButton,
+          {
+            id: state.id,
+            onClick: () => toggleOpen(),
+            onKeyDown: (event) => {
+              switch (event.key) {
+                case "ArrowDown":
+                  toggleOpen(true, { highlightStartPosition: "first" });
+                  break;
+                case "ArrowUp":
+                  toggleOpen(true, { highlightStartPosition: "last" });
+              }
+            },
+            size: "small",
+            color: "neutral",
+            "aria-invalid": invalid,
+            "aria-disabled": disabled,
+            "aria-haspopup": "listbox",
+            "aria-expanded": state.isOpen,
+            "aria-controls": state.isOpen ? `${state.id}-listbox` : void 0,
+            children: /* @__PURE__ */ (0, import_jsx_runtime15.jsx)(import_lucide_react6.Plus, {})
+          }
+        )
+      ]
+    }
+  );
+});
+var SelectContent = (0, import_react13.forwardRef)(
+  function SelectContent2({
+    alignment,
+    orientation = "vertical",
+    ...props
+  }, ref) {
+    const innerRef = (0, import_react13.useRef)(null);
+    (0, import_react13.useImperativeHandle)(ref, () => innerRef.current);
+    const { trigger, state, config, item } = useSelectContext();
+    const position = useFloatingElement({
+      active: state.isOpen,
+      anchorRef: trigger.ref,
+      containerRef: innerRef,
+      ...alignment
+    });
+    useFocusTrap({
+      container: innerRef,
+      active: state.isOpen && !!position
+    });
+    return (0, import_react_dom.createPortal)(
+      /* @__PURE__ */ (0, import_jsx_runtime15.jsxs)(import_jsx_runtime15.Fragment, { children: [
+        /* @__PURE__ */ (0, import_jsx_runtime15.jsx)(
+          "div",
+          {
+            hidden: !state.isOpen,
+            onClick: () => trigger.toggleOpen(false),
+            className: (0, import_clsx9.default)("fixed w-screen h-screen inset-0")
+          }
+        ),
+        /* @__PURE__ */ (0, import_jsx_runtime15.jsx)(
+          "ul",
+          {
+            ...props,
+            id: `${state.id}-listbox`,
+            ref: innerRef,
+            hidden: !state.isOpen,
+            onKeyDown: (event) => {
+              switch (event.key) {
+                case "Escape":
+                  trigger.toggleOpen(false);
+                  event.preventDefault();
+                  event.stopPropagation();
+                  break;
+                case match(orientation, {
+                  vertical: "ArrowDown",
+                  horizontal: "ArrowUp"
+                }):
+                  item.moveHighlightedIndex(1);
+                  event.preventDefault();
+                  break;
+                case match(orientation, {
+                  vertical: "ArrowUp",
+                  horizontal: "ArrowDown"
+                }):
+                  item.moveHighlightedIndex(-1);
+                  event.preventDefault();
+                  break;
+                case "Home":
+                  event.preventDefault();
+                  break;
+                case "End":
+                  event.preventDefault();
+                  break;
+                case "Enter":
+                // Fall through
+                case " ":
+                  if (state.highlightedValue) {
+                    item.toggleSelection(state.highlightedValue);
+                    if (!config.isMultiSelect) {
+                      trigger.toggleOpen(false);
+                    }
+                    event.preventDefault();
+                  }
+                  break;
+              }
+            },
+            className: (0, import_clsx9.default)("flex-col-0 p-2 bg-menu-background text-menu-text rounded-md shadow-hw-bottom focus-style-within overflow-auto", props.className),
+            style: {
+              opacity: position ? void 0 : 0,
+              position: "fixed",
+              ...position
+            },
+            role: "listbox",
+            "aria-multiselectable": config.isMultiSelect,
+            "aria-orientation": orientation,
+            tabIndex: position ? 0 : void 0,
+            children: props.children
+          }
+        )
+      ] }),
+      document.body
+    );
+  }
+);
+var Select = (0, import_react13.forwardRef)(function Select2({
+  children,
+  contentPanelProps,
+  buttonProps,
+  ...props
+}, ref) {
+  return /* @__PURE__ */ (0, import_jsx_runtime15.jsxs)(SelectRoot, { ...props, isMultiSelect: false, children: [
+    /* @__PURE__ */ (0, import_jsx_runtime15.jsx)(
+      SelectButton,
+      {
+        ref,
+        ...buttonProps,
+        selectedDisplay: (values) => {
+          const value = values[0];
+          if (!buttonProps?.selectedDisplay) return void 0;
+          return buttonProps.selectedDisplay(value);
+        }
+      }
+    ),
+    /* @__PURE__ */ (0, import_jsx_runtime15.jsx)(SelectContent, { ...contentPanelProps, children })
+  ] });
+});
+var SelectUncontrolled = (0, import_react13.forwardRef)(function SelectUncontrolled2({
+  value: initialValue,
+  onValueChanged,
+  ...props
+}, ref) {
+  const [value, setValue] = (0, import_react13.useState)(initialValue);
+  (0, import_react13.useEffect)(() => {
+    setValue(initialValue);
+  }, [initialValue]);
+  return /* @__PURE__ */ (0, import_jsx_runtime15.jsx)(
+    Select,
+    {
+      ...props,
+      ref,
+      value,
+      onValueChanged: (value2) => {
+        setValue(value2);
+        onValueChanged?.(value2);
+      }
+    }
+  );
+});
+var MultiSelect = (0, import_react13.forwardRef)(function MultiSelect2({
+  children,
+  contentPanelProps,
+  buttonProps,
+  ...props
+}, ref) {
+  return /* @__PURE__ */ (0, import_jsx_runtime15.jsxs)(SelectRoot, { ...props, isMultiSelect: true, children: [
+    /* @__PURE__ */ (0, import_jsx_runtime15.jsx)(SelectButton, { ref, ...buttonProps }),
+    /* @__PURE__ */ (0, import_jsx_runtime15.jsx)(SelectContent, { ...contentPanelProps, children })
+  ] });
+});
+var MultiSelectUncontrolled = (0, import_react13.forwardRef)(function MultiSelectUncontrolled2({
+  values: initialValues,
+  onValuesChanged,
+  ...props
+}, ref) {
+  const [values, setValues] = (0, import_react13.useState)(initialValues);
+  (0, import_react13.useEffect)(() => {
+    setValues(initialValues);
+  }, [initialValues]);
+  return /* @__PURE__ */ (0, import_jsx_runtime15.jsx)(
+    MultiSelect,
+    {
+      ...props,
+      ref,
+      values,
+      onValuesChanged: (value) => {
+        setValues(value);
+        onValuesChanged?.(value);
+      }
+    }
+  );
+});
+var MultiSelectChipDisplay = (0, import_react13.forwardRef)(function MultiSelectChipDisplay2({
+  children,
+  contentPanelProps,
+  chipDisplayProps,
+  ...props
+}, ref) {
+  return /* @__PURE__ */ (0, import_jsx_runtime15.jsxs)(SelectRoot, { ...props, isMultiSelect: true, children: [
+    /* @__PURE__ */ (0, import_jsx_runtime15.jsx)(SelectChipDisplay, { ref, ...chipDisplayProps }),
+    /* @__PURE__ */ (0, import_jsx_runtime15.jsx)(SelectContent, { ...contentPanelProps, children })
+  ] });
+});
+var MultiSelectChipDisplayUncontrolled = (0, import_react13.forwardRef)(function MultiSelectChipDisplayUncontrolled2({
+  values: initialValues,
+  onValuesChanged,
+  ...props
+}, ref) {
+  const [values, setValues] = (0, import_react13.useState)(initialValues);
+  (0, import_react13.useEffect)(() => {
+    setValues(initialValues);
+  }, [initialValues]);
+  return /* @__PURE__ */ (0, import_jsx_runtime15.jsx)(
+    MultiSelectChipDisplay,
+    {
+      ...props,
+      ref,
+      values,
+      onValuesChanged: (value) => {
+        setValues(value);
+        onValuesChanged?.(value);
+      }
+    }
+  );
+});
+
+// src/components/properties/MultiSelectProperty.tsx
+var import_jsx_runtime16 = require("react/jsx-runtime");
+var MultiSelectProperty = ({
+  values,
+  options,
+  onValuesChanged,
+  ...props
+}) => {
+  const hasValue = values.length > 0;
+  return /* @__PURE__ */ (0, import_jsx_runtime16.jsx)(
+    PropertyBase,
+    {
+      ...props,
+      hasValue,
+      icon: /* @__PURE__ */ (0, import_jsx_runtime16.jsx)(import_lucide_react7.List, { size: 24 }),
+      input: ({ softRequired }) => /* @__PURE__ */ (0, import_jsx_runtime16.jsx)(
+        MultiSelectChipDisplay,
+        {
+          values,
+          onValuesChanged,
+          disabled: props.readOnly,
+          contentPanelProps: {
+            className: (0, import_clsx10.default)(
+              "!border-none !min-h-10"
+            )
+          },
+          chipDisplayProps: {
+            className: (0, import_clsx10.default)({
+              "!bg-warning !text-surface-warning": softRequired && !hasValue
+            })
+          },
+          children: options.map((value) => /* @__PURE__ */ (0, import_jsx_runtime16.jsx)(SelectOption, { value }, value))
+        }
+      )
+    }
+  );
+};
+
+// src/components/properties/NumberProperty.tsx
+var import_lucide_react8 = require("lucide-react");
+var import_clsx11 = __toESM(require("clsx"));
+var import_jsx_runtime17 = require("react/jsx-runtime");
+var defaultNumberPropertyTranslation = {
+  en: {
+    value: "Value"
+  },
+  de: {
+    value: "Wert"
+  }
+};
+var NumberProperty = ({
+  overwriteTranslation,
+  value,
+  onChange = noop,
+  onRemove = noop,
+  onEditComplete = noop,
+  readOnly,
+  suffix,
+  ...baseProps
+}) => {
+  const translation = useTranslation([defaultNumberPropertyTranslation], overwriteTranslation);
+  const hasValue = value !== void 0;
+  return /* @__PURE__ */ (0, import_jsx_runtime17.jsx)(
+    PropertyBase,
+    {
+      ...baseProps,
+      onRemove,
+      hasValue,
+      icon: /* @__PURE__ */ (0, import_jsx_runtime17.jsx)(import_lucide_react8.Binary, { size: 24 }),
+      input: ({ softRequired }) => /* @__PURE__ */ (0, import_jsx_runtime17.jsxs)(
+        "div",
+        {
+          className: (0, import_clsx11.default)("flex-row-2 grow", { "text-warning": softRequired && !hasValue }),
+          children: [
+            /* @__PURE__ */ (0, import_jsx_runtime17.jsx)(
+              Input,
+              {
+                className: (0, import_clsx11.default)("!ring-0 !border-0 !outline-0 !p-0 !m-0 !w-fit !shadow-none !rounded-none", { "bg-surface-warning placeholder-warning": softRequired && !hasValue }),
+                value: value?.toString() ?? "",
+                type: "number",
+                readOnly,
+                placeholder: `${translation("value")}...`,
+                onChangeText: (value2) => {
+                  const numberValue = parseFloat(value2);
+                  if (isNaN(numberValue)) {
+                    onRemove();
+                  } else {
+                    onChange(numberValue);
+                  }
+                },
+                onEditCompleted: (value2) => {
+                  const numberValue = parseFloat(value2);
+                  if (isNaN(numberValue)) {
+                    onRemove();
+                  } else {
+                    onEditComplete(numberValue);
+                  }
+                }
+              }
+            ),
+            suffix && /* @__PURE__ */ (0, import_jsx_runtime17.jsx)("span", { className: (0, import_clsx11.default)("ml-1", { "bg-surface-warning": softRequired && !hasValue }), children: suffix })
+          ]
+        }
+      )
+    }
+  );
+};
+
+// src/components/properties/SelectProperty.tsx
+var import_lucide_react9 = require("lucide-react");
+var import_clsx12 = __toESM(require("clsx"));
+var import_jsx_runtime18 = require("react/jsx-runtime");
+var SingleSelectProperty = ({
+  value,
+  options,
+  onValueChanged,
+  ...props
+}) => {
+  const hasValue = value !== void 0;
+  return /* @__PURE__ */ (0, import_jsx_runtime18.jsx)(
+    PropertyBase,
+    {
+      ...props,
+      hasValue,
+      icon: /* @__PURE__ */ (0, import_jsx_runtime18.jsx)(import_lucide_react9.List, { size: 24 }),
+      input: ({ softRequired }) => /* @__PURE__ */ (0, import_jsx_runtime18.jsx)(
+        Select,
+        {
+          value,
+          onValueChanged,
+          disabled: props.readOnly,
+          buttonProps: {
+            className: (0, import_clsx12.default)(
+              "border-none w-full",
+              {
+                "!bg-warning !text-surface-warning": softRequired && !hasValue
+              }
+            )
+          },
+          children: options.map((value2) => /* @__PURE__ */ (0, import_jsx_runtime18.jsx)(SelectOption, { value: value2 }, value2))
+        }
+      )
+    }
+  );
+};
+
+// src/components/properties/TextProperty.tsx
+var import_lucide_react10 = require("lucide-react");
+var import_clsx14 = __toESM(require("clsx"));
+
+// src/components/user-action/Textarea.tsx
+var import_react14 = require("react");
+var import_clsx13 = __toESM(require("clsx"));
+var import_jsx_runtime19 = require("react/jsx-runtime");
+var Textarea = (0, import_react14.forwardRef)(function Textarea2({
+  id,
+  onChange,
+  onChangeText,
+  onBlur,
+  onEditCompleted,
+  saveDelayOptions,
+  defaultStyle = true,
+  invalid = false,
+  disabled = false,
+  className,
+  ...props
+}, ref) {
+  const { restartTimer, clearTimer } = useDelay(saveDelayOptions);
+  const onEditCompletedWrapper = (text) => {
+    onEditCompleted?.(text);
+    clearTimer();
+  };
+  return /* @__PURE__ */ (0, import_jsx_runtime19.jsx)(
+    "textarea",
+    {
+      ref,
+      id,
+      className: (0, import_clsx13.default)(
+        "resize-none w-full h-32 overflow-y-scroll",
+        "py-2 px-3 rounded-md border-1",
+        {
+          "bg-input-background text-input-text hover:border-primary focus-within:border-primary focus-within:ring-2 ring-focus": !disabled && !invalid,
+          "bg-on-negative text-negative border-negative-border hover:border-negative-border-hover focus-visible:ring-negative-border": invalid && !disabled && defaultStyle,
+          "text-disabled-text bg-disabled-background border-disabled-border": disabled && defaultStyle
+        },
+        className
+      ),
+      onChange: (event) => {
+        const value = event.target.value;
+        restartTimer(() => {
+          onEditCompletedWrapper(value);
+        });
+        onChange?.(event);
+        onChangeText?.(value);
+      },
+      onBlur: (event) => {
+        onBlur?.(event);
+        onEditCompletedWrapper(event.target.value);
+      },
+      disabled,
+      ...props
+    }
+  );
+});
+
+// src/components/properties/TextProperty.tsx
+var import_jsx_runtime20 = require("react/jsx-runtime");
+var defaultTextPropertyTranslation = {
+  en: {
+    text: "Text"
+  },
+  de: {
+    text: "Text"
+  }
+};
+var TextProperty = ({
+  overwriteTranslation,
+  value,
+  readOnly,
+  onChange = noop,
+  onRemove = noop,
+  onEditComplete = noop,
+  ...baseProps
+}) => {
+  const translation = useTranslation([defaultTextPropertyTranslation], overwriteTranslation);
+  const hasValue = value !== void 0;
+  return /* @__PURE__ */ (0, import_jsx_runtime20.jsx)(
+    PropertyBase,
+    {
+      ...baseProps,
+      onRemove,
+      hasValue,
+      icon: /* @__PURE__ */ (0, import_jsx_runtime20.jsx)(import_lucide_react10.Text, { size: 24 }),
+      input: ({ softRequired }) => /* @__PURE__ */ (0, import_jsx_runtime20.jsx)(
+        Textarea,
+        {
+          className: (0, import_clsx14.default)({
+            "bg-surface-warning placeholder-warning": softRequired && !hasValue
+          }),
+          rows: 5,
+          defaultStyle: false,
+          value: value ?? "",
+          readOnly,
+          placeholder: `${translation("text")}...`,
+          onChangeText: (value2) => {
+            if (!value2) {
+              onRemove();
+            } else {
+              onChange(value2);
+            }
+          },
+          onEditCompleted: (value2) => {
+            if (!value2) {
+              onRemove();
+            } else {
+              onEditComplete(value2);
+            }
+          }
+        }
+      )
+    }
+  );
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  CheckboxProperty,
+  DateProperty,
+  MultiSelectProperty,
+  NumberProperty,
+  PropertyBase,
+  SingleSelectProperty,
+  TextProperty
+});
+//# sourceMappingURL=index.js.map