@zag-js/splitter 1.34.1 → 1.35.0

package/dist/utils/fuzzy.js

@@ -0,0 +1,60 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/utils/fuzzy.ts
+var fuzzy_exports = {};
+__export(fuzzy_exports, {
+  PRECISION: () => PRECISION,
+  fuzzyCompareNumbers: () => fuzzyCompareNumbers,
+  fuzzyNumbersEqual: () => fuzzyNumbersEqual,
+  fuzzySizeEqual: () => fuzzySizeEqual
+});
+module.exports = __toCommonJS(fuzzy_exports);
+var PRECISION = 10;
+function fuzzyCompareNumbers(actual, expected, fractionDigits = PRECISION) {
+  if (actual.toFixed(fractionDigits) === expected.toFixed(fractionDigits)) {
+    return 0;
+  } else {
+    return actual > expected ? 1 : -1;
+  }
+}
+function fuzzyNumbersEqual(actual, expected, fractionDigits = PRECISION) {
+  if (actual == null || expected == null) return false;
+  return fuzzyCompareNumbers(actual, expected, fractionDigits) === 0;
+}
+function fuzzySizeEqual(actual, expected, fractionDigits) {
+  if (actual.length !== expected.length) {
+    return false;
+  }
+  for (let index = 0; index < actual.length; index++) {
+    const actualSize = actual[index];
+    const expectedSize = expected[index];
+    if (!fuzzyNumbersEqual(actualSize, expectedSize, fractionDigits)) {
+      return false;
+    }
+  }
+  return true;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  PRECISION,
+  fuzzyCompareNumbers,
+  fuzzyNumbersEqual,
+  fuzzySizeEqual
+});

package/dist/utils/fuzzy.mjs

@@ -0,0 +1,32 @@
+// src/utils/fuzzy.ts
+var PRECISION = 10;
+function fuzzyCompareNumbers(actual, expected, fractionDigits = PRECISION) {
+  if (actual.toFixed(fractionDigits) === expected.toFixed(fractionDigits)) {
+    return 0;
+  } else {
+    return actual > expected ? 1 : -1;
+  }
+}
+function fuzzyNumbersEqual(actual, expected, fractionDigits = PRECISION) {
+  if (actual == null || expected == null) return false;
+  return fuzzyCompareNumbers(actual, expected, fractionDigits) === 0;
+}
+function fuzzySizeEqual(actual, expected, fractionDigits) {
+  if (actual.length !== expected.length) {
+    return false;
+  }
+  for (let index = 0; index < actual.length; index++) {
+    const actualSize = actual[index];
+    const expectedSize = expected[index];
+    if (!fuzzyNumbersEqual(actualSize, expectedSize, fractionDigits)) {
+      return false;
+    }
+  }
+  return true;
+}
+export {
+  PRECISION,
+  fuzzyCompareNumbers,
+  fuzzyNumbersEqual,
+  fuzzySizeEqual
+};

package/dist/utils/panel.d.mts

@@ -0,0 +1,34 @@
+import { Style } from '@zag-js/types';
+import { PanelData, DragState, PanelId } from '../splitter.types.mjs';
+import '@zag-js/core';
+
+declare function getPanelById(panels: PanelData[], id: string): PanelData;
+declare function findPanelDataIndex(panels: PanelData[], panel: PanelData): number;
+declare function findPanelIndex(panels: PanelData[], id: string): number;
+declare function panelDataHelper(panels: PanelData[], panel: PanelData, sizes: number[]): {
+    panelSize: number;
+    pivotIndices: number[];
+    id: PanelId;
+    order?: number | undefined;
+    minSize?: number | undefined;
+    maxSize?: number | undefined;
+    collapsible?: boolean | undefined;
+    collapsedSize?: number | undefined;
+};
+declare function sortPanels(panels: PanelData[]): PanelData[];
+declare function getPanelLayout(panels: PanelData[]): string;
+declare function serializePanels(panels: PanelData[]): string;
+declare function getPanelFlexBoxStyle({ defaultSize, dragState, sizes, panels, panelIndex, precision, }: {
+    defaultSize: number | undefined;
+    sizes: number[];
+    dragState: DragState | null;
+    panels: PanelData[];
+    panelIndex: number;
+    precision?: number | undefined;
+}): Style;
+declare function getUnsafeDefaultSize({ panels, size: sizes }: {
+    panels: PanelData[];
+    size: number[];
+}): number[];
+
+export { findPanelDataIndex, findPanelIndex, getPanelById, getPanelFlexBoxStyle, getPanelLayout, getUnsafeDefaultSize, panelDataHelper, serializePanels, sortPanels };

