@vielzeug/orbit 1.0.3

package/dist/float.d.ts

@@ -0,0 +1,73 @@
+import type { ComputePositionOptions, ComputePositionResult, FloatHandle, Placement, ReferenceElement } from './types';
+import { type AutoUpdateOptions } from './auto-update';
+declare function isCssAnchorPositioningSupported(): boolean;
+export interface CssAnchorHandle extends FloatHandle {
+    /** Always `true` — position is managed natively by CSS Anchor Positioning. */
+    readonly cssAnchor: true;
+}
+/**
+ * Uses CSS Anchor Positioning to let the browser handle repositioning natively.
+ * No JavaScript positioning loop — the browser manages placement via `position-try-fallbacks`.
+ *
+ * Requires both elements to be `HTMLElement`. Falls back to `float()` for complex cases
+ * (e.g. middleware pipelines, custom apply callbacks).
+ *
+ * @experimental CSS Anchor Positioning support varies by browser. Check `isCssAnchorSupported()`
+ * before using in production.
+ *
+ * @example
+ * ```ts
+ * import { floatWithAnchor } from '@vielzeug/orbit';
+ *
+ * const handle = floatWithAnchor(trigger, tooltip, { placement: 'top' });
+ * // on hide:
+ * handle.dispose();
+ * ```
+ */
+export declare function floatWithAnchor(reference: HTMLElement, floating: HTMLElement, { fallbacks, placement, }?: {
+    fallbacks?: string;
+    placement?: Placement;
+}): CssAnchorHandle;
+/**
+ * Returns `true` when the browser supports CSS Anchor Positioning.
+ * Use to guard `floatWithAnchor()` calls in production.
+ */
+export { isCssAnchorPositioningSupported as isCssAnchorSupported };
+/**
+ * Options for `float()`. Extends `ComputePositionOptions` so all positioning
+ * options (`placement`, `middleware`, `boundary`, `padding`, `containingBlock`)
+ * are inherited directly.
+ */
+export interface FloatOptions extends ComputePositionOptions {
+    /**
+     * Custom callback to apply the computed position to the DOM.
+     * Called once per position update with the full `ComputePositionResult`.
+     * Defaults to writing `left` / `top` on the floating element (requires `position: fixed`).
+     */
+    apply?: (result: ComputePositionResult) => void;
+    /**
+     * Options for the auto-update loop. Omit to use defaults.
+     * Pass `false` to disable auto-updating (position is computed once on call).
+     */
+    autoUpdate?: AutoUpdateOptions | false;
+}
+/**
+ * High-level API: positions the floating element and continuously keeps it updated.
+ *
+ * For CSS Anchor Positioning (browser-native, no JS loop), use {@link floatWithAnchor} instead.
+ *
+ * Returns a {@link FloatHandle} with `dispose()`, `update()`, and `getPosition()`.
+ * Always call `dispose()` on teardown to remove listeners.
+ *
+ * @example
+ * ```ts
+ * const handle = float(trigger, tooltip, {
+ *   placement: 'top',
+ *   middleware: [offset(8), flip(), shift({ padding: 6 })],
+ * });
+ * // on hide:
+ * handle.dispose();
+ * ```
+ */
+export declare function float(reference: ReferenceElement, floating: HTMLElement, { apply, autoUpdate: autoUpdateOptions, boundary, containingBlock, middleware, padding, placement, }?: FloatOptions): FloatHandle;
+//# sourceMappingURL=float.d.ts.map

package/dist/float.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"float.d.ts","sourceRoot":"","sources":["../src/float.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,sBAAsB,EAAE,qBAAqB,EAAE,WAAW,EAAE,SAAS,EAAE,gBAAgB,EAAE,MAAM,SAAS,CAAC;AAEvH,OAAO,EAAc,KAAK,iBAAiB,EAAE,MAAM,eAAe,CAAC;AAyCnE,iBAAS,+BAA+B,IAAI,OAAO,CAElD;AAqED,MAAM,WAAW,eAAgB,SAAQ,WAAW;IAClD,8EAA8E;IAC9E,QAAQ,CAAC,SAAS,EAAE,IAAI,CAAC;CAC1B;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,eAAe,CAC7B,SAAS,EAAE,WAAW,EACtB,QAAQ,EAAE,WAAW,EACrB,EACE,SAA6D,EAC7D,SAAoB,GACrB,GAAE;IAAE,SAAS,CAAC,EAAE,MAAM,CAAC;IAAC,SAAS,CAAC,EAAE,SAAS,CAAA;CAAO,GACpD,eAAe,CASjB;AAED;;;GAGG;AACH,OAAO,EAAE,+BAA+B,IAAI,oBAAoB,EAAE,CAAC;AAInE;;;;GAIG;AACH,MAAM,WAAW,YAAa,SAAQ,sBAAsB;IAC1D;;;;OAIG;IACH,KAAK,CAAC,EAAE,CAAC,MAAM,EAAE,qBAAqB,KAAK,IAAI,CAAC;IAChD;;;OAGG;IACH,UAAU,CAAC,EAAE,iBAAiB,GAAG,KAAK,CAAC;CACxC;AAOD;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,KAAK,CACnB,SAAS,EAAE,gBAAgB,EAC3B,QAAQ,EAAE,WAAW,EACrB,EACE,KAAK,EACL,UAAU,EAAE,iBAAsB,EAClC,QAAQ,EACR,eAAe,EACf,UAAU,EACV,OAAO,EACP,SAAoB,GACrB,GAAE,YAAiB,GACnB,WAAW,CA4Bb"}

package/dist/float.js

@@ -0,0 +1,2 @@
+import{autoUpdate as e}from"./auto-update.js";import{computePosition as t}from"./core.js";function n(e,t,n){let r=new AbortController,i=!1;return{get disposalSignal(){return r.signal},dispose(){i||(i=!0,r.abort(),e())},get disposed(){return i},getPosition:t,[Symbol.dispose](){this.dispose()},update:n}}function r(){return typeof CSS<`u`&&CSS.supports(`anchor-name`,`--orbit`)}var i=0,a={bottom:`block-end center`,"bottom-end":`block-end span-inline-end`,"bottom-start":`block-end span-inline-start`,left:`inline-start center`,"left-end":`inline-start span-block-end`,"left-start":`inline-start span-block-start`,right:`inline-end center`,"right-end":`inline-end span-block-end`,"right-start":`inline-end span-block-start`,top:`block-start center`,"top-end":`block-start span-inline-end`,"top-start":`block-start span-inline-start`};function o(e,t){let n={};for(let r of Object.keys(t)){let i=e.style.getPropertyValue(r);n[r]=i===``?void 0:i,e.style.setProperty(r,t[r])}return()=>{for(let r of Object.keys(t)){let t=n[r];t===void 0?e.style.removeProperty(r):e.style.setProperty(r,t)}}}function s(e,t,n,r){let s=`--orbit-${++i}`,c=o(e,{"anchor-name":s}),l=o(t,{position:`fixed`,"position-anchor":s,"position-area":a[n],"position-try-fallbacks":r});return()=>{c(),l()}}function c(e,t,{fallbacks:r=`flip-block, flip-inline, flip-block flip-inline`,placement:i=`bottom`}={}){let a=s(e,t,i,r),o=n(()=>a(),()=>null,()=>{});return Object.assign(o,{cssAnchor:!0})}function l(e,t){t.style.left=`${e.x}px`,t.style.top=`${e.y}px`}function u(r,i,{apply:a,autoUpdate:o={},boundary:s,containingBlock:c,middleware:u,padding:d,placement:f=`bottom`}={}){let p=null,m=a??(e=>l(e,i));function h(){let e=t(r,i,{boundary:s,containingBlock:c,middleware:u,padding:d,placement:f});p=e,m(e)}if(o===!1)return h(),n(()=>{},()=>p,h);let g=e(r,i,h,o);return n(()=>g(),()=>p,h)}export{u as float,c as floatWithAnchor,r as isCssAnchorSupported,n as makeHandle};
+//# sourceMappingURL=float.js.map

package/dist/float.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"float.js","names":[],"sources":["../src/float.ts"],"sourcesContent":["import type { ComputePositionOptions, ComputePositionResult, FloatHandle, Placement, ReferenceElement } from './types';\n\nimport { autoUpdate, type AutoUpdateOptions } from './auto-update';\nimport { computePosition } from './core';\n\n// ── makeHandle ────────────────────────────────────────────────────────────────\n\n/**\n * Constructs a {@link FloatHandle} with idempotent dispose, disposalSignal, and disposed getter.\n * @internal — exported for use by ssr.ts and devtools.ts only.\n */\nexport function makeHandle(\n  rawDispose: () => void,\n  getPosition: () => ComputePositionResult | null,\n  update: () => void,\n): FloatHandle {\n  const controller = new AbortController();\n  let disposed = false;\n\n  return {\n    get disposalSignal() {\n      return controller.signal;\n    },\n    dispose() {\n      if (disposed) return;\n\n      disposed = true;\n      controller.abort();\n      rawDispose();\n    },\n    get disposed() {\n      return disposed;\n    },\n    getPosition,\n    [Symbol.dispose](): void {\n      this.dispose();\n    },\n    update,\n  };\n}\n\n// ── CSS Anchor Positioning ────────────────────────────────────────────────────\n\nfunction isCssAnchorPositioningSupported(): boolean {\n  return typeof CSS !== 'undefined' && CSS.supports('anchor-name', '--orbit');\n}\n\nlet anchorCounter = 0;\n\n/**\n * Maps a placement to the CSS `position-area` value.\n * https://drafts.csswg.org/css-anchor-position/#position-area\n */\nconst POSITION_AREA: Record<Placement, string> = {\n  bottom: 'block-end center',\n  'bottom-end': 'block-end span-inline-end',\n  'bottom-start': 'block-end span-inline-start',\n  left: 'inline-start center',\n  'left-end': 'inline-start span-block-end',\n  'left-start': 'inline-start span-block-start',\n  right: 'inline-end center',\n  'right-end': 'inline-end span-block-end',\n  'right-start': 'inline-end span-block-start',\n  top: 'block-start center',\n  'top-end': 'block-start span-inline-end',\n  'top-start': 'block-start span-inline-start',\n};\n\n/** Applies a set of CSS properties to an element and returns a cleanup that restores them. */\nfunction withStyles(el: HTMLElement, props: Record<string, string>): () => void {\n  const saved: Record<string, string | undefined> = {};\n\n  for (const prop of Object.keys(props)) {\n    const prev = el.style.getPropertyValue(prop);\n\n    saved[prop] = prev !== '' ? prev : undefined;\n    el.style.setProperty(prop, props[prop]);\n  }\n\n  return () => {\n    for (const prop of Object.keys(props)) {\n      const prev = saved[prop];\n\n      if (prev !== undefined) {\n        el.style.setProperty(prop, prev);\n      } else {\n        el.style.removeProperty(prop);\n      }\n    }\n  };\n}\n\nfunction setupCssAnchorPositioning(\n  reference: HTMLElement,\n  floating: HTMLElement,\n  placement: Placement,\n  fallbacks: string,\n): () => void {\n  const name = `--orbit-${++anchorCounter}`;\n\n  const cleanupRef = withStyles(reference, { 'anchor-name': name });\n  const cleanupFloat = withStyles(floating, {\n    position: 'fixed',\n    'position-anchor': name,\n    'position-area': POSITION_AREA[placement],\n    'position-try-fallbacks': fallbacks,\n  });\n\n  return () => {\n    cleanupRef();\n    cleanupFloat();\n  };\n}\n\nexport interface CssAnchorHandle extends FloatHandle {\n  /** Always `true` — position is managed natively by CSS Anchor Positioning. */\n  readonly cssAnchor: true;\n}\n\n/**\n * Uses CSS Anchor Positioning to let the browser handle repositioning natively.\n * No JavaScript positioning loop — the browser manages placement via `position-try-fallbacks`.\n *\n * Requires both elements to be `HTMLElement`. Falls back to `float()` for complex cases\n * (e.g. middleware pipelines, custom apply callbacks).\n *\n * @experimental CSS Anchor Positioning support varies by browser. Check `isCssAnchorSupported()`\n * before using in production.\n *\n * @example\n * ```ts\n * import { floatWithAnchor } from '@vielzeug/orbit';\n *\n * const handle = floatWithAnchor(trigger, tooltip, { placement: 'top' });\n * // on hide:\n * handle.dispose();\n * ```\n */\nexport function floatWithAnchor(\n  reference: HTMLElement,\n  floating: HTMLElement,\n  {\n    fallbacks = 'flip-block, flip-inline, flip-block flip-inline',\n    placement = 'bottom',\n  }: { fallbacks?: string; placement?: Placement } = {},\n): CssAnchorHandle {\n  const cleanupFn = setupCssAnchorPositioning(reference, floating, placement, fallbacks);\n  const base = makeHandle(\n    () => cleanupFn(),\n    () => null,\n    () => {},\n  );\n\n  return Object.assign(base, { cssAnchor: true as const });\n}\n\n/**\n * Returns `true` when the browser supports CSS Anchor Positioning.\n * Use to guard `floatWithAnchor()` calls in production.\n */\nexport { isCssAnchorPositioningSupported as isCssAnchorSupported };\n\n// ── float() ───────────────────────────────────────────────────────────────────\n\n/**\n * Options for `float()`. Extends `ComputePositionOptions` so all positioning\n * options (`placement`, `middleware`, `boundary`, `padding`, `containingBlock`)\n * are inherited directly.\n */\nexport interface FloatOptions extends ComputePositionOptions {\n  /**\n   * Custom callback to apply the computed position to the DOM.\n   * Called once per position update with the full `ComputePositionResult`.\n   * Defaults to writing `left` / `top` on the floating element (requires `position: fixed`).\n   */\n  apply?: (result: ComputePositionResult) => void;\n  /**\n   * Options for the auto-update loop. Omit to use defaults.\n   * Pass `false` to disable auto-updating (position is computed once on call).\n   */\n  autoUpdate?: AutoUpdateOptions | false;\n}\n\nfunction applyDefault(result: ComputePositionResult, floating: HTMLElement): void {\n  floating.style.left = `${result.x}px`;\n  floating.style.top = `${result.y}px`;\n}\n\n/**\n * High-level API: positions the floating element and continuously keeps it updated.\n *\n * For CSS Anchor Positioning (browser-native, no JS loop), use {@link floatWithAnchor} instead.\n *\n * Returns a {@link FloatHandle} with `dispose()`, `update()`, and `getPosition()`.\n * Always call `dispose()` on teardown to remove listeners.\n *\n * @example\n * ```ts\n * const handle = float(trigger, tooltip, {\n *   placement: 'top',\n *   middleware: [offset(8), flip(), shift({ padding: 6 })],\n * });\n * // on hide:\n * handle.dispose();\n * ```\n */\nexport function float(\n  reference: ReferenceElement,\n  floating: HTMLElement,\n  {\n    apply,\n    autoUpdate: autoUpdateOptions = {},\n    boundary,\n    containingBlock,\n    middleware,\n    padding,\n    placement = 'bottom',\n  }: FloatOptions = {},\n): FloatHandle {\n  let lastPosition: ComputePositionResult | null = null;\n  const applyFn = apply ?? ((result) => applyDefault(result, floating));\n\n  function update(): void {\n    const result = computePosition(reference, floating, { boundary, containingBlock, middleware, padding, placement });\n\n    lastPosition = result;\n    applyFn(result);\n  }\n\n  if (autoUpdateOptions === false) {\n    update();\n\n    return makeHandle(\n      () => {},\n      () => lastPosition,\n      update,\n    );\n  }\n\n  const cleanupFn = autoUpdate(reference, floating, update, autoUpdateOptions);\n\n  return makeHandle(\n    () => cleanupFn(),\n    () => lastPosition,\n    update,\n  );\n}\n"],"mappings":"0FAWA,SAAgB,EACd,EACA,EACA,EACa,CACb,IAAM,EAAa,IAAI,gBACnB,EAAW,GAEf,MAAO,CACL,IAAI,gBAAiB,CACnB,OAAO,EAAW,MACpB,EACA,SAAU,CACJ,IAEJ,EAAW,GACX,EAAW,MAAM,EACjB,EAAW,EACb,EACA,IAAI,UAAW,CACb,OAAO,CACT,EACA,cACA,CAAC,OAAO,UAAiB,CACvB,KAAK,QAAQ,CACf,EACA,QACF,CACF,CAIA,SAAS,GAA2C,CAClD,OAAO,OAAO,IAAQ,KAAe,IAAI,SAAS,cAAe,SAAS,CAC5E,CAEA,IAAI,EAAgB,EAMd,EAA2C,CAC/C,OAAQ,mBACR,aAAc,4BACd,eAAgB,8BAChB,KAAM,sBACN,WAAY,8BACZ,aAAc,gCACd,MAAO,oBACP,YAAa,4BACb,cAAe,8BACf,IAAK,qBACL,UAAW,8BACX,YAAa,+BACf,EAGA,SAAS,EAAW,EAAiB,EAA2C,CAC9E,IAAM,EAA4C,CAAC,EAEnD,IAAK,IAAM,KAAQ,OAAO,KAAK,CAAK,EAAG,CACrC,IAAM,EAAO,EAAG,MAAM,iBAAiB,CAAI,EAE3C,EAAM,GAAQ,IAAS,GAAY,IAAA,GAAP,EAC5B,EAAG,MAAM,YAAY,EAAM,EAAM,EAAK,CACxC,CAEA,UAAa,CACX,IAAK,IAAM,KAAQ,OAAO,KAAK,CAAK,EAAG,CACrC,IAAM,EAAO,EAAM,GAEf,IAAS,IAAA,GAGX,EAAG,MAAM,eAAe,CAAI,EAF5B,EAAG,MAAM,YAAY,EAAM,CAAI,CAInC,CACF,CACF,CAEA,SAAS,EACP,EACA,EACA,EACA,EACY,CACZ,IAAM,EAAO,WAAW,EAAE,IAEpB,EAAa,EAAW,EAAW,CAAE,cAAe,CAAK,CAAC,EAC1D,EAAe,EAAW,EAAU,CACxC,SAAU,QACV,kBAAmB,EACnB,gBAAiB,EAAc,GAC/B,yBAA0B,CAC5B,CAAC,EAED,UAAa,CACX,EAAW,EACX,EAAa,CACf,CACF,CA0BA,SAAgB,EACd,EACA,EACA,CACE,YAAY,kDACZ,YAAY,UACqC,CAAC,EACnC,CACjB,IAAM,EAAY,EAA0B,EAAW,EAAU,EAAW,CAAS,EAC/E,EAAO,MACL,EAAU,MACV,SACA,CAAC,CACT,EAEA,OAAO,OAAO,OAAO,EAAM,CAAE,UAAW,EAAc,CAAC,CACzD,CA6BA,SAAS,EAAa,EAA+B,EAA6B,CAChF,EAAS,MAAM,KAAO,GAAG,EAAO,EAAE,IAClC,EAAS,MAAM,IAAM,GAAG,EAAO,EAAE,GACnC,CAoBA,SAAgB,EACd,EACA,EACA,CACE,QACA,WAAY,EAAoB,CAAC,EACjC,WACA,kBACA,aACA,UACA,YAAY,UACI,CAAC,EACN,CACb,IAAI,EAA6C,KAC3C,EAAU,IAAW,GAAW,EAAa,EAAQ,CAAQ,GAEnE,SAAS,GAAe,CACtB,IAAM,EAAS,EAAgB,EAAW,EAAU,CAAE,WAAU,kBAAiB,aAAY,UAAS,WAAU,CAAC,EAEjH,EAAe,EACf,EAAQ,CAAM,CAChB,CAEA,GAAI,IAAsB,GAGxB,OAFA,EAAO,EAEA,MACC,CAAC,MACD,EACN,CACF,EAGF,IAAM,EAAY,EAAW,EAAW,EAAU,EAAQ,CAAiB,EAE3E,OAAO,MACC,EAAU,MACV,EACN,CACF,CACF"}

