@blcklab/freedom 0.1.1

package/dist/window.js

@@ -0,0 +1,785 @@
+// src/core/events.ts
+var Emitter = class {
+  listeners = /* @__PURE__ */ new Map();
+  on(event, handler) {
+    let set = this.listeners.get(event);
+    if (!set) {
+      set = /* @__PURE__ */ new Set();
+      this.listeners.set(event, set);
+    }
+    set.add(handler);
+    return () => this.off(event, handler);
+  }
+  off(event, handler) {
+    this.listeners.get(event)?.delete(handler);
+  }
+  emit(event, data) {
+    const set = this.listeners.get(event);
+    if (!set || set.size === 0) return;
+    for (const handler of [...set]) {
+      handler(data);
+    }
+  }
+  clear() {
+    this.listeners.clear();
+  }
+};
+
+// src/core/math.ts
+function clamp(value, min, max) {
+  if (min > max) return min;
+  return Math.min(Math.max(value, min), max);
+}
+function clampSize(size, limits) {
+  return {
+    width: clamp(size.width, limits.minWidth, Math.max(limits.minWidth, limits.maxWidth)),
+    height: clamp(size.height, limits.minHeight, Math.max(limits.minHeight, limits.maxHeight))
+  };
+}
+function clampPointToBounds(point, size, bounds) {
+  const maxX = Math.max(bounds.minX, bounds.maxX - size.width);
+  const maxY = Math.max(bounds.minY, bounds.maxY - size.height);
+  return {
+    x: clamp(point.x, bounds.minX, maxX),
+    y: clamp(point.y, bounds.minY, maxY)
+  };
+}
+
+// src/engine/constraints.ts
+function resolveBounds(option, element) {
+  if (!option || option === "none") return null;
+  if (option === "viewport") {
+    return { minX: 0, minY: 0, maxX: window.innerWidth, maxY: window.innerHeight };
+  }
+  if (option === "parent") {
+    const parent = element.offsetParent;
+    if (!parent) return null;
+    return { minX: 0, minY: 0, maxX: parent.clientWidth, maxY: parent.clientHeight };
+  }
+  return {
+    minX: option.x,
+    minY: option.y,
+    maxX: option.x + option.width,
+    maxY: option.y + option.height
+  };
+}
+function constrainToBounds(point, size, option, element) {
+  const bounds = resolveBounds(option, element);
+  return bounds ? clampPointToBounds(point, size, bounds) : point;
+}
+
+// src/engine/drag.ts
+function createDragEngine(options) {
+  let startPointer = { x: 0, y: 0 };
+  let startPosition = { x: 0, y: 0 };
+  return {
+    begin(pointer, pointerEvent) {
+      startPointer = pointer;
+      startPosition = options.getPosition();
+      return { position: startPosition, delta: { x: 0, y: 0 }, pointerEvent };
+    },
+    move(pointer, pointerEvent) {
+      const delta = {
+        x: pointer.x - startPointer.x,
+        y: pointer.y - startPointer.y
+      };
+      let next = { x: startPosition.x + delta.x, y: startPosition.y + delta.y };
+      next = constrainToBounds(next, options.getSize(), options.bounds, options.element);
+      for (const plugin of options.plugins) {
+        if (!plugin.onDrag) continue;
+        const result = plugin.onDrag(
+          { position: next, delta, pointerEvent },
+          options.pluginContext
+        );
+        if (result) next = result;
+      }
+      return { position: next, data: { position: next, delta, pointerEvent } };
+    },
+    end(pointer, pointerEvent) {
+      const delta = {
+        x: pointer.x - startPointer.x,
+        y: pointer.y - startPointer.y
+      };
+      return { position: options.getPosition(), delta, pointerEvent };
+    }
+  };
+}
+
+// src/engine/resize.ts
+var WEST_HANDLES = ["nw", "w", "sw"];
+var NORTH_HANDLES = ["nw", "n", "ne"];
+var VERTICAL_ONLY_HANDLES = ["n", "s"];
+var HORIZONTAL_ONLY_HANDLES = ["e", "w"];
+function createResizeEngine(options) {
+  let activeHandle = "se";
+  let startPointer = { x: 0, y: 0 };
+  let startPosition = { x: 0, y: 0 };
+  let startSize = { width: 0, height: 0 };
+  let affectsWest = false;
+  let affectsNorth = false;
+  let affectsWidth = true;
+  let affectsHeight = true;
+  return {
+    begin(handle, pointer, pointerEvent) {
+      activeHandle = handle;
+      affectsWest = WEST_HANDLES.includes(handle);
+      affectsNorth = NORTH_HANDLES.includes(handle);
+      affectsWidth = !VERTICAL_ONLY_HANDLES.includes(handle);
+      affectsHeight = !HORIZONTAL_ONLY_HANDLES.includes(handle);
+      startPointer = pointer;
+      startPosition = options.getPosition();
+      startSize = options.getSize();
+      return { size: startSize, position: startPosition, handle, pointerEvent };
+    },
+    move(pointer, pointerEvent) {
+      const dx = pointer.x - startPointer.x;
+      const dy = pointer.y - startPointer.y;
+      let x = startPosition.x;
+      let y = startPosition.y;
+      const width = affectsWidth ? affectsWest ? startSize.width - dx : startSize.width + dx : startSize.width;
+      const height = affectsHeight ? affectsNorth ? startSize.height - dy : startSize.height + dy : startSize.height;
+      const clampedWidth = clamp(width, options.minWidth, Math.max(options.minWidth, options.maxWidth));
+      const clampedHeight = clamp(height, options.minHeight, Math.max(options.minHeight, options.maxHeight));
+      if (affectsWest) x = startPosition.x + (startSize.width - clampedWidth);
+      if (affectsNorth) y = startPosition.y + (startSize.height - clampedHeight);
+      let nextSize = { width: clampedWidth, height: clampedHeight };
+      let nextPosition = constrainToBounds({ x, y }, nextSize, options.bounds, options.element);
+      for (const plugin of options.plugins) {
+        if (!plugin.onResize) continue;
+        const result = plugin.onResize(
+          { size: nextSize, position: nextPosition, handle: activeHandle, pointerEvent },
+          options.pluginContext
+        );
+        if (result) {
+          nextSize = result.size;
+          nextPosition = result.position;
+        }
+      }
+      return {
+        position: nextPosition,
+        size: nextSize,
+        data: { size: nextSize, position: nextPosition, handle: activeHandle, pointerEvent }
+      };
+    },
+    end(pointer, pointerEvent) {
+      return {
+        size: options.getSize(),
+        position: options.getPosition(),
+        handle: activeHandle,
+        pointerEvent
+      };
+    }
+  };
+}
+
+// src/core/interaction-manager.ts
+function toPoint(event) {
+  return { x: event.clientX, y: event.clientY };
+}
+var InteractionManager = class {
+  options;
+  activePointerId = null;
+  captureTarget = null;
+  _active = null;
+  destroyed = false;
+  constructor(options) {
+    this.options = options;
+    this.options.element.addEventListener("pointerdown", this.handlePointerDown);
+  }
+  get active() {
+    return this._active;
+  }
+  startDrag(event) {
+    if (this.destroyed || this._active !== null) return;
+    this._active = "drag";
+    this.captureGesture(event);
+    const data = this.options.dragEngine.begin(toPoint(event), event);
+    this.options.onDragStart(data);
+  }
+  startResize(handle, event) {
+    if (this.destroyed || this._active !== null) return;
+    this._active = "resize";
+    this.captureGesture(event);
+    const data = this.options.resizeEngine.begin(handle, toPoint(event), event);
+    this.options.onResizeStart(data);
+  }
+  cancel() {
+    this.teardown();
+  }
+  destroy() {
+    if (this.destroyed) return;
+    this.destroyed = true;
+    this.options.element.removeEventListener("pointerdown", this.handlePointerDown);
+    this.teardown();
+  }
+  captureGesture(event) {
+    this.activePointerId = event.pointerId;
+    this.captureTarget = event.target instanceof Element ? event.target : this.options.element;
+    try {
+      this.captureTarget.setPointerCapture?.(event.pointerId);
+    } catch {
+    }
+    window.addEventListener("pointermove", this.handlePointerMove);
+    window.addEventListener("pointerup", this.handlePointerUp);
+    window.addEventListener("pointercancel", this.handlePointerUp);
+  }
+  teardown() {
+    if (this.activePointerId !== null && this.captureTarget) {
+      try {
+        this.captureTarget.releasePointerCapture?.(this.activePointerId);
+      } catch {
+      }
+    }
+    this.activePointerId = null;
+    this.captureTarget = null;
+    this._active = null;
+    window.removeEventListener("pointermove", this.handlePointerMove);
+    window.removeEventListener("pointerup", this.handlePointerUp);
+    window.removeEventListener("pointercancel", this.handlePointerUp);
+  }
+  handlePointerDown = (event) => {
+    if (this.destroyed || this._active !== null) return;
+    if (event.pointerType === "mouse" && event.button !== 0) return;
+    const resizeHandle = this.options.resolveResizeHandle(event.target);
+    if (resizeHandle) {
+      event.preventDefault();
+      event.stopPropagation();
+      this.startResize(resizeHandle, event);
+      return;
+    }
+    if (this.options.isDragTarget(event.target)) {
+      this.startDrag(event);
+    }
+  };
+  handlePointerMove = (event) => {
+    if (this.destroyed || event.pointerId !== this.activePointerId) return;
+    if (this._active === "drag") {
+      this.options.onDragMove(this.options.dragEngine.move(toPoint(event), event));
+    } else if (this._active === "resize") {
+      this.options.onResizeMove(this.options.resizeEngine.move(toPoint(event), event));
+    }
+  };
+  handlePointerUp = (event) => {
+    if (this.destroyed || event.pointerId !== this.activePointerId) return;
+    if (this._active === "drag") {
+      this.options.onDragEnd(this.options.dragEngine.end(toPoint(event), event));
+    } else if (this._active === "resize") {
+      this.options.onResizeEnd(this.options.resizeEngine.end(toPoint(event), event));
+    }
+    this.teardown();
+  };
+};
+function createInteractionManager(options) {
+  return new InteractionManager(options);
+}
+
+// src/dom/render.ts
+function applyBaseStyles(element, options) {
+  const style = element.style;
+  const computedPosition = window.getComputedStyle?.(element).position ?? style.position;
+  if (options.forcePositioning || computedPosition === "static") {
+    style.position = options.positioning;
+  }
+  if (!style.touchAction) style.touchAction = "none";
+  if (!style.userSelect) style.userSelect = "none";
+  if (!style.boxSizing) style.boxSizing = "border-box";
+  if (!style.willChange) style.willChange = "transform";
+}
+function readRenderedPosition(element, positioning) {
+  const rect = element.getBoundingClientRect();
+  if (positioning === "fixed") {
+    return { x: rect.left || 0, y: rect.top || 0 };
+  }
+  if (positioning === "absolute") {
+    const parent = element.offsetParent;
+    if (parent) {
+      const parentRect = parent.getBoundingClientRect();
+      return {
+        x: (rect.left || 0) - (parentRect.left || 0) + (parent.scrollLeft || 0),
+        y: (rect.top || 0) - (parentRect.top || 0) + (parent.scrollTop || 0)
+      };
+    }
+    return {
+      x: (rect.left || 0) + (window.scrollX || 0),
+      y: (rect.top || 0) + (window.scrollY || 0)
+    };
+  }
+  return { x: rect.left || 0, y: rect.top || 0 };
+}
+function createPositionRenderer(element, positioning, initialPosition) {
+  const baseTransform = normalizeTransform(element.style.transform);
+  if (positioning === "relative") {
+    return {
+      positioning,
+      origin: readRenderedPosition(element, positioning),
+      baseTransform,
+      flowRelative: true
+    };
+  }
+  element.style.left = `${initialPosition.x}px`;
+  element.style.top = `${initialPosition.y}px`;
+  element.style.right = "auto";
+  element.style.bottom = "auto";
+  return {
+    positioning,
+    origin: { ...initialPosition },
+    baseTransform: "",
+    flowRelative: false
+  };
+}
+function writePosition(element, point, renderer) {
+  const dx = point.x - renderer.origin.x;
+  const dy = point.y - renderer.origin.y;
+  const translate = dx === 0 && dy === 0 ? "" : `translate3d(${dx}px, ${dy}px, 0)`;
+  element.style.transform = joinTransforms(renderer.baseTransform, translate);
+}
+function writeSize(element, size) {
+  element.style.width = `${size.width}px`;
+  element.style.height = `${size.height}px`;
+}
+function normalizeTransform(value) {
+  if (!value || value === "none") return "";
+  return value.trim();
+}
+function joinTransforms(base, translate) {
+  if (base && translate) return `${base} ${translate}`;
+  if (base) return base;
+  return translate;
+}
+
+// src/dom/handles.ts
+var CORNER_SIZE_PX = 14;
+var EDGE_THICKNESS_PX = 8;
+var EDGE_STYLES = {
+  nw: { top: "0", left: "0", width: `${CORNER_SIZE_PX}px`, height: `${CORNER_SIZE_PX}px`, cursor: "nwse-resize" },
+  ne: { top: "0", right: "0", width: `${CORNER_SIZE_PX}px`, height: `${CORNER_SIZE_PX}px`, cursor: "nesw-resize" },
+  sw: { bottom: "0", left: "0", width: `${CORNER_SIZE_PX}px`, height: `${CORNER_SIZE_PX}px`, cursor: "nesw-resize" },
+  se: { bottom: "0", right: "0", width: `${CORNER_SIZE_PX}px`, height: `${CORNER_SIZE_PX}px`, cursor: "nwse-resize" },
+  n: { top: "0", left: `${CORNER_SIZE_PX}px`, right: `${CORNER_SIZE_PX}px`, height: `${EDGE_THICKNESS_PX}px`, cursor: "ns-resize" },
+  s: { bottom: "0", left: `${CORNER_SIZE_PX}px`, right: `${CORNER_SIZE_PX}px`, height: `${EDGE_THICKNESS_PX}px`, cursor: "ns-resize" },
+  e: { right: "0", top: `${CORNER_SIZE_PX}px`, bottom: `${CORNER_SIZE_PX}px`, width: `${EDGE_THICKNESS_PX}px`, cursor: "ew-resize" },
+  w: { left: "0", top: `${CORNER_SIZE_PX}px`, bottom: `${CORNER_SIZE_PX}px`, width: `${EDGE_THICKNESS_PX}px`, cursor: "ew-resize" }
+};
+function createResizeHandle(handle) {
+  const el = document.createElement("div");
+  el.dataset.freedomResizeHandle = handle;
+  el.className = `freedom-resize-handle freedom-resize-handle--${handle}`;
+  Object.assign(el.style, {
+    position: "absolute",
+    boxSizing: "border-box",
+    touchAction: "none",
+    userSelect: "none",
+    pointerEvents: "auto",
+    zIndex: "1",
+    ...EDGE_STYLES[handle]
+  });
+  return el;
+}
+
+// src/dom/scheduler.ts
+function createFrameScheduler(flush) {
+  let frameHandle = null;
+  return {
+    schedule() {
+      if (frameHandle !== null) return;
+      frameHandle = requestAnimationFrame(() => {
+        frameHandle = null;
+        flush();
+      });
+    },
+    cancel() {
+      if (frameHandle !== null) {
+        cancelAnimationFrame(frameHandle);
+        frameHandle = null;
+      }
+    }
+  };
+}
+
+// src/runtime/window.ts
+var ALL_HANDLES = ["n", "s", "e", "w", "nw", "ne", "sw", "se"];
+var instances = /* @__PURE__ */ new WeakMap();
+var autoId = 0;
+function createWindow(element, options = {}) {
+  if (typeof document === "undefined" || typeof window === "undefined") {
+    throw new Error("freedom.window() requires a browser environment. Importing is SSR-safe, but creating a window must run in the browser.");
+  }
+  assertHTMLElement(element);
+  if (instances.has(element)) {
+    throw new Error("freedom.window() was called more than once for the same element. Destroy the existing instance before creating a new one.");
+  }
+  const id = options.id ?? `freedom-window-${++autoId}`;
+  const emitter = new Emitter();
+  const plugins = options.plugins ?? [];
+  const limits = normalizeSizeLimits(options);
+  const positioning = resolvePositioning(element, options);
+  applyBaseStyles(element, {
+    positioning,
+    forcePositioning: shouldForcePositioning(element, options)
+  });
+  let size = clampSize(sanitizeSize(options.initialSize ?? readInitialSize(element), "initialSize"), limits);
+  let position = resolveInitialPosition(options.initialPosition, element, size, options.bounds, positioning);
+  const renderer = createPositionRenderer(element, positioning, position);
+  let zIndex = normalizeZIndex(options.zIndex ?? 0);
+  let focused = false;
+  let isDraggable = options.draggable ?? true;
+  let isDestroyed = false;
+  writeSize(element, size);
+  writePosition(element, position, renderer);
+  if (zIndex) element.style.zIndex = String(zIndex);
+  revealIfRequested(element, options);
+  let pendingPosition = null;
+  let pendingSize = null;
+  const scheduler = createFrameScheduler(() => {
+    if (isDestroyed) return;
+    if (pendingPosition) {
+      writePosition(element, pendingPosition, renderer);
+      pendingPosition = null;
+    }
+    if (pendingSize) {
+      writeSize(element, pendingSize);
+      pendingSize = null;
+    }
+  });
+  function paint(nextPosition, nextSize) {
+    if (nextPosition) pendingPosition = nextPosition;
+    if (nextSize) pendingSize = nextSize;
+    scheduler.schedule();
+  }
+  function assertAlive(method) {
+    if (isDestroyed) {
+      throw new Error(`Cannot call ${method}() on a destroyed freedom window.`);
+    }
+  }
+  const pluginContext = {
+    element,
+    get window() {
+      return api;
+    }
+  };
+  const dragHandleElement = resolveDragHandle(element, options.dragHandle);
+  function isDragTarget(target) {
+    if (!isDraggable || !dragHandleElement) return false;
+    if (!(target instanceof Node)) return false;
+    return dragHandleElement === target || dragHandleElement.contains(target);
+  }
+  const dragEngine = createDragEngine({
+    element,
+    bounds: options.bounds,
+    plugins,
+    pluginContext,
+    getPosition: () => position,
+    getSize: () => size
+  });
+  const resizeHandleElements = /* @__PURE__ */ new Map();
+  function resolveResizeHandle(target) {
+    if (!(target instanceof Element)) return null;
+    const handleEl = target.closest(".freedom-resize-handle");
+    if (!handleEl) return null;
+    for (const [handle, el] of resizeHandleElements) {
+      if (el === handleEl) return handle;
+    }
+    return null;
+  }
+  const resizeEngine = createResizeEngine({
+    element,
+    bounds: options.bounds,
+    ...limits,
+    plugins,
+    pluginContext,
+    getPosition: () => position,
+    getSize: () => size
+  });
+  function setupResizeHandles(handles) {
+    const normalizedHandles = normalizeResizeHandles(handles);
+    for (const handle of normalizedHandles) {
+      if (resizeHandleElements.has(handle)) continue;
+      const handleEl = createResizeHandle(handle);
+      element.appendChild(handleEl);
+      resizeHandleElements.set(handle, handleEl);
+    }
+  }
+  function teardownResizeHandles(handles = ALL_HANDLES) {
+    for (const handle of handles) {
+      const handleEl = resizeHandleElements.get(handle);
+      if (handleEl) {
+        handleEl.remove();
+        resizeHandleElements.delete(handle);
+      }
+    }
+  }
+  const interactionManager = createInteractionManager({
+    element,
+    dragEngine,
+    resizeEngine,
+    resolveResizeHandle,
+    isDragTarget,
+    onDragStart(data) {
+      element.classList.add("freedom-dragging");
+      emitter.emit("dragstart", data);
+    },
+    onDragMove({ position: next, data }) {
+      position = next;
+      paint(position);
+      emitter.emit("drag", data);
+    },
+    onDragEnd(data) {
+      element.classList.remove("freedom-dragging");
+      emitter.emit("dragend", data);
+    },
+    onResizeStart(data) {
+      element.classList.add("freedom-resizing");
+      emitter.emit("resizestart", data);
+    },
+    onResizeMove({ position: nextPosition, size: nextSize, data }) {
+      position = nextPosition;
+      size = nextSize;
+      paint(position, size);
+      emitter.emit("resize", data);
+    },
+    onResizeEnd(data) {
+      element.classList.remove("freedom-resizing");
+      emitter.emit("resizeend", data);
+    }
+  });
+  const initialResizeHandles = resolveEnabledHandles(options.resizable ?? true);
+  if (initialResizeHandles.length > 0) setupResizeHandles(initialResizeHandles);
+  const api = {
+    id,
+    element,
+    getPosition() {
+      assertAlive("getPosition");
+      return { ...position };
+    },
+    getSize() {
+      assertAlive("getSize");
+      return { ...size };
+    },
+    setPosition(point) {
+      assertAlive("setPosition");
+      position = sanitizePoint(point, "setPosition");
+      paint(position);
+    },
+    setSize(nextSize) {
+      assertAlive("setSize");
+      size = clampSize(sanitizeSize(nextSize, "setSize"), limits);
+      paint(void 0, size);
+    },
+    focus() {
+      assertAlive("focus");
+      if (focused) return;
+      focused = true;
+      element.classList.add("freedom-focused");
+      emitter.emit("focus", void 0);
+      options.onFocus?.();
+    },
+    blur() {
+      assertAlive("blur");
+      if (!focused) return;
+      focused = false;
+      element.classList.remove("freedom-focused");
+      emitter.emit("blur", void 0);
+      options.onBlur?.();
+    },
+    isFocused() {
+      assertAlive("isFocused");
+      return focused;
+    },
+    setZIndex(next) {
+      assertAlive("setZIndex");
+      zIndex = normalizeZIndex(next);
+      element.style.zIndex = String(zIndex);
+    },
+    getZIndex() {
+      assertAlive("getZIndex");
+      return zIndex;
+    },
+    enableDrag() {
+      assertAlive("enableDrag");
+      isDraggable = true;
+    },
+    disableDrag() {
+      assertAlive("disableDrag");
+      isDraggable = false;
+      if (interactionManager.active === "drag") {
+        interactionManager.cancel();
+        element.classList.remove("freedom-dragging");
+      }
+    },
+    enableResize(handles = ALL_HANDLES) {
+      assertAlive("enableResize");
+      setupResizeHandles(handles);
+    },
+    disableResize() {
+      assertAlive("disableResize");
+      if (interactionManager.active === "resize") {
+        interactionManager.cancel();
+        element.classList.remove("freedom-resizing");
+      }
+      teardownResizeHandles();
+    },
+    destroy() {
+      if (isDestroyed) return;
+      isDestroyed = true;
+      interactionManager.destroy();
+      teardownResizeHandles();
+      scheduler.cancel();
+      element.classList.remove("freedom-dragging", "freedom-resizing", "freedom-focused");
+      for (const plugin of plugins) plugin.onDestroy?.(pluginContext);
+      emitter.emit("destroy", void 0);
+      emitter.clear();
+      instances.delete(element);
+    },
+    on(event, handler) {
+      assertAlive("on");
+      return emitter.on(event, handler);
+    }
+  };
+  instances.set(element, api);
+  if (options.onDragStart) api.on("dragstart", options.onDragStart);
+  if (options.onDrag) api.on("drag", options.onDrag);
+  if (options.onDragEnd) api.on("dragend", options.onDragEnd);
+  if (options.onResizeStart) api.on("resizestart", options.onResizeStart);
+  if (options.onResize) api.on("resize", options.onResize);
+  if (options.onResizeEnd) api.on("resizeend", options.onResizeEnd);
+  for (const plugin of plugins) plugin.onInit?.(pluginContext);
+  return api;
+}
+function assertHTMLElement(element) {
+  const maybeElement = element;
+  const isUsableElement = !!maybeElement && typeof maybeElement === "object" && maybeElement.nodeType === 1 && typeof maybeElement.getBoundingClientRect === "function" && !!maybeElement.style && typeof maybeElement.addEventListener === "function" && typeof maybeElement.removeEventListener === "function";
+  if (!isUsableElement) {
+    throw new TypeError("freedom.window(element) expected a real HTMLElement. Received null, undefined, or a non-element value.");
+  }
+}
+function normalizeSizeLimits(options) {
+  const minWidth = finiteNonNegative(options.minWidth, 0);
+  const minHeight = finiteNonNegative(options.minHeight, 0);
+  const maxWidth = finitePositiveOrInfinity(options.maxWidth, Infinity);
+  const maxHeight = finitePositiveOrInfinity(options.maxHeight, Infinity);
+  return {
+    minWidth,
+    minHeight,
+    maxWidth: Math.max(minWidth, maxWidth),
+    maxHeight: Math.max(minHeight, maxHeight)
+  };
+}
+function finiteNonNegative(value, fallback) {
+  return typeof value === "number" && Number.isFinite(value) && value >= 0 ? value : fallback;
+}
+function finitePositiveOrInfinity(value, fallback) {
+  if (value === Infinity) return Infinity;
+  return typeof value === "number" && Number.isFinite(value) && value >= 0 ? value : fallback;
+}
+function normalizeZIndex(value) {
+  return Number.isFinite(value) ? Math.trunc(value) : 0;
+}
+function sanitizePoint(point, source) {
+  if (!point || typeof point.x !== "number" || typeof point.y !== "number" || !Number.isFinite(point.x) || !Number.isFinite(point.y)) {
+    throw new TypeError(`freedom.window(): ${source} expected a finite { x, y } point.`);
+  }
+  return { x: point.x, y: point.y };
+}
+function sanitizeSize(size, source) {
+  if (!size || typeof size.width !== "number" || typeof size.height !== "number" || !Number.isFinite(size.width) || !Number.isFinite(size.height)) {
+    throw new TypeError(`freedom.window(): ${source} expected a finite { width, height } size.`);
+  }
+  return { width: Math.max(0, size.width), height: Math.max(0, size.height) };
+}
+function shouldForcePositioning(element, options) {
+  const computed = window.getComputedStyle(element).position;
+  return Boolean(options.positioning) || computed === "static";
+}
+function resolvePositioning(element, options) {
+  if (options.positioning) return options.positioning;
+  const computed = window.getComputedStyle(element);
+  if (computed.position === "fixed") return "fixed";
+  if (computed.position === "absolute") return "absolute";
+  if (computed.position === "relative" || computed.position === "sticky") return "relative";
+  if (hasAuthoredInset(computed)) return "fixed";
+  if (options.initialPosition !== void 0) {
+    return options.bounds === "parent" ? "absolute" : "fixed";
+  }
+  return "relative";
+}
+function hasAuthoredInset(style) {
+  return [style.top, style.right, style.bottom, style.left].some((value) => {
+    if (!value || value === "auto") return false;
+    return value !== "0px" && value !== "0";
+  });
+}
+function resolveInitialPosition(initialPosition, element, size, bounds, positioning) {
+  if (initialPosition === "center") {
+    return centerPosition(element, size, bounds, positioning);
+  }
+  if (initialPosition) {
+    return sanitizePoint(initialPosition, "initialPosition");
+  }
+  return readRenderedPosition(element, positioning);
+}
+function centerPosition(element, size, bounds, positioning) {
+  const box = resolveCenterBox(element, bounds, positioning);
+  return {
+    x: Math.round(box.x + Math.max(0, box.width - size.width) / 2),
+    y: Math.round(box.y + Math.max(0, box.height - size.height) / 2)
+  };
+}
+function resolveCenterBox(element, bounds, positioning) {
+  if (bounds && typeof bounds === "object") {
+    return { x: bounds.x, y: bounds.y, width: bounds.width, height: bounds.height };
+  }
+  if (bounds === "parent") {
+    const parent = element.offsetParent;
+    if (parent) return { x: 0, y: 0, width: parent.clientWidth, height: parent.clientHeight };
+  }
+  if (positioning === "absolute" && bounds !== "viewport") {
+    const parent = element.offsetParent;
+    if (parent) return { x: 0, y: 0, width: parent.clientWidth, height: parent.clientHeight };
+  }
+  const root = document.documentElement;
+  return {
+    x: 0,
+    y: 0,
+    width: window.innerWidth || root.clientWidth,
+    height: window.innerHeight || root.clientHeight
+  };
+}
+function readInitialSize(element) {
+  const rect = element.getBoundingClientRect();
+  return {
+    width: rect.width || element.offsetWidth || 0,
+    height: rect.height || element.offsetHeight || 0
+  };
+}
+function revealIfRequested(element, options) {
+  if (options.autoReveal === false) return;
+  const visibility = window.getComputedStyle(element).visibility;
+  if (visibility === "hidden") {
+    element.style.visibility = "visible";
+  }
+}
+function resolveDragHandle(element, handleOption) {
+  if (handleOption === null) return null;
+  if (handleOption === void 0) return element;
+  if (typeof handleOption === "string") return element.querySelector(handleOption);
+  return handleOption;
+}
+function resolveEnabledHandles(option) {
+  if (option === false) return [];
+  if (option === true) return [...ALL_HANDLES];
+  return normalizeResizeHandles(option);
+}
+function normalizeResizeHandles(handles) {
+  const unique = /* @__PURE__ */ new Set();
+  for (const handle of handles) {
+    if (!ALL_HANDLES.includes(handle)) {
+      throw new TypeError(`freedom.window(): invalid resize handle "${String(handle)}".`);
+    }
+    unique.add(handle);
+  }
+  return [...unique];
+}
+
+export { createWindow, createWindow as window };
+//# sourceMappingURL=window.js.map
+//# sourceMappingURL=window.js.map