package/dist/utils/panel.d.ts

@@ -0,0 +1,34 @@
+import { Style } from '@zag-js/types';
+import { PanelData, DragState, PanelId } from '../splitter.types.js';
+import '@zag-js/core';
+
+declare function getPanelById(panels: PanelData[], id: string): PanelData;
+declare function findPanelDataIndex(panels: PanelData[], panel: PanelData): number;
+declare function findPanelIndex(panels: PanelData[], id: string): number;
+declare function panelDataHelper(panels: PanelData[], panel: PanelData, sizes: number[]): {
+    panelSize: number;
+    pivotIndices: number[];
+    id: PanelId;
+    order?: number | undefined;
+    minSize?: number | undefined;
+    maxSize?: number | undefined;
+    collapsible?: boolean | undefined;
+    collapsedSize?: number | undefined;
+};
+declare function sortPanels(panels: PanelData[]): PanelData[];
+declare function getPanelLayout(panels: PanelData[]): string;
+declare function serializePanels(panels: PanelData[]): string;
+declare function getPanelFlexBoxStyle({ defaultSize, dragState, sizes, panels, panelIndex, precision, }: {
+    defaultSize: number | undefined;
+    sizes: number[];
+    dragState: DragState | null;
+    panels: PanelData[];
+    panelIndex: number;
+    precision?: number | undefined;
+}): Style;
+declare function getUnsafeDefaultSize({ panels, size: sizes }: {
+    panels: PanelData[];
+    size: number[];
+}): number[];
+
+export { findPanelDataIndex, findPanelIndex, getPanelById, getPanelFlexBoxStyle, getPanelLayout, getUnsafeDefaultSize, panelDataHelper, serializePanels, sortPanels };

package/dist/utils/panel.js