package/dist/index.cjs

@@ -0,0 +1 @@
+Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const e=require("./errors.cjs"),t=require("./utils.cjs"),n=require("./auto-update.cjs"),r=require("./core.cjs"),i=require("./float.cjs"),a=require("./overflow.cjs"),o=require("./compose.cjs"),s=require("./middleware/arrow.cjs"),c=require("./middleware/auto-placement.cjs"),l=require("./middleware/flip.cjs"),u=require("./middleware/hide.cjs"),d=require("./inline.cjs"),f=require("./middleware/offset.cjs"),p=require("./middleware/shift.cjs"),m=require("./middleware/size.cjs");exports.OrbitConfigError=e.OrbitConfigError,exports.OrbitError=e.OrbitError,exports.arrow=s.arrow,exports.autoPlacement=c.autoPlacement,exports.autoUpdate=n.autoUpdate,exports.compose=o.compose,exports.computePosition=r.computePosition,exports.computePositionAsync=r.computePositionAsync,exports.computePositionRaf=r.computePositionRaf,exports.detectOverflow=a.detectOverflow,exports.flip=l.flip,exports.float=i.float,exports.floatWithAnchor=i.floatWithAnchor,exports.getAlignment=t.getAlignment,exports.getRects=r.getRects,exports.getSide=t.getSide,exports.hide=u.hide,exports.inline=d.inline,exports.isCssAnchorSupported=i.isCssAnchorSupported,exports.limitShift=p.limitShift,exports.offset=f.offset,exports.shift=p.shift,exports.size=m.size;

package/dist/index.d.ts

@@ -0,0 +1,28 @@
+export { OrbitConfigError, OrbitError } from './errors';
+export { computePosition, computePositionAsync, computePositionRaf, getRects } from './core';
+export { detectOverflow } from './overflow';
+export { float, floatWithAnchor, isCssAnchorSupported } from './float';
+export type { CssAnchorHandle, FloatOptions } from './float';
+export { autoUpdate } from './auto-update';
+export type { AutoUpdateOptions } from './auto-update';
+export { compose } from './compose';
+export { arrow } from './middleware/arrow';
+export type { ArrowOptions } from './middleware/arrow';
+export { autoPlacement } from './middleware/auto-placement';
+export type { AutoPlacementOptions } from './middleware/auto-placement';
+export { flip } from './middleware/flip';
+export type { FlipOptions } from './middleware/flip';
+export { hide } from './middleware/hide';
+export type { HideOptions } from './middleware/hide';
+export { inline } from './inline';
+export type { InlineOptions } from './inline';
+export { offset } from './middleware/offset';
+export type { OffsetConfig, OffsetValue } from './middleware/offset';
+export { limitShift, shift } from './middleware/shift';
+export type { LimitShiftOptions, ShiftLimiter, ShiftOptions } from './middleware/shift';
+export { size } from './middleware/size';
+export type { SizeOptions } from './middleware/size';
+export type { PositioningPreset, PresetOptions } from './presets';
+export { getAlignment, getSide } from './utils';
+export type { Alignment, ArrowData, ComputePositionOptions, ComputePositionResult, DetectOverflowOptions, FlipData, FloatHandle, HideData, Middleware, MiddlewareData, MiddlewareReset, MiddlewareResult, MiddlewareState, Padding, Placement, Rect, ReferenceElement, ShiftData, Side, SideObject, SizeData, TypedMiddleware, VirtualReference, } from './types';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,gBAAgB,EAAE,UAAU,EAAE,MAAM,UAAU,CAAC;AAGxD,OAAO,EAAE,eAAe,EAAE,oBAAoB,EAAE,kBAAkB,EAAE,QAAQ,EAAE,MAAM,QAAQ,CAAC;AAC7F,OAAO,EAAE,cAAc,EAAE,MAAM,YAAY,CAAC;AAG5C,OAAO,EAAE,KAAK,EAAE,eAAe,EAAE,oBAAoB,EAAE,MAAM,SAAS,CAAC;AACvE,YAAY,EAAE,eAAe,EAAE,YAAY,EAAE,MAAM,SAAS,CAAC;AAG7D,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAC3C,YAAY,EAAE,iBAAiB,EAAE,MAAM,eAAe,CAAC;AAGvD,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAGpC,OAAO,EAAE,KAAK,EAAE,MAAM,oBAAoB,CAAC;AAC3C,YAAY,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAEvD,OAAO,EAAE,aAAa,EAAE,MAAM,6BAA6B,CAAC;AAC5D,YAAY,EAAE,oBAAoB,EAAE,MAAM,6BAA6B,CAAC;AAExE,OAAO,EAAE,IAAI,EAAE,MAAM,mBAAmB,CAAC;AACzC,YAAY,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAErD,OAAO,EAAE,IAAI,EAAE,MAAM,mBAAmB,CAAC;AACzC,YAAY,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAErD,OAAO,EAAE,MAAM,EAAE,MAAM,UAAU,CAAC;AAClC,YAAY,EAAE,aAAa,EAAE,MAAM,UAAU,CAAC;AAE9C,OAAO,EAAE,MAAM,EAAE,MAAM,qBAAqB,CAAC;AAC7C,YAAY,EAAE,YAAY,EAAE,WAAW,EAAE,MAAM,qBAAqB,CAAC;AAErE,OAAO,EAAE,UAAU,EAAE,KAAK,EAAE,MAAM,oBAAoB,CAAC;AACvD,YAAY,EAAE,iBAAiB,EAAE,YAAY,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAExF,OAAO,EAAE,IAAI,EAAE,MAAM,mBAAmB,CAAC;AACzC,YAAY,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAGrD,YAAY,EAAE,iBAAiB,EAAE,aAAa,EAAE,MAAM,WAAW,CAAC;AAGlE,OAAO,EAAE,YAAY,EAAE,OAAO,EAAE,MAAM,SAAS,CAAC;AAGhD,YAAY,EACV,SAAS,EACT,SAAS,EACT,sBAAsB,EACtB,qBAAqB,EACrB,qBAAqB,EACrB,QAAQ,EACR,WAAW,EACX,QAAQ,EACR,UAAU,EACV,cAAc,EACd,eAAe,EACf,gBAAgB,EAChB,eAAe,EACf,OAAO,EACP,SAAS,EACT,IAAI,EACJ,gBAAgB,EAChB,SAAS,EACT,IAAI,EACJ,UAAU,EACV,QAAQ,EACR,eAAe,EACf,gBAAgB,GACjB,MAAM,SAAS,CAAC"}

package/dist/index.js

@@ -0,0 +1 @@
+import{OrbitConfigError as e,OrbitError as t}from"./errors.js";import{getAlignment as n,getSide as r}from"./utils.js";import{autoUpdate as i}from"./auto-update.js";import{computePosition as a,computePositionAsync as o,computePositionRaf as s,getRects as c}from"./core.js";import{float as l,floatWithAnchor as u,isCssAnchorSupported as d}from"./float.js";import{detectOverflow as f}from"./overflow.js";import{compose as p}from"./compose.js";import{arrow as m}from"./middleware/arrow.js";import{autoPlacement as h}from"./middleware/auto-placement.js";import{flip as g}from"./middleware/flip.js";import{hide as _}from"./middleware/hide.js";import{inline as v}from"./inline.js";import{offset as y}from"./middleware/offset.js";import{limitShift as b,shift as x}from"./middleware/shift.js";import{size as S}from"./middleware/size.js";export{e as OrbitConfigError,t as OrbitError,m as arrow,h as autoPlacement,i as autoUpdate,p as compose,a as computePosition,o as computePositionAsync,s as computePositionRaf,f as detectOverflow,g as flip,l as float,u as floatWithAnchor,n as getAlignment,c as getRects,r as getSide,_ as hide,v as inline,d as isCssAnchorSupported,b as limitShift,y as offset,x as shift,S as size};

package/dist/inline.cjs

@@ -0,0 +1,2 @@
+Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const e=require("./utils.cjs");function t(t){return!(`getClientRects`in t)||typeof t.getClientRects!=`function`?[]:Array.from(t.getClientRects()).map(e.toRect).filter(e=>e.width>0||e.height>0)}function n(e,t,n,r){return t>=e.x-r.left&&t<=e.x+e.width+r.right&&n>=e.y-r.top&&n<=e.y+e.height+r.bottom}function r(e,t){return e.x===t.x&&e.y===t.y&&e.width===t.width&&e.height===t.height}function i(i={}){function a(a){let o=t(a.elements.reference);if(o.length<=1)return;let s=e.toSideObject(i.padding??2),c=e.getSide(a.placement),l=o[0];if(i.x!=null&&i.y!=null)l=o.find(e=>n(e,i.x,i.y,s))??l;else if(c===`top`||c===`bottom`){let e=a.x+a.rects.floating.width/2;l=o.reduce((t,n)=>{let r=Math.abs(t.x+t.width/2-e);return Math.abs(n.x+n.width/2-e)<r?n:t},l)}else{let e=a.y+a.rects.floating.height/2;l=o.reduce((t,n)=>{let r=Math.abs(t.y+t.height/2-e);return Math.abs(n.y+n.height/2-e)<r?n:t},l)}if(!r(l,a.rects.reference))return{reset:{rects:{...a.rects,reference:l}}}}return e.tagMiddleware(a,`inline`)}exports.inline=i;
+//# sourceMappingURL=inline.cjs.map

package/dist/inline.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"inline.cjs","names":[],"sources":["../src/inline.ts"],"sourcesContent":["import type { Middleware, Padding, Rect, ReferenceElement } from './types';\n\nimport { getSide, tagMiddleware, toRect, toSideObject } from './utils';\n\n// ── Private helpers (only used by inline) ────────────────────────────────────────────\n\nfunction getClientRects(reference: ReferenceElement): Rect[] {\n  if (!('getClientRects' in reference) || typeof reference.getClientRects !== 'function') return [];\n\n  return Array.from((reference.getClientRects as () => DOMRectList | DOMRect[])())\n    .map(toRect)\n    .filter((r) => r.width > 0 || r.height > 0);\n}\n\nfunction rectContainsPoint(rect: Rect, x: number, y: number, padding: ReturnType<typeof toSideObject>): boolean {\n  return (\n    x >= rect.x - padding.left &&\n    x <= rect.x + rect.width + padding.right &&\n    y >= rect.y - padding.top &&\n    y <= rect.y + rect.height + padding.bottom\n  );\n}\n\nfunction sameRect(a: Rect, b: Rect): boolean {\n  return a.x === b.x && a.y === b.y && a.width === b.width && a.height === b.height;\n}\n\n// ── Inline middleware ─────────────────────────────────────────────────────────────────\n\nexport interface InlineOptions {\n  /**\n   * Cursor x-coordinate. When provided alongside `y`, the middleware picks the\n   * client rect that contains the cursor instead of the closest rect to the floating element.\n   */\n  x?: number;\n  /** Cursor y-coordinate. */\n  y?: number;\n  /**\n   * Padding used when hit-testing cursor coordinates against client rects.\n   * Prevents snapping when the cursor is just outside a rect edge. Default: `2`.\n   *\n   * @remarks Only applies when both `x` and `y` are provided.\n   */\n  padding?: Padding;\n}\n\n/**\n * Improves positioning accuracy for inline references that span multiple lines\n * (e.g. `<span>` wrapping across line breaks).\n *\n * Must be placed **before** `flip()` and other middleware in the pipeline.\n *\n * @example Tooltip on selected text:\n * ```ts\n * import { inline, float, flip, shift } from '@vielzeug/orbit';\n *\n * float(selectionRef, tooltip, {\n *   placement: 'top',\n *   middleware: [inline({ x: cursorX, y: cursorY }), flip(), shift({ padding: 6 })],\n * });\n * ```\n */\nexport function inline(options: InlineOptions = {}): Middleware {\n  function inlineMiddleware(state: Parameters<Middleware>[0]): ReturnType<Middleware> {\n    const rects = getClientRects(state.elements.reference);\n\n    if (rects.length <= 1) return;\n\n    const padding = toSideObject(options.padding ?? 2);\n    const side = getSide(state.placement);\n    let nextRect = rects[0]!;\n\n    if (options.x != null && options.y != null) {\n      nextRect = rects.find((rect) => rectContainsPoint(rect, options.x!, options.y!, padding)) ?? nextRect;\n    } else if (side === 'top' || side === 'bottom') {\n      const targetX = state.x + state.rects.floating.width / 2;\n\n      nextRect = rects.reduce((best, rect) => {\n        const bestDist = Math.abs(best.x + best.width / 2 - targetX);\n        const rectDist = Math.abs(rect.x + rect.width / 2 - targetX);\n\n        return rectDist < bestDist ? rect : best;\n      }, nextRect);\n    } else {\n      const targetY = state.y + state.rects.floating.height / 2;\n\n      nextRect = rects.reduce((best, rect) => {\n        const bestDist = Math.abs(best.y + best.height / 2 - targetY);\n        const rectDist = Math.abs(rect.y + rect.height / 2 - targetY);\n\n        return rectDist < bestDist ? rect : best;\n      }, nextRect);\n    }\n\n    if (sameRect(nextRect, state.rects.reference)) return;\n\n    return { reset: { rects: { ...state.rects, reference: nextRect } } };\n  }\n\n  return tagMiddleware(inlineMiddleware, 'inline');\n}\n"],"mappings":"kGAMA,SAAS,EAAe,EAAqC,CAG3D,MAFI,EAAE,mBAAoB,IAAc,OAAO,EAAU,gBAAmB,WAAmB,CAAC,EAEzF,MAAM,KAAM,EAAU,eAAiD,CAAC,CAAC,CAC7E,IAAI,EAAA,MAAM,CAAC,CACX,OAAQ,GAAM,EAAE,MAAQ,GAAK,EAAE,OAAS,CAAC,CAC9C,CAEA,SAAS,EAAkB,EAAY,EAAW,EAAW,EAAmD,CAC9G,OACE,GAAK,EAAK,EAAI,EAAQ,MACtB,GAAK,EAAK,EAAI,EAAK,MAAQ,EAAQ,OACnC,GAAK,EAAK,EAAI,EAAQ,KACtB,GAAK,EAAK,EAAI,EAAK,OAAS,EAAQ,MAExC,CAEA,SAAS,EAAS,EAAS,EAAkB,CAC3C,OAAO,EAAE,IAAM,EAAE,GAAK,EAAE,IAAM,EAAE,GAAK,EAAE,QAAU,EAAE,OAAS,EAAE,SAAW,EAAE,MAC7E,CAqCA,SAAgB,EAAO,EAAyB,CAAC,EAAe,CAC9D,SAAS,EAAiB,EAA0D,CAClF,IAAM,EAAQ,EAAe,EAAM,SAAS,SAAS,EAErD,GAAI,EAAM,QAAU,EAAG,OAEvB,IAAM,EAAU,EAAA,aAAa,EAAQ,SAAW,CAAC,EAC3C,EAAO,EAAA,QAAQ,EAAM,SAAS,EAChC,EAAW,EAAM,GAErB,GAAI,EAAQ,GAAK,MAAQ,EAAQ,GAAK,KACpC,EAAW,EAAM,KAAM,GAAS,EAAkB,EAAM,EAAQ,EAAI,EAAQ,EAAI,CAAO,CAAC,GAAK,OACxF,GAAI,IAAS,OAAS,IAAS,SAAU,CAC9C,IAAM,EAAU,EAAM,EAAI,EAAM,MAAM,SAAS,MAAQ,EAEvD,EAAW,EAAM,QAAQ,EAAM,IAAS,CACtC,IAAM,EAAW,KAAK,IAAI,EAAK,EAAI,EAAK,MAAQ,EAAI,CAAO,EAG3D,OAFiB,KAAK,IAAI,EAAK,EAAI,EAAK,MAAQ,EAAI,CAE7C,EAAW,EAAW,EAAO,CACtC,EAAG,CAAQ,CACb,KAAO,CACL,IAAM,EAAU,EAAM,EAAI,EAAM,MAAM,SAAS,OAAS,EAExD,EAAW,EAAM,QAAQ,EAAM,IAAS,CACtC,IAAM,EAAW,KAAK,IAAI,EAAK,EAAI,EAAK,OAAS,EAAI,CAAO,EAG5D,OAFiB,KAAK,IAAI,EAAK,EAAI,EAAK,OAAS,EAAI,CAE9C,EAAW,EAAW,EAAO,CACtC,EAAG,CAAQ,CACb,CAEI,MAAS,EAAU,EAAM,MAAM,SAAS,EAE5C,MAAO,CAAE,MAAO,CAAE,MAAO,CAAE,GAAG,EAAM,MAAO,UAAW,CAAS,CAAE,CAAE,CACrE,CAEA,OAAO,EAAA,cAAc,EAAkB,QAAQ,CACjD"}

package/dist/inline.d.ts

@@ -0,0 +1,35 @@
+import type { Middleware, Padding } from './types';
+export interface InlineOptions {
+    /**
+     * Cursor x-coordinate. When provided alongside `y`, the middleware picks the
+     * client rect that contains the cursor instead of the closest rect to the floating element.
+     */
+    x?: number;
+    /** Cursor y-coordinate. */
+    y?: number;
+    /**
+     * Padding used when hit-testing cursor coordinates against client rects.
+     * Prevents snapping when the cursor is just outside a rect edge. Default: `2`.
+     *
+     * @remarks Only applies when both `x` and `y` are provided.
+     */
+    padding?: Padding;
+}
+/**
+ * Improves positioning accuracy for inline references that span multiple lines
+ * (e.g. `<span>` wrapping across line breaks).
+ *
+ * Must be placed **before** `flip()` and other middleware in the pipeline.
+ *
+ * @example Tooltip on selected text:
+ * ```ts
+ * import { inline, float, flip, shift } from '@vielzeug/orbit';
+ *
+ * float(selectionRef, tooltip, {
+ *   placement: 'top',
+ *   middleware: [inline({ x: cursorX, y: cursorY }), flip(), shift({ padding: 6 })],
+ * });
+ * ```
+ */
+export declare function inline(options?: InlineOptions): Middleware;
+//# sourceMappingURL=inline.d.ts.map

package/dist/inline.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"inline.d.ts","sourceRoot":"","sources":["../src/inline.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,OAAO,EAA0B,MAAM,SAAS,CAAC;AA6B3E,MAAM,WAAW,aAAa;IAC5B;;;OAGG;IACH,CAAC,CAAC,EAAE,MAAM,CAAC;IACX,2BAA2B;IAC3B,CAAC,CAAC,EAAE,MAAM,CAAC;IACX;;;;;OAKG;IACH,OAAO,CAAC,EAAE,OAAO,CAAC;CACnB;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,MAAM,CAAC,OAAO,GAAE,aAAkB,GAAG,UAAU,CAsC9D"}

package/dist/inline.js

@@ -0,0 +1,2 @@
+import{getSide as e,tagMiddleware as t,toRect as n,toSideObject as r}from"./utils.js";function i(e){return!(`getClientRects`in e)||typeof e.getClientRects!=`function`?[]:Array.from(e.getClientRects()).map(n).filter(e=>e.width>0||e.height>0)}function a(e,t,n,r){return t>=e.x-r.left&&t<=e.x+e.width+r.right&&n>=e.y-r.top&&n<=e.y+e.height+r.bottom}function o(e,t){return e.x===t.x&&e.y===t.y&&e.width===t.width&&e.height===t.height}function s(n={}){function s(t){let s=i(t.elements.reference);if(s.length<=1)return;let c=r(n.padding??2),l=e(t.placement),u=s[0];if(n.x!=null&&n.y!=null)u=s.find(e=>a(e,n.x,n.y,c))??u;else if(l===`top`||l===`bottom`){let e=t.x+t.rects.floating.width/2;u=s.reduce((t,n)=>{let r=Math.abs(t.x+t.width/2-e);return Math.abs(n.x+n.width/2-e)<r?n:t},u)}else{let e=t.y+t.rects.floating.height/2;u=s.reduce((t,n)=>{let r=Math.abs(t.y+t.height/2-e);return Math.abs(n.y+n.height/2-e)<r?n:t},u)}if(!o(u,t.rects.reference))return{reset:{rects:{...t.rects,reference:u}}}}return t(s,`inline`)}export{s as inline};
+//# sourceMappingURL=inline.js.map

package/dist/inline.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"inline.js","names":[],"sources":["../src/inline.ts"],"sourcesContent":["import type { Middleware, Padding, Rect, ReferenceElement } from './types';\n\nimport { getSide, tagMiddleware, toRect, toSideObject } from './utils';\n\n// ── Private helpers (only used by inline) ────────────────────────────────────────────\n\nfunction getClientRects(reference: ReferenceElement): Rect[] {\n  if (!('getClientRects' in reference) || typeof reference.getClientRects !== 'function') return [];\n\n  return Array.from((reference.getClientRects as () => DOMRectList | DOMRect[])())\n    .map(toRect)\n    .filter((r) => r.width > 0 || r.height > 0);\n}\n\nfunction rectContainsPoint(rect: Rect, x: number, y: number, padding: ReturnType<typeof toSideObject>): boolean {\n  return (\n    x >= rect.x - padding.left &&\n    x <= rect.x + rect.width + padding.right &&\n    y >= rect.y - padding.top &&\n    y <= rect.y + rect.height + padding.bottom\n  );\n}\n\nfunction sameRect(a: Rect, b: Rect): boolean {\n  return a.x === b.x && a.y === b.y && a.width === b.width && a.height === b.height;\n}\n\n// ── Inline middleware ─────────────────────────────────────────────────────────────────\n\nexport interface InlineOptions {\n  /**\n   * Cursor x-coordinate. When provided alongside `y`, the middleware picks the\n   * client rect that contains the cursor instead of the closest rect to the floating element.\n   */\n  x?: number;\n  /** Cursor y-coordinate. */\n  y?: number;\n  /**\n   * Padding used when hit-testing cursor coordinates against client rects.\n   * Prevents snapping when the cursor is just outside a rect edge. Default: `2`.\n   *\n   * @remarks Only applies when both `x` and `y` are provided.\n   */\n  padding?: Padding;\n}\n\n/**\n * Improves positioning accuracy for inline references that span multiple lines\n * (e.g. `<span>` wrapping across line breaks).\n *\n * Must be placed **before** `flip()` and other middleware in the pipeline.\n *\n * @example Tooltip on selected text:\n * ```ts\n * import { inline, float, flip, shift } from '@vielzeug/orbit';\n *\n * float(selectionRef, tooltip, {\n *   placement: 'top',\n *   middleware: [inline({ x: cursorX, y: cursorY }), flip(), shift({ padding: 6 })],\n * });\n * ```\n */\nexport function inline(options: InlineOptions = {}): Middleware {\n  function inlineMiddleware(state: Parameters<Middleware>[0]): ReturnType<Middleware> {\n    const rects = getClientRects(state.elements.reference);\n\n    if (rects.length <= 1) return;\n\n    const padding = toSideObject(options.padding ?? 2);\n    const side = getSide(state.placement);\n    let nextRect = rects[0]!;\n\n    if (options.x != null && options.y != null) {\n      nextRect = rects.find((rect) => rectContainsPoint(rect, options.x!, options.y!, padding)) ?? nextRect;\n    } else if (side === 'top' || side === 'bottom') {\n      const targetX = state.x + state.rects.floating.width / 2;\n\n      nextRect = rects.reduce((best, rect) => {\n        const bestDist = Math.abs(best.x + best.width / 2 - targetX);\n        const rectDist = Math.abs(rect.x + rect.width / 2 - targetX);\n\n        return rectDist < bestDist ? rect : best;\n      }, nextRect);\n    } else {\n      const targetY = state.y + state.rects.floating.height / 2;\n\n      nextRect = rects.reduce((best, rect) => {\n        const bestDist = Math.abs(best.y + best.height / 2 - targetY);\n        const rectDist = Math.abs(rect.y + rect.height / 2 - targetY);\n\n        return rectDist < bestDist ? rect : best;\n      }, nextRect);\n    }\n\n    if (sameRect(nextRect, state.rects.reference)) return;\n\n    return { reset: { rects: { ...state.rects, reference: nextRect } } };\n  }\n\n  return tagMiddleware(inlineMiddleware, 'inline');\n}\n"],"mappings":"sFAMA,SAAS,EAAe,EAAqC,CAG3D,MAFI,EAAE,mBAAoB,IAAc,OAAO,EAAU,gBAAmB,WAAmB,CAAC,EAEzF,MAAM,KAAM,EAAU,eAAiD,CAAC,CAAC,CAC7E,IAAI,CAAM,CAAC,CACX,OAAQ,GAAM,EAAE,MAAQ,GAAK,EAAE,OAAS,CAAC,CAC9C,CAEA,SAAS,EAAkB,EAAY,EAAW,EAAW,EAAmD,CAC9G,OACE,GAAK,EAAK,EAAI,EAAQ,MACtB,GAAK,EAAK,EAAI,EAAK,MAAQ,EAAQ,OACnC,GAAK,EAAK,EAAI,EAAQ,KACtB,GAAK,EAAK,EAAI,EAAK,OAAS,EAAQ,MAExC,CAEA,SAAS,EAAS,EAAS,EAAkB,CAC3C,OAAO,EAAE,IAAM,EAAE,GAAK,EAAE,IAAM,EAAE,GAAK,EAAE,QAAU,EAAE,OAAS,EAAE,SAAW,EAAE,MAC7E,CAqCA,SAAgB,EAAO,EAAyB,CAAC,EAAe,CAC9D,SAAS,EAAiB,EAA0D,CAClF,IAAM,EAAQ,EAAe,EAAM,SAAS,SAAS,EAErD,GAAI,EAAM,QAAU,EAAG,OAEvB,IAAM,EAAU,EAAa,EAAQ,SAAW,CAAC,EAC3C,EAAO,EAAQ,EAAM,SAAS,EAChC,EAAW,EAAM,GAErB,GAAI,EAAQ,GAAK,MAAQ,EAAQ,GAAK,KACpC,EAAW,EAAM,KAAM,GAAS,EAAkB,EAAM,EAAQ,EAAI,EAAQ,EAAI,CAAO,CAAC,GAAK,OACxF,GAAI,IAAS,OAAS,IAAS,SAAU,CAC9C,IAAM,EAAU,EAAM,EAAI,EAAM,MAAM,SAAS,MAAQ,EAEvD,EAAW,EAAM,QAAQ,EAAM,IAAS,CACtC,IAAM,EAAW,KAAK,IAAI,EAAK,EAAI,EAAK,MAAQ,EAAI,CAAO,EAG3D,OAFiB,KAAK,IAAI,EAAK,EAAI,EAAK,MAAQ,EAAI,CAE7C,EAAW,EAAW,EAAO,CACtC,EAAG,CAAQ,CACb,KAAO,CACL,IAAM,EAAU,EAAM,EAAI,EAAM,MAAM,SAAS,OAAS,EAExD,EAAW,EAAM,QAAQ,EAAM,IAAS,CACtC,IAAM,EAAW,KAAK,IAAI,EAAK,EAAI,EAAK,OAAS,EAAI,CAAO,EAG5D,OAFiB,KAAK,IAAI,EAAK,EAAI,EAAK,OAAS,EAAI,CAE9C,EAAW,EAAW,EAAO,CACtC,EAAG,CAAQ,CACb,CAEI,MAAS,EAAU,EAAM,MAAM,SAAS,EAE5C,MAAO,CAAE,MAAO,CAAE,MAAO,CAAE,GAAG,EAAM,MAAO,UAAW,CAAS,CAAE,CAAE,CACrE,CAEA,OAAO,EAAc,EAAkB,QAAQ,CACjD"}