@@ -0,0 +1,147 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/utils/panel.ts
+var panel_exports = {};
+__export(panel_exports, {
+  findPanelDataIndex: () => findPanelDataIndex,
+  findPanelIndex: () => findPanelIndex,
+  getPanelById: () => getPanelById,
+  getPanelFlexBoxStyle: () => getPanelFlexBoxStyle,
+  getPanelLayout: () => getPanelLayout,
+  getUnsafeDefaultSize: () => getUnsafeDefaultSize,
+  panelDataHelper: () => panelDataHelper,
+  serializePanels: () => serializePanels,
+  sortPanels: () => sortPanels
+});
+module.exports = __toCommonJS(panel_exports);
+var import_utils = require("@zag-js/utils");
+function getPanelById(panels, id) {
+  const panel = panels.find((panel2) => panel2.id === id);
+  (0, import_utils.ensure)(panel, () => `Panel data not found for id "${id}"`);
+  return panel;
+}
+function findPanelDataIndex(panels, panel) {
+  return panels.findIndex((prevPanel) => prevPanel === panel || prevPanel.id === panel.id);
+}
+function findPanelIndex(panels, id) {
+  return panels.findIndex((panel) => panel.id === id);
+}
+function panelDataHelper(panels, panel, sizes) {
+  const index = findPanelIndex(panels, panel.id);
+  const pivotIndices = index === panels.length - 1 ? [index - 1, index] : [index, index + 1];
+  const panelSize = sizes[index];
+  return { ...panel, panelSize, pivotIndices };
+}
+function sortPanels(panels) {
+  return panels.sort((panelA, panelB) => {
+    const orderA = panelA.order;
+    const orderB = panelB.order;
+    if (orderA == null && orderB == null) {
+      return 0;
+    } else if (orderA == null) {
+      return -1;
+    } else if (orderB == null) {
+      return 1;
+    } else {
+      return orderA - orderB;
+    }
+  });
+}
+function getPanelLayout(panels) {
+  return panels.map((panel) => panel.id).sort().join(":");
+}
+function serializePanels(panels) {
+  const keys = panels.map((panel) => panel.id);
+  const sortedKeys = keys.sort();
+  const serialized = sortedKeys.map((key) => {
+    const panel = panels.find((panel2) => panel2.id === key);
+    return JSON.stringify(panel);
+  });
+  return serialized.join(",");
+}
+function getPanelFlexBoxStyle({
+  defaultSize,
+  dragState,
+  sizes,
+  panels,
+  panelIndex,
+  precision = 3
+}) {
+  const size = sizes[panelIndex];
+  let flexGrow;
+  if (size == null) {
+    flexGrow = defaultSize != void 0 ? defaultSize.toPrecision(precision) : "1";
+  } else if (panels.length === 1) {
+    flexGrow = "1";
+  } else {
+    flexGrow = size.toPrecision(precision);
+  }
+  return {
+    flexBasis: 0,
+    flexGrow,
+    flexShrink: 1,
+    // Without this, Panel sizes may be unintentionally overridden by their content
+    overflow: "hidden",
+    // Disable pointer events inside of a panel during resize
+    // This avoid edge cases like nested iframes
+    pointerEvents: dragState !== null ? "none" : void 0
+  };
+}
+function getUnsafeDefaultSize({ panels, size: sizes }) {
+  const finalSizes = Array(panels.length);
+  let numPanelsWithSizes = 0;
+  let remainingSize = 100;
+  for (let index = 0; index < panels.length; index++) {
+    const panel = panels[index];
+    (0, import_utils.ensure)(panel, () => `Panel data not found for index ${index}`);
+    const defaultSize = sizes[index];
+    if (defaultSize != null) {
+      numPanelsWithSizes++;
+      finalSizes[index] = defaultSize;
+      remainingSize -= defaultSize;
+    }
+  }
+  for (let index = 0; index < panels.length; index++) {
+    const panel = panels[index];
+    (0, import_utils.ensure)(panel, () => `Panel data not found for index ${index}`);
+    const defaultSize = sizes[index];
+    if (defaultSize != null) {
+      continue;
+    }
+    const numRemainingPanels = panels.length - numPanelsWithSizes;
+    const size = remainingSize / numRemainingPanels;
+    numPanelsWithSizes++;
+    finalSizes[index] = size;
+    remainingSize -= size;
+  }
+  return finalSizes;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  findPanelDataIndex,
+  findPanelIndex,
+  getPanelById,
+  getPanelFlexBoxStyle,
+  getPanelLayout,
+  getUnsafeDefaultSize,
+  panelDataHelper,
+  serializePanels,
+  sortPanels
+});

package/dist/utils/panel.mjs