package/dist/middleware/arrow.cjs

@@ -0,0 +1,2 @@
+const e=require("../utils.cjs");let t=require("@vielzeug/arsenal");function n({element:n,padding:r=0}){function i(i){let a=e.getSide(i.placement),o=e.toSideObject(r),s=e.toRect(n.getBoundingClientRect());if(a===`top`||a===`bottom`){let e=i.rects.reference.x+i.rects.reference.width/2-i.x-s.width/2,n=o.left,r=(0,t.clamp)(e,n,Math.max(n,i.rects.floating.width-s.width-o.right));return{data:{arrow:{centerOffset:e-r,constrained:r!==e,x:r}}}}let c=i.rects.reference.y+i.rects.reference.height/2-i.y-s.height/2,l=o.top,u=(0,t.clamp)(c,l,Math.max(l,i.rects.floating.height-s.height-o.bottom));return{data:{arrow:{centerOffset:c-u,constrained:u!==c,y:u}}}}return e.tagMiddleware(i,`arrow`)}exports.arrow=n;
+//# sourceMappingURL=arrow.cjs.map

package/dist/middleware/arrow.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"arrow.cjs","names":[],"sources":["../../src/middleware/arrow.ts"],"sourcesContent":["import type { ArrowData, Middleware, Padding, TypedMiddleware } from '../types';\n\nimport { clamp, getSide, tagMiddleware, toRect, toSideObject } from '../utils';\n\nexport interface ArrowOptions {\n  /** The arrow DOM element. Must be a child of the floating element. */\n  element: HTMLElement;\n  /** Padding to keep the arrow from the floating element's corners. */\n  padding?: Padding;\n}\n\n/**\n * Positions an arrow element inside the floating element, pointed toward the reference.\n * Writes `{ x?, y?, centerOffset }` to `middlewareData.arrow`.\n *\n * Must come **after** flip(), shift(), and autoPlacement() in the middleware pipeline.\n *\n * @example\n * ```ts\n * const result = computePosition(ref, floating, {\n *   middleware: [offset(8), flip(), shift(), arrow({ element: arrowEl })],\n * });\n * const { x, y } = result.middlewareData.arrow!;\n * arrowEl.style.left = x != null ? `${x}px` : '';\n * arrowEl.style.top  = y != null ? `${y}px` : '';\n * ```\n */\nexport function arrow({ element, padding = 0 }: ArrowOptions): TypedMiddleware<'arrow', ArrowData> {\n  function arrowMiddleware(state: Parameters<Middleware>[0]): ReturnType<Middleware> {\n    const side = getSide(state.placement);\n    const inset = toSideObject(padding);\n    const arrowRect = toRect(element.getBoundingClientRect());\n\n    if (side === 'top' || side === 'bottom') {\n      const idealX = state.rects.reference.x + state.rects.reference.width / 2 - state.x - arrowRect.width / 2;\n      const minX = inset.left;\n      const maxX = Math.max(minX, state.rects.floating.width - arrowRect.width - inset.right);\n      const x = clamp(idealX, minX, maxX);\n\n      return { data: { arrow: { centerOffset: idealX - x, constrained: x !== idealX, x } } };\n    }\n\n    const idealY = state.rects.reference.y + state.rects.reference.height / 2 - state.y - arrowRect.height / 2;\n    const minY = inset.top;\n    const maxY = Math.max(minY, state.rects.floating.height - arrowRect.height - inset.bottom);\n    const y = clamp(idealY, minY, maxY);\n\n    return { data: { arrow: { centerOffset: idealY - y, constrained: y !== idealY, y } } };\n  }\n\n  return tagMiddleware<'arrow', ArrowData, typeof arrowMiddleware>(arrowMiddleware, 'arrow');\n}\n"],"mappings":"mEA2BA,SAAgB,EAAM,CAAE,UAAS,UAAU,GAAwD,CACjG,SAAS,EAAgB,EAA0D,CACjF,IAAM,EAAO,EAAA,QAAQ,EAAM,SAAS,EAC9B,EAAQ,EAAA,aAAa,CAAO,EAC5B,EAAY,EAAA,OAAO,EAAQ,sBAAsB,CAAC,EAExD,GAAI,IAAS,OAAS,IAAS,SAAU,CACvC,IAAM,EAAS,EAAM,MAAM,UAAU,EAAI,EAAM,MAAM,UAAU,MAAQ,EAAI,EAAM,EAAI,EAAU,MAAQ,EACjG,EAAO,EAAM,KAEb,GAAA,EAAA,EAAA,MAAA,CAAU,EAAQ,EADX,KAAK,IAAI,EAAM,EAAM,MAAM,SAAS,MAAQ,EAAU,MAAQ,EAAM,KACnD,CAAI,EAElC,MAAO,CAAE,KAAM,CAAE,MAAO,CAAE,aAAc,EAAS,EAAG,YAAa,IAAM,EAAQ,GAAE,CAAE,CAAE,CACvF,CAEA,IAAM,EAAS,EAAM,MAAM,UAAU,EAAI,EAAM,MAAM,UAAU,OAAS,EAAI,EAAM,EAAI,EAAU,OAAS,EACnG,EAAO,EAAM,IAEb,GAAA,EAAA,EAAA,MAAA,CAAU,EAAQ,EADX,KAAK,IAAI,EAAM,EAAM,MAAM,SAAS,OAAS,EAAU,OAAS,EAAM,MACrD,CAAI,EAElC,MAAO,CAAE,KAAM,CAAE,MAAO,CAAE,aAAc,EAAS,EAAG,YAAa,IAAM,EAAQ,GAAE,CAAE,CAAE,CACvF,CAEA,OAAO,EAAA,cAA0D,EAAiB,OAAO,CAC3F"}

package/dist/middleware/arrow.d.ts

@@ -0,0 +1,25 @@
+import type { ArrowData, Padding, TypedMiddleware } from '../types';
+export interface ArrowOptions {
+    /** The arrow DOM element. Must be a child of the floating element. */
+    element: HTMLElement;
+    /** Padding to keep the arrow from the floating element's corners. */
+    padding?: Padding;
+}
+/**
+ * Positions an arrow element inside the floating element, pointed toward the reference.
+ * Writes `{ x?, y?, centerOffset }` to `middlewareData.arrow`.
+ *
+ * Must come **after** flip(), shift(), and autoPlacement() in the middleware pipeline.
+ *
+ * @example
+ * ```ts
+ * const result = computePosition(ref, floating, {
+ *   middleware: [offset(8), flip(), shift(), arrow({ element: arrowEl })],
+ * });
+ * const { x, y } = result.middlewareData.arrow!;
+ * arrowEl.style.left = x != null ? `${x}px` : '';
+ * arrowEl.style.top  = y != null ? `${y}px` : '';
+ * ```
+ */
+export declare function arrow({ element, padding }: ArrowOptions): TypedMiddleware<'arrow', ArrowData>;
+//# sourceMappingURL=arrow.d.ts.map

package/dist/middleware/arrow.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"arrow.d.ts","sourceRoot":"","sources":["../../src/middleware/arrow.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAc,OAAO,EAAE,eAAe,EAAE,MAAM,UAAU,CAAC;AAIhF,MAAM,WAAW,YAAY;IAC3B,sEAAsE;IACtE,OAAO,EAAE,WAAW,CAAC;IACrB,qEAAqE;IACrE,OAAO,CAAC,EAAE,OAAO,CAAC;CACnB;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,KAAK,CAAC,EAAE,OAAO,EAAE,OAAW,EAAE,EAAE,YAAY,GAAG,eAAe,CAAC,OAAO,EAAE,SAAS,CAAC,CAwBjG"}

package/dist/middleware/arrow.js

@@ -0,0 +1,2 @@
+import{clamp as e,getSide as t,tagMiddleware as n,toRect as r,toSideObject as i}from"../utils.js";function a({element:a,padding:o=0}){function s(n){let s=t(n.placement),c=i(o),l=r(a.getBoundingClientRect());if(s===`top`||s===`bottom`){let t=n.rects.reference.x+n.rects.reference.width/2-n.x-l.width/2,r=c.left,i=e(t,r,Math.max(r,n.rects.floating.width-l.width-c.right));return{data:{arrow:{centerOffset:t-i,constrained:i!==t,x:i}}}}let u=n.rects.reference.y+n.rects.reference.height/2-n.y-l.height/2,d=c.top,f=e(u,d,Math.max(d,n.rects.floating.height-l.height-c.bottom));return{data:{arrow:{centerOffset:u-f,constrained:f!==u,y:f}}}}return n(s,`arrow`)}export{a as arrow};
+//# sourceMappingURL=arrow.js.map

package/dist/middleware/arrow.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"arrow.js","names":[],"sources":["../../src/middleware/arrow.ts"],"sourcesContent":["import type { ArrowData, Middleware, Padding, TypedMiddleware } from '../types';\n\nimport { clamp, getSide, tagMiddleware, toRect, toSideObject } from '../utils';\n\nexport interface ArrowOptions {\n  /** The arrow DOM element. Must be a child of the floating element. */\n  element: HTMLElement;\n  /** Padding to keep the arrow from the floating element's corners. */\n  padding?: Padding;\n}\n\n/**\n * Positions an arrow element inside the floating element, pointed toward the reference.\n * Writes `{ x?, y?, centerOffset }` to `middlewareData.arrow`.\n *\n * Must come **after** flip(), shift(), and autoPlacement() in the middleware pipeline.\n *\n * @example\n * ```ts\n * const result = computePosition(ref, floating, {\n *   middleware: [offset(8), flip(), shift(), arrow({ element: arrowEl })],\n * });\n * const { x, y } = result.middlewareData.arrow!;\n * arrowEl.style.left = x != null ? `${x}px` : '';\n * arrowEl.style.top  = y != null ? `${y}px` : '';\n * ```\n */\nexport function arrow({ element, padding = 0 }: ArrowOptions): TypedMiddleware<'arrow', ArrowData> {\n  function arrowMiddleware(state: Parameters<Middleware>[0]): ReturnType<Middleware> {\n    const side = getSide(state.placement);\n    const inset = toSideObject(padding);\n    const arrowRect = toRect(element.getBoundingClientRect());\n\n    if (side === 'top' || side === 'bottom') {\n      const idealX = state.rects.reference.x + state.rects.reference.width / 2 - state.x - arrowRect.width / 2;\n      const minX = inset.left;\n      const maxX = Math.max(minX, state.rects.floating.width - arrowRect.width - inset.right);\n      const x = clamp(idealX, minX, maxX);\n\n      return { data: { arrow: { centerOffset: idealX - x, constrained: x !== idealX, x } } };\n    }\n\n    const idealY = state.rects.reference.y + state.rects.reference.height / 2 - state.y - arrowRect.height / 2;\n    const minY = inset.top;\n    const maxY = Math.max(minY, state.rects.floating.height - arrowRect.height - inset.bottom);\n    const y = clamp(idealY, minY, maxY);\n\n    return { data: { arrow: { centerOffset: idealY - y, constrained: y !== idealY, y } } };\n  }\n\n  return tagMiddleware<'arrow', ArrowData, typeof arrowMiddleware>(arrowMiddleware, 'arrow');\n}\n"],"mappings":"kGA2BA,SAAgB,EAAM,CAAE,UAAS,UAAU,GAAwD,CACjG,SAAS,EAAgB,EAA0D,CACjF,IAAM,EAAO,EAAQ,EAAM,SAAS,EAC9B,EAAQ,EAAa,CAAO,EAC5B,EAAY,EAAO,EAAQ,sBAAsB,CAAC,EAExD,GAAI,IAAS,OAAS,IAAS,SAAU,CACvC,IAAM,EAAS,EAAM,MAAM,UAAU,EAAI,EAAM,MAAM,UAAU,MAAQ,EAAI,EAAM,EAAI,EAAU,MAAQ,EACjG,EAAO,EAAM,KAEb,EAAI,EAAM,EAAQ,EADX,KAAK,IAAI,EAAM,EAAM,MAAM,SAAS,MAAQ,EAAU,MAAQ,EAAM,KACnD,CAAI,EAElC,MAAO,CAAE,KAAM,CAAE,MAAO,CAAE,aAAc,EAAS,EAAG,YAAa,IAAM,EAAQ,GAAE,CAAE,CAAE,CACvF,CAEA,IAAM,EAAS,EAAM,MAAM,UAAU,EAAI,EAAM,MAAM,UAAU,OAAS,EAAI,EAAM,EAAI,EAAU,OAAS,EACnG,EAAO,EAAM,IAEb,EAAI,EAAM,EAAQ,EADX,KAAK,IAAI,EAAM,EAAM,MAAM,SAAS,OAAS,EAAU,OAAS,EAAM,MACrD,CAAI,EAElC,MAAO,CAAE,KAAM,CAAE,MAAO,CAAE,aAAc,EAAS,EAAG,YAAa,IAAM,EAAQ,GAAE,CAAE,CAAE,CACvF,CAEA,OAAO,EAA0D,EAAiB,OAAO,CAC3F"}

package/dist/middleware/auto-placement.cjs

@@ -0,0 +1,2 @@
+const e=require("../utils.cjs"),t=require("../_dev.cjs"),n=require("../overflow.cjs");var r=[`top`,`right`,`bottom`,`left`];function i(e){return e===void 0?r:e===null?r.flatMap(e=>[e,`${e}-start`,`${e}-end`]):r.map(t=>`${t}-${e}`)}function a(r={}){return e.tagMiddleware(function(e){let{boundary:a,padding:o}=n.resolveBoundary(r,e),s=r.allowedPlacements??i(r.alignment);s.length===0&&t.warn(`autoPlacement: allowedPlacements is empty — no placement will be evaluated.`);let c=e.placement,l=1/0,u=-1/0;for(let t of s){let i=n.totalOverflow(n.getPlacementOverflow(e,t,r)),s=n.getAvailableSpace(e,t,a,o);(i<l||i===l&&s>u)&&(c=t,l=i,u=s)}if(c!==e.placement)return{reset:{placement:c}}},`autoPlacement`)}exports.autoPlacement=a;
+//# sourceMappingURL=auto-placement.cjs.map

package/dist/middleware/auto-placement.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"auto-placement.cjs","names":[],"sources":["../../src/middleware/auto-placement.ts"],"sourcesContent":["import type { Alignment, DetectOverflowOptions, Middleware, Placement, Side } from '../types';\n\nimport { warn } from '../_dev';\nimport { getAvailableSpace, getPlacementOverflow, resolveBoundary, totalOverflow } from '../overflow';\nimport { tagMiddleware } from '../utils';\n\nexport interface AutoPlacementOptions extends DetectOverflowOptions {\n  /**\n   * Placements to evaluate. When provided, takes precedence over `alignment`.\n   * Note: use either `flip` or `autoPlacement`, not both.\n   */\n  allowedPlacements?: Placement[];\n  /**\n   * Constrains auto-placement to variants with the given alignment.\n   *\n   * - `'start'` — evaluates only `top-start`, `right-start`, `bottom-start`, `left-start`.\n   * - `'end'` — evaluates only `top-end`, `right-end`, `bottom-end`, `left-end`.\n   * - `null` — evaluates all 12 variants (4 cardinal + 4 start + 4 end).\n   * - omitted (default) — evaluates the 4 cardinal sides only.\n   */\n  alignment?: Alignment | null;\n}\n\nconst SIDES: Side[] = ['top', 'right', 'bottom', 'left'];\n\nfunction getDefaultPlacements(alignment?: Alignment | null): Placement[] {\n  if (alignment === undefined) return SIDES;\n\n  if (alignment === null) {\n    return SIDES.flatMap((side) => [side, `${side}-start`, `${side}-end`] as Placement[]);\n  }\n\n  return SIDES.map((side) => `${side}-${alignment}` as Placement);\n}\n\n/**\n * Automatically selects the placement with the most available space and least overflow.\n * Evaluates all allowed placements and picks the optimal one.\n *\n * Use the `alignment` option to restrict evaluation to aligned variants (e.g. `'start'`)\n * when you want to preserve a consistent alignment across all candidate sides.\n *\n * @see {@link flip} for simple opposite-side flipping.\n */\nexport function autoPlacement(options: AutoPlacementOptions = {}): Middleware {\n  return tagMiddleware(function autoPlacementMiddleware(state: Parameters<Middleware>[0]): ReturnType<Middleware> {\n    const { boundary, padding } = resolveBoundary(options, state);\n    const placements = options.allowedPlacements ?? getDefaultPlacements(options.alignment);\n\n    if (placements.length === 0) {\n      warn('autoPlacement: allowedPlacements is empty — no placement will be evaluated.');\n    }\n\n    let bestPlacement = state.placement;\n    let bestOverflow = Number.POSITIVE_INFINITY;\n    let bestSpace = Number.NEGATIVE_INFINITY;\n\n    for (const candidate of placements) {\n      const overflow = getPlacementOverflow(state, candidate, options);\n      const overflowScore = totalOverflow(overflow);\n      const availableSpace = getAvailableSpace(state, candidate, boundary, padding);\n\n      if (overflowScore < bestOverflow || (overflowScore === bestOverflow && availableSpace > bestSpace)) {\n        bestPlacement = candidate;\n        bestOverflow = overflowScore;\n        bestSpace = availableSpace;\n      }\n    }\n\n    if (bestPlacement !== state.placement) {\n      return { reset: { placement: bestPlacement } };\n    }\n  }, 'autoPlacement');\n}\n"],"mappings":"sFAuBA,IAAM,EAAgB,CAAC,MAAO,QAAS,SAAU,MAAM,EAEvD,SAAS,EAAqB,EAA2C,CAOvE,OANI,IAAc,IAAA,GAAkB,EAEhC,IAAc,KACT,EAAM,QAAS,GAAS,CAAC,EAAM,GAAG,EAAK,QAAS,GAAG,EAAK,KAAK,CAAgB,EAG/E,EAAM,IAAK,GAAS,GAAG,EAAK,GAAG,GAAwB,CAChE,CAWA,SAAgB,EAAc,EAAgC,CAAC,EAAe,CAC5E,OAAO,EAAA,cAAc,SAAiC,EAA0D,CAC9G,GAAM,CAAE,WAAU,WAAY,EAAA,gBAAgB,EAAS,CAAK,EACtD,EAAa,EAAQ,mBAAqB,EAAqB,EAAQ,SAAS,EAElF,EAAW,SAAW,GACxB,EAAA,KAAK,6EAA6E,EAGpF,IAAI,EAAgB,EAAM,UACtB,EAAe,IACf,EAAY,KAEhB,IAAK,IAAM,KAAa,EAAY,CAElC,IAAM,EAAgB,EAAA,cADL,EAAA,qBAAqB,EAAO,EAAW,CACpB,CAAQ,EACtC,EAAiB,EAAA,kBAAkB,EAAO,EAAW,EAAU,CAAO,GAExE,EAAgB,GAAiB,IAAkB,GAAgB,EAAiB,KACtF,EAAgB,EAChB,EAAe,EACf,EAAY,EAEhB,CAEA,GAAI,IAAkB,EAAM,UAC1B,MAAO,CAAE,MAAO,CAAE,UAAW,CAAc,CAAE,CAEjD,EAAG,eAAe,CACpB"}

package/dist/middleware/auto-placement.d.ts

@@ -0,0 +1,28 @@
+import type { Alignment, DetectOverflowOptions, Middleware, Placement } from '../types';
+export interface AutoPlacementOptions extends DetectOverflowOptions {
+    /**
+     * Placements to evaluate. When provided, takes precedence over `alignment`.
+     * Note: use either `flip` or `autoPlacement`, not both.
+     */
+    allowedPlacements?: Placement[];
+    /**
+     * Constrains auto-placement to variants with the given alignment.
+     *
+     * - `'start'` — evaluates only `top-start`, `right-start`, `bottom-start`, `left-start`.
+     * - `'end'` — evaluates only `top-end`, `right-end`, `bottom-end`, `left-end`.
+     * - `null` — evaluates all 12 variants (4 cardinal + 4 start + 4 end).
+     * - omitted (default) — evaluates the 4 cardinal sides only.
+     */
+    alignment?: Alignment | null;
+}
+/**
+ * Automatically selects the placement with the most available space and least overflow.
+ * Evaluates all allowed placements and picks the optimal one.
+ *
+ * Use the `alignment` option to restrict evaluation to aligned variants (e.g. `'start'`)
+ * when you want to preserve a consistent alignment across all candidate sides.
+ *
+ * @see {@link flip} for simple opposite-side flipping.
+ */
+export declare function autoPlacement(options?: AutoPlacementOptions): Middleware;
+//# sourceMappingURL=auto-placement.d.ts.map

package/dist/middleware/auto-placement.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"auto-placement.d.ts","sourceRoot":"","sources":["../../src/middleware/auto-placement.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,qBAAqB,EAAE,UAAU,EAAE,SAAS,EAAQ,MAAM,UAAU,CAAC;AAM9F,MAAM,WAAW,oBAAqB,SAAQ,qBAAqB;IACjE;;;OAGG;IACH,iBAAiB,CAAC,EAAE,SAAS,EAAE,CAAC;IAChC;;;;;;;OAOG;IACH,SAAS,CAAC,EAAE,SAAS,GAAG,IAAI,CAAC;CAC9B;AAcD;;;;;;;;GAQG;AACH,wBAAgB,aAAa,CAAC,OAAO,GAAE,oBAAyB,GAAG,UAAU,CA6B5E"}

package/dist/middleware/auto-placement.js

@@ -0,0 +1,2 @@
+import{tagMiddleware as e}from"../utils.js";import{warn as t}from"../_dev.js";import{getAvailableSpace as n,getPlacementOverflow as r,resolveBoundary as i,totalOverflow as a}from"../overflow.js";var o=[`top`,`right`,`bottom`,`left`];function s(e){return e===void 0?o:e===null?o.flatMap(e=>[e,`${e}-start`,`${e}-end`]):o.map(t=>`${t}-${e}`)}function c(o={}){return e(function(e){let{boundary:c,padding:l}=i(o,e),u=o.allowedPlacements??s(o.alignment);u.length===0&&t(`autoPlacement: allowedPlacements is empty — no placement will be evaluated.`);let d=e.placement,f=1/0,p=-1/0;for(let t of u){let i=a(r(e,t,o)),s=n(e,t,c,l);(i<f||i===f&&s>p)&&(d=t,f=i,p=s)}if(d!==e.placement)return{reset:{placement:d}}},`autoPlacement`)}export{c as autoPlacement};
+//# sourceMappingURL=auto-placement.js.map

package/dist/middleware/auto-placement.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"auto-placement.js","names":[],"sources":["../../src/middleware/auto-placement.ts"],"sourcesContent":["import type { Alignment, DetectOverflowOptions, Middleware, Placement, Side } from '../types';\n\nimport { warn } from '../_dev';\nimport { getAvailableSpace, getPlacementOverflow, resolveBoundary, totalOverflow } from '../overflow';\nimport { tagMiddleware } from '../utils';\n\nexport interface AutoPlacementOptions extends DetectOverflowOptions {\n  /**\n   * Placements to evaluate. When provided, takes precedence over `alignment`.\n   * Note: use either `flip` or `autoPlacement`, not both.\n   */\n  allowedPlacements?: Placement[];\n  /**\n   * Constrains auto-placement to variants with the given alignment.\n   *\n   * - `'start'` — evaluates only `top-start`, `right-start`, `bottom-start`, `left-start`.\n   * - `'end'` — evaluates only `top-end`, `right-end`, `bottom-end`, `left-end`.\n   * - `null` — evaluates all 12 variants (4 cardinal + 4 start + 4 end).\n   * - omitted (default) — evaluates the 4 cardinal sides only.\n   */\n  alignment?: Alignment | null;\n}\n\nconst SIDES: Side[] = ['top', 'right', 'bottom', 'left'];\n\nfunction getDefaultPlacements(alignment?: Alignment | null): Placement[] {\n  if (alignment === undefined) return SIDES;\n\n  if (alignment === null) {\n    return SIDES.flatMap((side) => [side, `${side}-start`, `${side}-end`] as Placement[]);\n  }\n\n  return SIDES.map((side) => `${side}-${alignment}` as Placement);\n}\n\n/**\n * Automatically selects the placement with the most available space and least overflow.\n * Evaluates all allowed placements and picks the optimal one.\n *\n * Use the `alignment` option to restrict evaluation to aligned variants (e.g. `'start'`)\n * when you want to preserve a consistent alignment across all candidate sides.\n *\n * @see {@link flip} for simple opposite-side flipping.\n */\nexport function autoPlacement(options: AutoPlacementOptions = {}): Middleware {\n  return tagMiddleware(function autoPlacementMiddleware(state: Parameters<Middleware>[0]): ReturnType<Middleware> {\n    const { boundary, padding } = resolveBoundary(options, state);\n    const placements = options.allowedPlacements ?? getDefaultPlacements(options.alignment);\n\n    if (placements.length === 0) {\n      warn('autoPlacement: allowedPlacements is empty — no placement will be evaluated.');\n    }\n\n    let bestPlacement = state.placement;\n    let bestOverflow = Number.POSITIVE_INFINITY;\n    let bestSpace = Number.NEGATIVE_INFINITY;\n\n    for (const candidate of placements) {\n      const overflow = getPlacementOverflow(state, candidate, options);\n      const overflowScore = totalOverflow(overflow);\n      const availableSpace = getAvailableSpace(state, candidate, boundary, padding);\n\n      if (overflowScore < bestOverflow || (overflowScore === bestOverflow && availableSpace > bestSpace)) {\n        bestPlacement = candidate;\n        bestOverflow = overflowScore;\n        bestSpace = availableSpace;\n      }\n    }\n\n    if (bestPlacement !== state.placement) {\n      return { reset: { placement: bestPlacement } };\n    }\n  }, 'autoPlacement');\n}\n"],"mappings":"mMAuBA,IAAM,EAAgB,CAAC,MAAO,QAAS,SAAU,MAAM,EAEvD,SAAS,EAAqB,EAA2C,CAOvE,OANI,IAAc,IAAA,GAAkB,EAEhC,IAAc,KACT,EAAM,QAAS,GAAS,CAAC,EAAM,GAAG,EAAK,QAAS,GAAG,EAAK,KAAK,CAAgB,EAG/E,EAAM,IAAK,GAAS,GAAG,EAAK,GAAG,GAAwB,CAChE,CAWA,SAAgB,EAAc,EAAgC,CAAC,EAAe,CAC5E,OAAO,EAAc,SAAiC,EAA0D,CAC9G,GAAM,CAAE,WAAU,WAAY,EAAgB,EAAS,CAAK,EACtD,EAAa,EAAQ,mBAAqB,EAAqB,EAAQ,SAAS,EAElF,EAAW,SAAW,GACxB,EAAK,6EAA6E,EAGpF,IAAI,EAAgB,EAAM,UACtB,EAAe,IACf,EAAY,KAEhB,IAAK,IAAM,KAAa,EAAY,CAElC,IAAM,EAAgB,EADL,EAAqB,EAAO,EAAW,CACpB,CAAQ,EACtC,EAAiB,EAAkB,EAAO,EAAW,EAAU,CAAO,GAExE,EAAgB,GAAiB,IAAkB,GAAgB,EAAiB,KACtF,EAAgB,EAChB,EAAe,EACf,EAAY,EAEhB,CAEA,GAAI,IAAkB,EAAM,UAC1B,MAAO,CAAE,MAAO,CAAE,UAAW,CAAc,CAAE,CAEjD,EAAG,eAAe,CACpB"}