@@ -0,0 +1,114 @@
+// src/utils/panel.ts
+import { ensure } from "@zag-js/utils";
+function getPanelById(panels, id) {
+  const panel = panels.find((panel2) => panel2.id === id);
+  ensure(panel, () => `Panel data not found for id "${id}"`);
+  return panel;
+}
+function findPanelDataIndex(panels, panel) {
+  return panels.findIndex((prevPanel) => prevPanel === panel || prevPanel.id === panel.id);
+}
+function findPanelIndex(panels, id) {
+  return panels.findIndex((panel) => panel.id === id);
+}
+function panelDataHelper(panels, panel, sizes) {
+  const index = findPanelIndex(panels, panel.id);
+  const pivotIndices = index === panels.length - 1 ? [index - 1, index] : [index, index + 1];
+  const panelSize = sizes[index];
+  return { ...panel, panelSize, pivotIndices };
+}
+function sortPanels(panels) {
+  return panels.sort((panelA, panelB) => {
+    const orderA = panelA.order;
+    const orderB = panelB.order;
+    if (orderA == null && orderB == null) {
+      return 0;
+    } else if (orderA == null) {
+      return -1;
+    } else if (orderB == null) {
+      return 1;
+    } else {
+      return orderA - orderB;
+    }
+  });
+}
+function getPanelLayout(panels) {
+  return panels.map((panel) => panel.id).sort().join(":");
+}
+function serializePanels(panels) {
+  const keys = panels.map((panel) => panel.id);
+  const sortedKeys = keys.sort();
+  const serialized = sortedKeys.map((key) => {
+    const panel = panels.find((panel2) => panel2.id === key);
+    return JSON.stringify(panel);
+  });
+  return serialized.join(",");
+}
+function getPanelFlexBoxStyle({
+  defaultSize,
+  dragState,
+  sizes,
+  panels,
+  panelIndex,
+  precision = 3
+}) {
+  const size = sizes[panelIndex];
+  let flexGrow;
+  if (size == null) {
+    flexGrow = defaultSize != void 0 ? defaultSize.toPrecision(precision) : "1";
+  } else if (panels.length === 1) {
+    flexGrow = "1";
+  } else {
+    flexGrow = size.toPrecision(precision);
+  }
+  return {
+    flexBasis: 0,
+    flexGrow,
+    flexShrink: 1,
+    // Without this, Panel sizes may be unintentionally overridden by their content
+    overflow: "hidden",
+    // Disable pointer events inside of a panel during resize
+    // This avoid edge cases like nested iframes
+    pointerEvents: dragState !== null ? "none" : void 0
+  };
+}
+function getUnsafeDefaultSize({ panels, size: sizes }) {
+  const finalSizes = Array(panels.length);
+  let numPanelsWithSizes = 0;
+  let remainingSize = 100;
+  for (let index = 0; index < panels.length; index++) {
+    const panel = panels[index];
+    ensure(panel, () => `Panel data not found for index ${index}`);
+    const defaultSize = sizes[index];
+    if (defaultSize != null) {
+      numPanelsWithSizes++;
+      finalSizes[index] = defaultSize;
+      remainingSize -= defaultSize;
+    }
+  }
+  for (let index = 0; index < panels.length; index++) {
+    const panel = panels[index];
+    ensure(panel, () => `Panel data not found for index ${index}`);
+    const defaultSize = sizes[index];
+    if (defaultSize != null) {
+      continue;
+    }
+    const numRemainingPanels = panels.length - numPanelsWithSizes;
+    const size = remainingSize / numRemainingPanels;
+    numPanelsWithSizes++;
+    finalSizes[index] = size;
+    remainingSize -= size;
+  }
+  return finalSizes;
+}
+export {
+  findPanelDataIndex,
+  findPanelIndex,
+  getPanelById,
+  getPanelFlexBoxStyle,
+  getPanelLayout,
+  getUnsafeDefaultSize,
+  panelDataHelper,
+  serializePanels,
+  sortPanels
+};

package/dist/utils/resize-by-delta.d.mts

@@ -0,0 +1,20 @@
+import { PanelData } from '../splitter.types.mjs';
+import '@zag-js/core';
+import '@zag-js/types';
+
+/**
+ * This code was modified from react-resizable-panels by Brian Vaughn
+ * @see https://github.com/bvaughn/react-resizable-panels
+ */
+
+interface Layout {
+    delta: number;
+    initialSize: number[];
+    panels: PanelData[];
+    pivotIndices: number[];
+    prevSize: number[];
+    trigger: "imperative-api" | "keyboard" | "mouse-or-touch";
+}
+declare function resizeByDelta(props: Layout): number[];
+
+export { resizeByDelta };