package/dist/middleware/flip.cjs

@@ -0,0 +1,2 @@
+const e=require("../utils.cjs"),t=require("../overflow.cjs");function n(n={}){function r(r){let i=t.detectOverflow(r,n);if(!t.hasOverflow(i))return;let a=e.getSide(r.placement),o=e.getAlignment(r.placement),s=n.fallbackPlacements??[e.withPlacement(e.OPPOSITE[a],o)],c=[r.placement],l=r.placement,u=t.totalOverflow(i);for(let e of s){let i=t.getPlacementOverflow(r,e,n),a=t.totalOverflow(i);if(!t.hasOverflow(i))return{data:{flip:{skippedPlacements:c}},reset:{placement:e}};c.push(e),a<u&&(l=e,u=a)}if(l!==r.placement)return{data:{flip:{skippedPlacements:c}},reset:{placement:l}}}return e.tagMiddleware(r,`flip`)}exports.flip=n;
+//# sourceMappingURL=flip.cjs.map

package/dist/middleware/flip.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"flip.cjs","names":[],"sources":["../../src/middleware/flip.ts"],"sourcesContent":["import type { DetectOverflowOptions, FlipData, Middleware, Placement, TypedMiddleware } from '../types';\n\nimport { detectOverflow, getPlacementOverflow, hasOverflow, totalOverflow } from '../overflow';\nimport { getAlignment, getSide, OPPOSITE, tagMiddleware, withPlacement } from '../utils';\n\nexport interface FlipOptions extends DetectOverflowOptions {\n  /**\n   * Ordered list of candidate placements to try when the floating element overflows.\n   * Defaults to the opposite side, preserving the current alignment.\n   */\n  fallbackPlacements?: Placement[];\n}\n\n/**\n * Flips the floating element to the opposite side when it overflows the boundary.\n * Falls back to the candidate with the least total overflow when no candidate fits.\n */\nexport function flip(options: FlipOptions = {}): TypedMiddleware<'flip', FlipData> {\n  function flipMiddleware(state: Parameters<Middleware>[0]): ReturnType<Middleware> {\n    const currentOverflow = detectOverflow(state, options);\n\n    if (!hasOverflow(currentOverflow)) return;\n\n    const side = getSide(state.placement);\n    const align = getAlignment(state.placement);\n    const fallbackPlacements = options.fallbackPlacements ?? [withPlacement(OPPOSITE[side], align)];\n    const skipped: Placement[] = [state.placement];\n    let bestPlacement = state.placement;\n    let bestScore = totalOverflow(currentOverflow);\n\n    for (const candidate of fallbackPlacements) {\n      const candidateOverflow = getPlacementOverflow(state, candidate, options);\n      const score = totalOverflow(candidateOverflow);\n\n      if (!hasOverflow(candidateOverflow)) {\n        return {\n          data: { flip: { skippedPlacements: skipped } },\n          reset: { placement: candidate },\n        };\n      }\n\n      skipped.push(candidate);\n\n      if (score < bestScore) {\n        bestPlacement = candidate;\n        bestScore = score;\n      }\n    }\n\n    if (bestPlacement !== state.placement) {\n      return {\n        data: { flip: { skippedPlacements: skipped } },\n        reset: { placement: bestPlacement },\n      };\n    }\n  }\n\n  return tagMiddleware<'flip', FlipData, typeof flipMiddleware>(flipMiddleware, 'flip');\n}\n"],"mappings":"6DAiBA,SAAgB,EAAK,EAAuB,CAAC,EAAsC,CACjF,SAAS,EAAe,EAA0D,CAChF,IAAM,EAAkB,EAAA,eAAe,EAAO,CAAO,EAErD,GAAI,CAAC,EAAA,YAAY,CAAe,EAAG,OAEnC,IAAM,EAAO,EAAA,QAAQ,EAAM,SAAS,EAC9B,EAAQ,EAAA,aAAa,EAAM,SAAS,EACpC,EAAqB,EAAQ,oBAAsB,CAAC,EAAA,cAAc,EAAA,SAAS,GAAO,CAAK,CAAC,EACxF,EAAuB,CAAC,EAAM,SAAS,EACzC,EAAgB,EAAM,UACtB,EAAY,EAAA,cAAc,CAAe,EAE7C,IAAK,IAAM,KAAa,EAAoB,CAC1C,IAAM,EAAoB,EAAA,qBAAqB,EAAO,EAAW,CAAO,EAClE,EAAQ,EAAA,cAAc,CAAiB,EAE7C,GAAI,CAAC,EAAA,YAAY,CAAiB,EAChC,MAAO,CACL,KAAM,CAAE,KAAM,CAAE,kBAAmB,CAAQ,CAAE,EAC7C,MAAO,CAAE,UAAW,CAAU,CAChC,EAGF,EAAQ,KAAK,CAAS,EAElB,EAAQ,IACV,EAAgB,EAChB,EAAY,EAEhB,CAEA,GAAI,IAAkB,EAAM,UAC1B,MAAO,CACL,KAAM,CAAE,KAAM,CAAE,kBAAmB,CAAQ,CAAE,EAC7C,MAAO,CAAE,UAAW,CAAc,CACpC,CAEJ,CAEA,OAAO,EAAA,cAAuD,EAAgB,MAAM,CACtF"}

package/dist/middleware/flip.d.ts

@@ -0,0 +1,14 @@
+import type { DetectOverflowOptions, FlipData, Placement, TypedMiddleware } from '../types';
+export interface FlipOptions extends DetectOverflowOptions {
+    /**
+     * Ordered list of candidate placements to try when the floating element overflows.
+     * Defaults to the opposite side, preserving the current alignment.
+     */
+    fallbackPlacements?: Placement[];
+}
+/**
+ * Flips the floating element to the opposite side when it overflows the boundary.
+ * Falls back to the candidate with the least total overflow when no candidate fits.
+ */
+export declare function flip(options?: FlipOptions): TypedMiddleware<'flip', FlipData>;
+//# sourceMappingURL=flip.d.ts.map

package/dist/middleware/flip.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"flip.d.ts","sourceRoot":"","sources":["../../src/middleware/flip.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,qBAAqB,EAAE,QAAQ,EAAc,SAAS,EAAE,eAAe,EAAE,MAAM,UAAU,CAAC;AAKxG,MAAM,WAAW,WAAY,SAAQ,qBAAqB;IACxD;;;OAGG;IACH,kBAAkB,CAAC,EAAE,SAAS,EAAE,CAAC;CAClC;AAED;;;GAGG;AACH,wBAAgB,IAAI,CAAC,OAAO,GAAE,WAAgB,GAAG,eAAe,CAAC,MAAM,EAAE,QAAQ,CAAC,CAyCjF"}

package/dist/middleware/flip.js

@@ -0,0 +1,2 @@
+import{OPPOSITE as e,getAlignment as t,getSide as n,tagMiddleware as r,withPlacement as i}from"../utils.js";import{detectOverflow as a,getPlacementOverflow as o,hasOverflow as s,totalOverflow as c}from"../overflow.js";function l(l={}){function u(r){let u=a(r,l);if(!s(u))return;let d=n(r.placement),f=t(r.placement),p=l.fallbackPlacements??[i(e[d],f)],m=[r.placement],h=r.placement,g=c(u);for(let e of p){let t=o(r,e,l),n=c(t);if(!s(t))return{data:{flip:{skippedPlacements:m}},reset:{placement:e}};m.push(e),n<g&&(h=e,g=n)}if(h!==r.placement)return{data:{flip:{skippedPlacements:m}},reset:{placement:h}}}return r(u,`flip`)}export{l as flip};
+//# sourceMappingURL=flip.js.map

package/dist/middleware/flip.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"flip.js","names":[],"sources":["../../src/middleware/flip.ts"],"sourcesContent":["import type { DetectOverflowOptions, FlipData, Middleware, Placement, TypedMiddleware } from '../types';\n\nimport { detectOverflow, getPlacementOverflow, hasOverflow, totalOverflow } from '../overflow';\nimport { getAlignment, getSide, OPPOSITE, tagMiddleware, withPlacement } from '../utils';\n\nexport interface FlipOptions extends DetectOverflowOptions {\n  /**\n   * Ordered list of candidate placements to try when the floating element overflows.\n   * Defaults to the opposite side, preserving the current alignment.\n   */\n  fallbackPlacements?: Placement[];\n}\n\n/**\n * Flips the floating element to the opposite side when it overflows the boundary.\n * Falls back to the candidate with the least total overflow when no candidate fits.\n */\nexport function flip(options: FlipOptions = {}): TypedMiddleware<'flip', FlipData> {\n  function flipMiddleware(state: Parameters<Middleware>[0]): ReturnType<Middleware> {\n    const currentOverflow = detectOverflow(state, options);\n\n    if (!hasOverflow(currentOverflow)) return;\n\n    const side = getSide(state.placement);\n    const align = getAlignment(state.placement);\n    const fallbackPlacements = options.fallbackPlacements ?? [withPlacement(OPPOSITE[side], align)];\n    const skipped: Placement[] = [state.placement];\n    let bestPlacement = state.placement;\n    let bestScore = totalOverflow(currentOverflow);\n\n    for (const candidate of fallbackPlacements) {\n      const candidateOverflow = getPlacementOverflow(state, candidate, options);\n      const score = totalOverflow(candidateOverflow);\n\n      if (!hasOverflow(candidateOverflow)) {\n        return {\n          data: { flip: { skippedPlacements: skipped } },\n          reset: { placement: candidate },\n        };\n      }\n\n      skipped.push(candidate);\n\n      if (score < bestScore) {\n        bestPlacement = candidate;\n        bestScore = score;\n      }\n    }\n\n    if (bestPlacement !== state.placement) {\n      return {\n        data: { flip: { skippedPlacements: skipped } },\n        reset: { placement: bestPlacement },\n      };\n    }\n  }\n\n  return tagMiddleware<'flip', FlipData, typeof flipMiddleware>(flipMiddleware, 'flip');\n}\n"],"mappings":"0NAiBA,SAAgB,EAAK,EAAuB,CAAC,EAAsC,CACjF,SAAS,EAAe,EAA0D,CAChF,IAAM,EAAkB,EAAe,EAAO,CAAO,EAErD,GAAI,CAAC,EAAY,CAAe,EAAG,OAEnC,IAAM,EAAO,EAAQ,EAAM,SAAS,EAC9B,EAAQ,EAAa,EAAM,SAAS,EACpC,EAAqB,EAAQ,oBAAsB,CAAC,EAAc,EAAS,GAAO,CAAK,CAAC,EACxF,EAAuB,CAAC,EAAM,SAAS,EACzC,EAAgB,EAAM,UACtB,EAAY,EAAc,CAAe,EAE7C,IAAK,IAAM,KAAa,EAAoB,CAC1C,IAAM,EAAoB,EAAqB,EAAO,EAAW,CAAO,EAClE,EAAQ,EAAc,CAAiB,EAE7C,GAAI,CAAC,EAAY,CAAiB,EAChC,MAAO,CACL,KAAM,CAAE,KAAM,CAAE,kBAAmB,CAAQ,CAAE,EAC7C,MAAO,CAAE,UAAW,CAAU,CAChC,EAGF,EAAQ,KAAK,CAAS,EAElB,EAAQ,IACV,EAAgB,EAChB,EAAY,EAEhB,CAEA,GAAI,IAAkB,EAAM,UAC1B,MAAO,CACL,KAAM,CAAE,KAAM,CAAE,kBAAmB,CAAQ,CAAE,EAC7C,MAAO,CAAE,UAAW,CAAc,CACpC,CAEJ,CAEA,OAAO,EAAuD,EAAgB,MAAM,CACtF"}

package/dist/middleware/hide.cjs

@@ -0,0 +1,2 @@
+const e=require("../utils.cjs"),t=require("../overflow.cjs");function n(n={}){let r=n.strategy??`both`;function i(e){let{boundary:i,padding:a}=t.resolveBoundary(n,e),o={};if(r===`escaped`||r===`both`){let n=t.getFloatingRect(e),r=t.detectOverflowAtRect(n,i,a);o.escaped=t.isFullyClipped(n,r),o.escapedOffsets=r}if(r===`referenceHidden`||r===`both`){let n=t.detectOverflowAtRect(e.rects.reference,i,a);o.referenceHidden=t.isFullyClipped(e.rects.reference,n),o.referenceHiddenOffsets=n}return{data:{hide:o}}}return e.tagMiddleware(i,`hide`)}exports.hide=n;
+//# sourceMappingURL=hide.cjs.map