package/dist/utils/resize-by-delta.d.ts

@@ -0,0 +1,20 @@
+import { PanelData } from '../splitter.types.js';
+import '@zag-js/core';
+import '@zag-js/types';
+
+/**
+ * This code was modified from react-resizable-panels by Brian Vaughn
+ * @see https://github.com/bvaughn/react-resizable-panels
+ */
+
+interface Layout {
+    delta: number;
+    initialSize: number[];
+    panels: PanelData[];
+    pivotIndices: number[];
+    prevSize: number[];
+    trigger: "imperative-api" | "keyboard" | "mouse-or-touch";
+}
+declare function resizeByDelta(props: Layout): number[];
+
+export { resizeByDelta };

package/dist/utils/resize-by-delta.js

@@ -0,0 +1,165 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/utils/resize-by-delta.ts
+var resize_by_delta_exports = {};
+__export(resize_by_delta_exports, {
+  resizeByDelta: () => resizeByDelta
+});
+module.exports = __toCommonJS(resize_by_delta_exports);
+var import_utils = require("@zag-js/utils");
+var import_fuzzy = require("./fuzzy.cjs");
+var import_resize_panel = require("./resize-panel.cjs");
+function resizeByDelta(props) {
+  let { delta, initialSize, panels, pivotIndices, prevSize, trigger } = props;
+  if ((0, import_fuzzy.fuzzyNumbersEqual)(delta, 0)) {
+    return initialSize;
+  }
+  const nextSize = [...initialSize];
+  const [firstPivotIndex, secondPivotIndex] = pivotIndices;
+  (0, import_utils.ensure)(firstPivotIndex, () => "Invalid first pivot index");
+  (0, import_utils.ensure)(secondPivotIndex, () => "Invalid second pivot index");
+  let deltaApplied = 0;
+  {
+    if (trigger === "keyboard") {
+      {
+        const index = delta < 0 ? secondPivotIndex : firstPivotIndex;
+        const panel = panels[index];
+        (0, import_utils.ensure)(panel, () => `Panel data not found for index ${index}`);
+        const { collapsedSize = 0, collapsible, minSize = 0 } = panel;
+        if (collapsible) {
+          const prevSize2 = initialSize[index];
+          (0, import_utils.ensure)(prevSize2, () => `Previous size not found for panel index ${index}`);
+          if ((0, import_fuzzy.fuzzyNumbersEqual)(prevSize2, collapsedSize)) {
+            const localDelta = minSize - prevSize2;
+            if ((0, import_fuzzy.fuzzyCompareNumbers)(localDelta, Math.abs(delta)) > 0) {
+              delta = delta < 0 ? 0 - localDelta : localDelta;
+            }
+          }
+        }
+      }
+      {
+        const index = delta < 0 ? firstPivotIndex : secondPivotIndex;
+        const panel = panels[index];
+        (0, import_utils.ensure)(panel, () => `No panel data found for index ${index}`);
+        const { collapsedSize = 0, collapsible, minSize = 0 } = panel;
+        if (collapsible) {
+          const prevSize2 = initialSize[index];
+          (0, import_utils.ensure)(prevSize2, () => `Previous size not found for panel index ${index}`);
+          if ((0, import_fuzzy.fuzzyNumbersEqual)(prevSize2, minSize)) {
+            const localDelta = prevSize2 - collapsedSize;
+            if ((0, import_fuzzy.fuzzyCompareNumbers)(localDelta, Math.abs(delta)) > 0) {
+              delta = delta < 0 ? 0 - localDelta : localDelta;
+            }
+          }
+        }
+      }
+    }
+  }
+  {
+    const increment = delta < 0 ? 1 : -1;
+    let index = delta < 0 ? secondPivotIndex : firstPivotIndex;
+    let maxAvailableDelta = 0;
+    while (true) {
+      const prevSize2 = initialSize[index];
+      (0, import_utils.ensure)(prevSize2, () => `Previous size not found for panel index ${index}`);
+      const maxSafeSize = (0, import_resize_panel.resizePanel)({
+        panels,
+        index,
+        size: 100
+      });
+      const delta2 = maxSafeSize - prevSize2;
+      maxAvailableDelta += delta2;
+      index += increment;
+      if (index < 0 || index >= panels.length) {
+        break;
+      }
+    }
+    const minAbsDelta = Math.min(Math.abs(delta), Math.abs(maxAvailableDelta));
+    delta = delta < 0 ? 0 - minAbsDelta : minAbsDelta;
+  }
+  {
+    const pivotIndex = delta < 0 ? firstPivotIndex : secondPivotIndex;
+    let index = pivotIndex;
+    while (index >= 0 && index < panels.length) {
+      const deltaRemaining = Math.abs(delta) - Math.abs(deltaApplied);
+      const prevSize2 = initialSize[index];
+      (0, import_utils.ensure)(prevSize2, () => `Previous size not found for panel index ${index}`);
+      const unsafeSize = prevSize2 - deltaRemaining;
+      const safeSize = (0, import_resize_panel.resizePanel)({ panels, index, size: unsafeSize });
+      if (!(0, import_fuzzy.fuzzyNumbersEqual)(prevSize2, safeSize)) {
+        deltaApplied += prevSize2 - safeSize;
+        nextSize[index] = safeSize;
+        if (deltaApplied.toPrecision(3).localeCompare(Math.abs(delta).toPrecision(3), void 0, {
+          numeric: true
+        }) >= 0) {
+          break;
+        }
+      }
+      if (delta < 0) {
+        index--;
+      } else {
+        index++;
+      }
+    }
+  }
+  if ((0, import_fuzzy.fuzzySizeEqual)(prevSize, nextSize)) {
+    return prevSize;
+  }
+  {
+    const pivotIndex = delta < 0 ? secondPivotIndex : firstPivotIndex;
+    const prevSize2 = initialSize[pivotIndex];
+    (0, import_utils.ensure)(prevSize2, () => `Previous size not found for panel index ${pivotIndex}`);
+    const unsafeSize = prevSize2 + deltaApplied;
+    const safeSize = (0, import_resize_panel.resizePanel)({ panels, index: pivotIndex, size: unsafeSize });
+    nextSize[pivotIndex] = safeSize;
+    if (!(0, import_fuzzy.fuzzyNumbersEqual)(safeSize, unsafeSize)) {
+      let deltaRemaining = unsafeSize - safeSize;
+      const pivotIndex2 = delta < 0 ? secondPivotIndex : firstPivotIndex;
+      let index = pivotIndex2;
+      while (index >= 0 && index < panels.length) {
+        const prevSize3 = nextSize[index];
+        (0, import_utils.ensure)(prevSize3, () => `Previous size not found for panel index ${index}`);
+        const unsafeSize2 = prevSize3 + deltaRemaining;
+        const safeSize2 = (0, import_resize_panel.resizePanel)({ panels, index, size: unsafeSize2 });
+        if (!(0, import_fuzzy.fuzzyNumbersEqual)(prevSize3, safeSize2)) {
+          deltaRemaining -= safeSize2 - prevSize3;
+          nextSize[index] = safeSize2;
+        }
+        if ((0, import_fuzzy.fuzzyNumbersEqual)(deltaRemaining, 0)) {
+          break;
+        }
+        if (delta > 0) {
+          index--;
+        } else {
+          index++;
+        }
+      }
+    }
+  }
+  const totalSize = nextSize.reduce((total, size) => size + total, 0);
+  if (!(0, import_fuzzy.fuzzyNumbersEqual)(totalSize, 100)) {
+    return prevSize;
+  }
+  return nextSize;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  resizeByDelta
+});