package/dist/middleware/hide.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"hide.cjs","names":[],"sources":["../../src/middleware/hide.ts"],"sourcesContent":["import type { DetectOverflowOptions, HideData, Middleware, TypedMiddleware } from '../types';\n\nimport { detectOverflowAtRect, getFloatingRect, isFullyClipped, resolveBoundary } from '../overflow';\nimport { tagMiddleware } from '../utils';\n\nexport interface HideOptions extends DetectOverflowOptions {\n  /**\n   * Which hidden states to compute.\n   * - `'referenceHidden'` — whether the reference itself is off-screen.\n   * - `'escaped'` — whether the floating element has fully exited the boundary.\n   * - `'both'` (default) — both of the above.\n   */\n  strategy?: 'referenceHidden' | 'escaped' | 'both';\n}\n\n/**\n * Detects when the reference or floating element is hidden outside the boundary.\n * Writes `{ referenceHidden, referenceHiddenOffsets, escaped, escapedOffsets }` to\n * `middlewareData.hide`.\n */\nexport function hide(options: HideOptions = {}): TypedMiddleware<'hide', HideData> {\n  const strategy = options.strategy ?? 'both';\n\n  function hideMiddleware(state: Parameters<Middleware>[0]): ReturnType<Middleware> {\n    const { boundary, padding } = resolveBoundary(options, state);\n    const next: HideData = {};\n\n    if (strategy === 'escaped' || strategy === 'both') {\n      const floatingRect = getFloatingRect(state);\n      const escapedOffsets = detectOverflowAtRect(floatingRect, boundary, padding);\n\n      next.escaped = isFullyClipped(floatingRect, escapedOffsets);\n      next.escapedOffsets = escapedOffsets;\n    }\n\n    if (strategy === 'referenceHidden' || strategy === 'both') {\n      const referenceHiddenOffsets = detectOverflowAtRect(state.rects.reference, boundary, padding);\n\n      next.referenceHidden = isFullyClipped(state.rects.reference, referenceHiddenOffsets);\n      next.referenceHiddenOffsets = referenceHiddenOffsets;\n    }\n\n    return { data: { hide: next } };\n  }\n\n  return tagMiddleware<'hide', HideData, typeof hideMiddleware>(hideMiddleware, 'hide');\n}\n"],"mappings":"6DAoBA,SAAgB,EAAK,EAAuB,CAAC,EAAsC,CACjF,IAAM,EAAW,EAAQ,UAAY,OAErC,SAAS,EAAe,EAA0D,CAChF,GAAM,CAAE,WAAU,WAAY,EAAA,gBAAgB,EAAS,CAAK,EACtD,EAAiB,CAAC,EAExB,GAAI,IAAa,WAAa,IAAa,OAAQ,CACjD,IAAM,EAAe,EAAA,gBAAgB,CAAK,EACpC,EAAiB,EAAA,qBAAqB,EAAc,EAAU,CAAO,EAE3E,EAAK,QAAU,EAAA,eAAe,EAAc,CAAc,EAC1D,EAAK,eAAiB,CACxB,CAEA,GAAI,IAAa,mBAAqB,IAAa,OAAQ,CACzD,IAAM,EAAyB,EAAA,qBAAqB,EAAM,MAAM,UAAW,EAAU,CAAO,EAE5F,EAAK,gBAAkB,EAAA,eAAe,EAAM,MAAM,UAAW,CAAsB,EACnF,EAAK,uBAAyB,CAChC,CAEA,MAAO,CAAE,KAAM,CAAE,KAAM,CAAK,CAAE,CAChC,CAEA,OAAO,EAAA,cAAuD,EAAgB,MAAM,CACtF"}

package/dist/middleware/hide.d.ts

@@ -0,0 +1,17 @@
+import type { DetectOverflowOptions, HideData, TypedMiddleware } from '../types';
+export interface HideOptions extends DetectOverflowOptions {
+    /**
+     * Which hidden states to compute.
+     * - `'referenceHidden'` — whether the reference itself is off-screen.
+     * - `'escaped'` — whether the floating element has fully exited the boundary.
+     * - `'both'` (default) — both of the above.
+     */
+    strategy?: 'referenceHidden' | 'escaped' | 'both';
+}
+/**
+ * Detects when the reference or floating element is hidden outside the boundary.
+ * Writes `{ referenceHidden, referenceHiddenOffsets, escaped, escapedOffsets }` to
+ * `middlewareData.hide`.
+ */
+export declare function hide(options?: HideOptions): TypedMiddleware<'hide', HideData>;
+//# sourceMappingURL=hide.d.ts.map

package/dist/middleware/hide.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hide.d.ts","sourceRoot":"","sources":["../../src/middleware/hide.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,qBAAqB,EAAE,QAAQ,EAAc,eAAe,EAAE,MAAM,UAAU,CAAC;AAK7F,MAAM,WAAW,WAAY,SAAQ,qBAAqB;IACxD;;;;;OAKG;IACH,QAAQ,CAAC,EAAE,iBAAiB,GAAG,SAAS,GAAG,MAAM,CAAC;CACnD;AAED;;;;GAIG;AACH,wBAAgB,IAAI,CAAC,OAAO,GAAE,WAAgB,GAAG,eAAe,CAAC,MAAM,EAAE,QAAQ,CAAC,CA0BjF"}

package/dist/middleware/hide.js

@@ -0,0 +1,2 @@
+import{tagMiddleware as e}from"../utils.js";import{detectOverflowAtRect as t,getFloatingRect as n,isFullyClipped as r,resolveBoundary as i}from"../overflow.js";function a(a={}){let o=a.strategy??`both`;function s(e){let{boundary:s,padding:c}=i(a,e),l={};if(o===`escaped`||o===`both`){let i=n(e),a=t(i,s,c);l.escaped=r(i,a),l.escapedOffsets=a}if(o===`referenceHidden`||o===`both`){let n=t(e.rects.reference,s,c);l.referenceHidden=r(e.rects.reference,n),l.referenceHiddenOffsets=n}return{data:{hide:l}}}return e(s,`hide`)}export{a as hide};
+//# sourceMappingURL=hide.js.map

package/dist/middleware/hide.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"hide.js","names":[],"sources":["../../src/middleware/hide.ts"],"sourcesContent":["import type { DetectOverflowOptions, HideData, Middleware, TypedMiddleware } from '../types';\n\nimport { detectOverflowAtRect, getFloatingRect, isFullyClipped, resolveBoundary } from '../overflow';\nimport { tagMiddleware } from '../utils';\n\nexport interface HideOptions extends DetectOverflowOptions {\n  /**\n   * Which hidden states to compute.\n   * - `'referenceHidden'` — whether the reference itself is off-screen.\n   * - `'escaped'` — whether the floating element has fully exited the boundary.\n   * - `'both'` (default) — both of the above.\n   */\n  strategy?: 'referenceHidden' | 'escaped' | 'both';\n}\n\n/**\n * Detects when the reference or floating element is hidden outside the boundary.\n * Writes `{ referenceHidden, referenceHiddenOffsets, escaped, escapedOffsets }` to\n * `middlewareData.hide`.\n */\nexport function hide(options: HideOptions = {}): TypedMiddleware<'hide', HideData> {\n  const strategy = options.strategy ?? 'both';\n\n  function hideMiddleware(state: Parameters<Middleware>[0]): ReturnType<Middleware> {\n    const { boundary, padding } = resolveBoundary(options, state);\n    const next: HideData = {};\n\n    if (strategy === 'escaped' || strategy === 'both') {\n      const floatingRect = getFloatingRect(state);\n      const escapedOffsets = detectOverflowAtRect(floatingRect, boundary, padding);\n\n      next.escaped = isFullyClipped(floatingRect, escapedOffsets);\n      next.escapedOffsets = escapedOffsets;\n    }\n\n    if (strategy === 'referenceHidden' || strategy === 'both') {\n      const referenceHiddenOffsets = detectOverflowAtRect(state.rects.reference, boundary, padding);\n\n      next.referenceHidden = isFullyClipped(state.rects.reference, referenceHiddenOffsets);\n      next.referenceHiddenOffsets = referenceHiddenOffsets;\n    }\n\n    return { data: { hide: next } };\n  }\n\n  return tagMiddleware<'hide', HideData, typeof hideMiddleware>(hideMiddleware, 'hide');\n}\n"],"mappings":"gKAoBA,SAAgB,EAAK,EAAuB,CAAC,EAAsC,CACjF,IAAM,EAAW,EAAQ,UAAY,OAErC,SAAS,EAAe,EAA0D,CAChF,GAAM,CAAE,WAAU,WAAY,EAAgB,EAAS,CAAK,EACtD,EAAiB,CAAC,EAExB,GAAI,IAAa,WAAa,IAAa,OAAQ,CACjD,IAAM,EAAe,EAAgB,CAAK,EACpC,EAAiB,EAAqB,EAAc,EAAU,CAAO,EAE3E,EAAK,QAAU,EAAe,EAAc,CAAc,EAC1D,EAAK,eAAiB,CACxB,CAEA,GAAI,IAAa,mBAAqB,IAAa,OAAQ,CACzD,IAAM,EAAyB,EAAqB,EAAM,MAAM,UAAW,EAAU,CAAO,EAE5F,EAAK,gBAAkB,EAAe,EAAM,MAAM,UAAW,CAAsB,EACnF,EAAK,uBAAyB,CAChC,CAEA,MAAO,CAAE,KAAM,CAAE,KAAM,CAAK,CAAE,CAChC,CAEA,OAAO,EAAuD,EAAgB,MAAM,CACtF"}

package/dist/middleware/offset.cjs

@@ -0,0 +1,2 @@
+const e=require("../utils.cjs");function t(e,t){let n=typeof e==`function`?e(t):e;return typeof n==`number`?{crossAxis:0,mainAxis:n}:{crossAxis:n.crossAxis??0,mainAxis:n.mainAxis??0}}function n(n){return e.tagMiddleware(function(r){let i=e.getSide(r.placement),{crossAxis:a,mainAxis:o}=t(n,r);switch(i){case`bottom`:return{x:r.x+a,y:r.y+o};case`left`:return{x:r.x-o,y:r.y+a};case`right`:return{x:r.x+o,y:r.y+a};case`top`:return{x:r.x+a,y:r.y-o}}},`offset`)}exports.offset=n;
+//# sourceMappingURL=offset.cjs.map

package/dist/middleware/offset.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"offset.cjs","names":[],"sources":["../../src/middleware/offset.ts"],"sourcesContent":["import type { Middleware, MiddlewareState } from '../types';\n\nimport { getSide, tagMiddleware } from '../utils';\n\nexport type OffsetConfig = {\n  /** Offset perpendicular to the main axis. */\n  crossAxis?: number;\n  /** Offset along the axis away from the reference. */\n  mainAxis?: number;\n};\n\nexport type OffsetValue = number | OffsetConfig | ((state: MiddlewareState) => number | OffsetConfig);\n\nfunction resolveOffsetConfig(value: OffsetValue, state: MiddlewareState): Required<OffsetConfig> {\n  const raw = typeof value === 'function' ? value(state) : value;\n\n  if (typeof raw === 'number') return { crossAxis: 0, mainAxis: raw };\n\n  return { crossAxis: raw.crossAxis ?? 0, mainAxis: raw.mainAxis ?? 0 };\n}\n\n/**\n * Shifts the floating element along the main axis (away from reference) and/or\n * the cross axis. Accepts a number, config object, or a function for dynamic values.\n *\n * Must be the **first** middleware in the pipeline.\n */\nexport function offset(value: OffsetValue): Middleware {\n  return tagMiddleware(function offsetMiddleware(state: Parameters<Middleware>[0]): ReturnType<Middleware> {\n    const side = getSide(state.placement);\n    const { crossAxis, mainAxis } = resolveOffsetConfig(value, state);\n\n    switch (side) {\n      case 'bottom':\n        return { x: state.x + crossAxis, y: state.y + mainAxis };\n      case 'left':\n        return { x: state.x - mainAxis, y: state.y + crossAxis };\n      case 'right':\n        return { x: state.x + mainAxis, y: state.y + crossAxis };\n      case 'top':\n        return { x: state.x + crossAxis, y: state.y - mainAxis };\n    }\n  }, 'offset');\n}\n"],"mappings":"gCAaA,SAAS,EAAoB,EAAoB,EAAgD,CAC/F,IAAM,EAAM,OAAO,GAAU,WAAa,EAAM,CAAK,EAAI,EAIzD,OAFI,OAAO,GAAQ,SAAiB,CAAE,UAAW,EAAG,SAAU,CAAI,EAE3D,CAAE,UAAW,EAAI,WAAa,EAAG,SAAU,EAAI,UAAY,CAAE,CACtE,CAQA,SAAgB,EAAO,EAAgC,CACrD,OAAO,EAAA,cAAc,SAA0B,EAA0D,CACvG,IAAM,EAAO,EAAA,QAAQ,EAAM,SAAS,EAC9B,CAAE,YAAW,YAAa,EAAoB,EAAO,CAAK,EAEhE,OAAQ,EAAR,CACE,IAAK,SACH,MAAO,CAAE,EAAG,EAAM,EAAI,EAAW,EAAG,EAAM,EAAI,CAAS,EACzD,IAAK,OACH,MAAO,CAAE,EAAG,EAAM,EAAI,EAAU,EAAG,EAAM,EAAI,CAAU,EACzD,IAAK,QACH,MAAO,CAAE,EAAG,EAAM,EAAI,EAAU,EAAG,EAAM,EAAI,CAAU,EACzD,IAAK,MACH,MAAO,CAAE,EAAG,EAAM,EAAI,EAAW,EAAG,EAAM,EAAI,CAAS,CAC3D,CACF,EAAG,QAAQ,CACb"}

package/dist/middleware/offset.d.ts

@@ -0,0 +1,16 @@
+import type { Middleware, MiddlewareState } from '../types';
+export type OffsetConfig = {
+    /** Offset perpendicular to the main axis. */
+    crossAxis?: number;
+    /** Offset along the axis away from the reference. */
+    mainAxis?: number;
+};
+export type OffsetValue = number | OffsetConfig | ((state: MiddlewareState) => number | OffsetConfig);
+/**
+ * Shifts the floating element along the main axis (away from reference) and/or
+ * the cross axis. Accepts a number, config object, or a function for dynamic values.
+ *
+ * Must be the **first** middleware in the pipeline.
+ */
+export declare function offset(value: OffsetValue): Middleware;
+//# sourceMappingURL=offset.d.ts.map

package/dist/middleware/offset.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"offset.d.ts","sourceRoot":"","sources":["../../src/middleware/offset.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,eAAe,EAAE,MAAM,UAAU,CAAC;AAI5D,MAAM,MAAM,YAAY,GAAG;IACzB,6CAA6C;IAC7C,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,qDAAqD;IACrD,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB,CAAC;AAEF,MAAM,MAAM,WAAW,GAAG,MAAM,GAAG,YAAY,GAAG,CAAC,CAAC,KAAK,EAAE,eAAe,KAAK,MAAM,GAAG,YAAY,CAAC,CAAC;AAUtG;;;;;GAKG;AACH,wBAAgB,MAAM,CAAC,KAAK,EAAE,WAAW,GAAG,UAAU,CAgBrD"}

package/dist/middleware/offset.js

@@ -0,0 +1,2 @@
+import{getSide as e,tagMiddleware as t}from"../utils.js";function n(e,t){let n=typeof e==`function`?e(t):e;return typeof n==`number`?{crossAxis:0,mainAxis:n}:{crossAxis:n.crossAxis??0,mainAxis:n.mainAxis??0}}function r(r){return t(function(t){let i=e(t.placement),{crossAxis:a,mainAxis:o}=n(r,t);switch(i){case`bottom`:return{x:t.x+a,y:t.y+o};case`left`:return{x:t.x-o,y:t.y+a};case`right`:return{x:t.x+o,y:t.y+a};case`top`:return{x:t.x+a,y:t.y-o}}},`offset`)}export{r as offset};
+//# sourceMappingURL=offset.js.map

package/dist/middleware/offset.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"offset.js","names":[],"sources":["../../src/middleware/offset.ts"],"sourcesContent":["import type { Middleware, MiddlewareState } from '../types';\n\nimport { getSide, tagMiddleware } from '../utils';\n\nexport type OffsetConfig = {\n  /** Offset perpendicular to the main axis. */\n  crossAxis?: number;\n  /** Offset along the axis away from the reference. */\n  mainAxis?: number;\n};\n\nexport type OffsetValue = number | OffsetConfig | ((state: MiddlewareState) => number | OffsetConfig);\n\nfunction resolveOffsetConfig(value: OffsetValue, state: MiddlewareState): Required<OffsetConfig> {\n  const raw = typeof value === 'function' ? value(state) : value;\n\n  if (typeof raw === 'number') return { crossAxis: 0, mainAxis: raw };\n\n  return { crossAxis: raw.crossAxis ?? 0, mainAxis: raw.mainAxis ?? 0 };\n}\n\n/**\n * Shifts the floating element along the main axis (away from reference) and/or\n * the cross axis. Accepts a number, config object, or a function for dynamic values.\n *\n * Must be the **first** middleware in the pipeline.\n */\nexport function offset(value: OffsetValue): Middleware {\n  return tagMiddleware(function offsetMiddleware(state: Parameters<Middleware>[0]): ReturnType<Middleware> {\n    const side = getSide(state.placement);\n    const { crossAxis, mainAxis } = resolveOffsetConfig(value, state);\n\n    switch (side) {\n      case 'bottom':\n        return { x: state.x + crossAxis, y: state.y + mainAxis };\n      case 'left':\n        return { x: state.x - mainAxis, y: state.y + crossAxis };\n      case 'right':\n        return { x: state.x + mainAxis, y: state.y + crossAxis };\n      case 'top':\n        return { x: state.x + crossAxis, y: state.y - mainAxis };\n    }\n  }, 'offset');\n}\n"],"mappings":"yDAaA,SAAS,EAAoB,EAAoB,EAAgD,CAC/F,IAAM,EAAM,OAAO,GAAU,WAAa,EAAM,CAAK,EAAI,EAIzD,OAFI,OAAO,GAAQ,SAAiB,CAAE,UAAW,EAAG,SAAU,CAAI,EAE3D,CAAE,UAAW,EAAI,WAAa,EAAG,SAAU,EAAI,UAAY,CAAE,CACtE,CAQA,SAAgB,EAAO,EAAgC,CACrD,OAAO,EAAc,SAA0B,EAA0D,CACvG,IAAM,EAAO,EAAQ,EAAM,SAAS,EAC9B,CAAE,YAAW,YAAa,EAAoB,EAAO,CAAK,EAEhE,OAAQ,EAAR,CACE,IAAK,SACH,MAAO,CAAE,EAAG,EAAM,EAAI,EAAW,EAAG,EAAM,EAAI,CAAS,EACzD,IAAK,OACH,MAAO,CAAE,EAAG,EAAM,EAAI,EAAU,EAAG,EAAM,EAAI,CAAU,EACzD,IAAK,QACH,MAAO,CAAE,EAAG,EAAM,EAAI,EAAU,EAAG,EAAM,EAAI,CAAU,EACzD,IAAK,MACH,MAAO,CAAE,EAAG,EAAM,EAAI,EAAW,EAAG,EAAM,EAAI,CAAS,CAC3D,CACF,EAAG,QAAQ,CACb"}

package/dist/middleware/shift.cjs

@@ -0,0 +1,2 @@
+const e=require("../utils.cjs"),t=require("../overflow.cjs");let n=require("@vielzeug/arsenal");function r(t={}){return(r,i)=>{let{placement:a,rects:o,x:s,y:c}=r,l=e.getSide(a),u=l===`top`||l===`bottom`,d=typeof t.offset==`function`?t.offset(r):t.offset??0;if(u){let e=o.reference.x-d,t=o.reference.x+o.reference.width+d-o.floating.width,[r,a]=e<=t?[e,t]:[t,e],c=(0,n.clamp)(s+i.crossAxis,r,a);return{...i,crossAxis:c-s}}let f=o.reference.y-d,p=o.reference.y+o.reference.height+d-o.floating.height,[m,h]=f<=p?[f,p]:[p,f],g=(0,n.clamp)(c+i.crossAxis,m,h);return{...i,crossAxis:g-c}}}function i(n={}){let{crossAxis:r=!0,limiter:i,mainAxis:a=!1}=n;function o(o){let s=t.detectOverflow(o,n),c=e.getSide(o.placement),l=c===`top`||c===`bottom`,u=Math.max(s.left,0)-Math.max(s.right,0),d=Math.max(s.top,0)-Math.max(s.bottom,0),f=l?r:a,p=l?a:r,m=f?u:0,h=p?d:0;if(i){let e=i(o,{crossAxis:l?m:h,mainAxis:l?h:m});m=l?e.crossAxis:e.mainAxis,h=l?e.mainAxis:e.crossAxis}return{data:{shift:{x:m,y:h}},x:o.x+m,y:o.y+h}}return e.tagMiddleware(o,`shift`)}exports.limitShift=r,exports.shift=i;
+//# sourceMappingURL=shift.cjs.map

package/dist/middleware/shift.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"shift.cjs","names":[],"sources":["../../src/middleware/shift.ts"],"sourcesContent":["import type { DetectOverflowOptions, Middleware, MiddlewareState, ShiftData, TypedMiddleware } from '../types';\n\nimport { detectOverflow } from '../overflow';\nimport { clamp, getSide, tagMiddleware } from '../utils';\n\n/**\n * A limiter function passed to `shift()` that constrains the maximum allowed drift.\n * Receives the current middleware state and the proposed shift correction (as deltas),\n * and returns the clamped correction.\n */\nexport type ShiftLimiter = (\n  state: MiddlewareState,\n  correction: { crossAxis: number; mainAxis: number },\n) => { crossAxis: number; mainAxis: number };\n\nexport interface LimitShiftOptions {\n  /**\n   * Extra pixels of allowed drift past the reference's cross-axis extent before clamping kicks in.\n   * Can be a static number or a function returning a number based on current state.\n   * Default: `0`.\n   */\n  offset?: number | ((state: MiddlewareState) => number);\n}\n\n/**\n * Returns a {@link ShiftLimiter} that constrains `shift()` so the floating element\n * stays visually connected to the reference along the cross axis.\n *\n * Without a limiter, `shift()` will push the float as far as needed to fit in the boundary —\n * potentially sliding it far away from the reference. `limitShift` clamps the drift so the\n * float stays within the reference's cross-axis extent (± `offset` pixels).\n *\n * @example\n * ```ts\n * // Tooltip stays above the button even when viewport clips it.\n * shift({ padding: 6, limiter: limitShift() })\n *\n * // Allow up to 10px of drift beyond the reference's edges.\n * shift({ padding: 6, limiter: limitShift({ offset: 10 }) })\n * ```\n */\nexport function limitShift(options: LimitShiftOptions = {}): ShiftLimiter {\n  return (state, correction) => {\n    const { placement, rects, x, y } = state;\n    const side = getSide(placement);\n    const isVertical = side === 'top' || side === 'bottom';\n    const extra = typeof options.offset === 'function' ? options.offset(state) : (options.offset ?? 0);\n\n    if (isVertical) {\n      // Cross axis is x. Clamp float.left to [ref.left-extra, ref.right+extra-float.width].\n      const lo = rects.reference.x - extra;\n      const hi = rects.reference.x + rects.reference.width + extra - rects.floating.width;\n      const [min, max] = lo <= hi ? [lo, hi] : [hi, lo];\n      const clamped = clamp(x + correction.crossAxis, min, max);\n\n      return { ...correction, crossAxis: clamped - x };\n    }\n\n    // Cross axis is y. Clamp float.top to [ref.top-extra, ref.bottom+extra-float.height].\n    const lo = rects.reference.y - extra;\n    const hi = rects.reference.y + rects.reference.height + extra - rects.floating.height;\n    const [min, max] = lo <= hi ? [lo, hi] : [hi, lo];\n    const clamped = clamp(y + correction.crossAxis, min, max);\n\n    return { ...correction, crossAxis: clamped - y };\n  };\n}\n\nexport interface ShiftOptions extends DetectOverflowOptions {\n  /**\n   * Whether to shift along the main axis (the axis away from the reference).\n   * Default: `false` — main-axis overflow is better handled by `flip`.\n   */\n  mainAxis?: boolean;\n  /**\n   * Whether to shift along the cross axis (perpendicular to the reference direction).\n   * Default: `true`.\n   */\n  crossAxis?: boolean;\n  /**\n   * Constrains how far `shift()` can move the floating element along the cross axis.\n   * Pass `limitShift()` to keep the float within the reference's extent.\n   */\n  limiter?: ShiftLimiter;\n}\n\n/**\n * Shifts the floating element along the cross axis to keep it inside the boundary.\n *\n * By default only the cross axis is corrected. Enable `mainAxis` to also shift\n * along the main axis (useful when `flip` is not in the pipeline).\n *\n * | Placement        | Cross axis | Main axis |\n * |------------------|------------|-----------|\n * | `top` / `bottom` | horizontal | vertical  |\n * | `left` / `right` | vertical   | horizontal|\n */\nexport function shift(options: ShiftOptions = {}): TypedMiddleware<'shift', ShiftData> {\n  const { crossAxis = true, limiter, mainAxis = false } = options;\n\n  function shiftMiddleware(state: Parameters<Middleware>[0]): ReturnType<Middleware> {\n    const overflow = detectOverflow(state, options);\n    const side = getSide(state.placement);\n    const isVertical = side === 'top' || side === 'bottom';\n\n    const xCorrection = Math.max(overflow.left, 0) - Math.max(overflow.right, 0);\n    const yCorrection = Math.max(overflow.top, 0) - Math.max(overflow.bottom, 0);\n    const applyX = isVertical ? crossAxis : mainAxis;\n    const applyY = isVertical ? mainAxis : crossAxis;\n\n    let dx = applyX ? xCorrection : 0;\n    let dy = applyY ? yCorrection : 0;\n\n    if (limiter) {\n      const limited = limiter(state, {\n        crossAxis: isVertical ? dx : dy,\n        mainAxis: isVertical ? dy : dx,\n      });\n\n      dx = isVertical ? limited.crossAxis : limited.mainAxis;\n      dy = isVertical ? limited.mainAxis : limited.crossAxis;\n    }\n\n    return { data: { shift: { x: dx, y: dy } }, x: state.x + dx, y: state.y + dy };\n  }\n\n  return tagMiddleware<'shift', ShiftData, typeof shiftMiddleware>(shiftMiddleware, 'shift');\n}\n"],"mappings":"gGAyCA,SAAgB,EAAW,EAA6B,CAAC,EAAiB,CACxE,OAAQ,EAAO,IAAe,CAC5B,GAAM,CAAE,YAAW,QAAO,IAAG,KAAM,EAC7B,EAAO,EAAA,QAAQ,CAAS,EACxB,EAAa,IAAS,OAAS,IAAS,SACxC,EAAQ,OAAO,EAAQ,QAAW,WAAa,EAAQ,OAAO,CAAK,EAAK,EAAQ,QAAU,EAEhG,GAAI,EAAY,CAEd,IAAM,EAAK,EAAM,UAAU,EAAI,EACzB,EAAK,EAAM,UAAU,EAAI,EAAM,UAAU,MAAQ,EAAQ,EAAM,SAAS,MACxE,CAAC,EAAK,GAAO,GAAM,EAAK,CAAC,EAAI,CAAE,EAAI,CAAC,EAAI,CAAE,EAC1C,GAAA,EAAA,EAAA,MAAA,CAAgB,EAAI,EAAW,UAAW,EAAK,CAAG,EAExD,MAAO,CAAE,GAAG,EAAY,UAAW,EAAU,CAAE,CACjD,CAGA,IAAM,EAAK,EAAM,UAAU,EAAI,EACzB,EAAK,EAAM,UAAU,EAAI,EAAM,UAAU,OAAS,EAAQ,EAAM,SAAS,OACzE,CAAC,EAAK,GAAO,GAAM,EAAK,CAAC,EAAI,CAAE,EAAI,CAAC,EAAI,CAAE,EAC1C,GAAA,EAAA,EAAA,MAAA,CAAgB,EAAI,EAAW,UAAW,EAAK,CAAG,EAExD,MAAO,CAAE,GAAG,EAAY,UAAW,EAAU,CAAE,CACjD,CACF,CA+BA,SAAgB,EAAM,EAAwB,CAAC,EAAwC,CACrF,GAAM,CAAE,YAAY,GAAM,UAAS,WAAW,IAAU,EAExD,SAAS,EAAgB,EAA0D,CACjF,IAAM,EAAW,EAAA,eAAe,EAAO,CAAO,EACxC,EAAO,EAAA,QAAQ,EAAM,SAAS,EAC9B,EAAa,IAAS,OAAS,IAAS,SAExC,EAAc,KAAK,IAAI,EAAS,KAAM,CAAC,EAAI,KAAK,IAAI,EAAS,MAAO,CAAC,EACrE,EAAc,KAAK,IAAI,EAAS,IAAK,CAAC,EAAI,KAAK,IAAI,EAAS,OAAQ,CAAC,EACrE,EAAS,EAAa,EAAY,EAClC,EAAS,EAAa,EAAW,EAEnC,EAAK,EAAS,EAAc,EAC5B,EAAK,EAAS,EAAc,EAEhC,GAAI,EAAS,CACX,IAAM,EAAU,EAAQ,EAAO,CAC7B,UAAW,EAAa,EAAK,EAC7B,SAAU,EAAa,EAAK,CAC9B,CAAC,EAED,EAAK,EAAa,EAAQ,UAAY,EAAQ,SAC9C,EAAK,EAAa,EAAQ,SAAW,EAAQ,SAC/C,CAEA,MAAO,CAAE,KAAM,CAAE,MAAO,CAAE,EAAG,EAAI,EAAG,CAAG,CAAE,EAAG,EAAG,EAAM,EAAI,EAAI,EAAG,EAAM,EAAI,CAAG,CAC/E,CAEA,OAAO,EAAA,cAA0D,EAAiB,OAAO,CAC3F"}