@infinite-table/infinite-react/index.dev.mjs

Infinite Table for React

var __create = Object.create;
var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __getProtoOf = Object.getPrototypeOf;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __commonJS = (cb, mod) => function __require() {
  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
};
var __copyProps = (to, from, except, desc) => {
  if (from && typeof from === "object" || typeof from === "function") {
    for (let key of __getOwnPropNames(from))
      if (!__hasOwnProp.call(to, key) && key !== except)
        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
  }
  return to;
};
var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
  // If the importer is in node compatibility mode or this is not an ESM
  // file that has been converted to a CommonJS file using a Babel-
  // compatible transform (i.e. "__esModule" has not been set), then set
  // "default" to the CommonJS "module.exports" for node compatibility.
  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
  mod
));

// node_modules/binary-search/index.js
var require_binary_search = __commonJS({
  "node_modules/binary-search/index.js"(exports, module) {
    "use strict";
    module.exports = function(haystack, needle, comparator, low, high) {
      var mid, cmp;
      if (low === void 0)
        low = 0;
      else {
        low = low | 0;
        if (low < 0 || low >= haystack.length)
          throw new RangeError("invalid lower bound");
      }
      if (high === void 0)
        high = haystack.length - 1;
      else {
        high = high | 0;
        if (high < low || high >= haystack.length)
          throw new RangeError("invalid upper bound");
      }
      while (low <= high) {
        mid = low + (high - low >>> 1);
        cmp = +comparator(haystack[mid], needle, mid, haystack);
        if (cmp < 0)
          low = mid + 1;
        else if (cmp > 0)
          high = mid - 1;
        else
          return mid;
      }
      return ~low;
    };
  }
});

// src/components/utils/debounce.ts
function debounce(fn, { wait }) {
  let timeout = null;
  return function(...args) {
    const context = this;
    if (timeout !== null) {
      clearTimeout(timeout);
    }
    timeout = setTimeout(() => {
      fn.apply(context, args);
    }, wait);
  };
}

// src/components/InfiniteTable/index.tsx
import * as React78 from "react";

// src/utils/join.ts
var join = (...args) => args.filter((x) => !!`${x}`).join(" ");

// src/components/CSSNumericVariableWatch.tsx
import * as React2 from "react";
import { useRef as useRef2 } from "react";

// src/components/utils/buildSubscriptionCallback.tsx
function buildSubscriptionCallback(withRaf = false) {
  let lastCallValue = null;
  let fns = [];
  let rafId = null;
  const updater = (items, callback) => {
    const results = [];
    if (withRaf) {
      if (rafId != null) {
        cancelAnimationFrame(rafId);
        rafId = null;
      }
      requestAnimationFrame(() => {
        lastCallValue = items;
        rafId = null;
        for (let i = 0, len = fns.length; i < len; i++) {
          results.push(fns[i](items));
        }
        callback?.(results);
      });
    } else {
      lastCallValue = items;
      for (let i = 0, len = fns.length; i < len; i++) {
        results.push(fns[i](items));
      }
      callback?.(results);
    }
  };
  updater.get = () => lastCallValue;
  updater.onChange = (fn) => {
    fns.push(fn);
    return () => {
      fns = fns.filter((f) => f !== fn);
    };
  };
  updater.destroy = () => {
    updater(null);
    fns.length = 0;
  };
  updater.getListenersCount = () => fns.length;
  return updater;
}

// src/utils/DeepMap/once.ts
function once(fn) {
  let called = false;
  let result = null;
  const onceFn = (...args) => {
    if (called) {
      return result;
    }
    called = true;
    result = fn(...args);
    return result;
  };
  return onceFn;
}

// src/utils/DeepMap/sortAscending.ts
var sortAscending = (a, b) => a - b;

// src/utils/DeepMap/index.ts
var SORT_ASC_REVISION = (p1, p2) => sortAscending(p1.revision, p2.revision);
var DeepMap = class _DeepMap {
  constructor(initial) {
    this.map = /* @__PURE__ */ new Map();
    this.length = 0;
    this.revision = 0;
    this.emptyKey = Symbol("emptyKey");
    this.visit = (fn) => {
      this.map.forEach((_, k) => this.visitKey(k, this.map, [], fn, false));
    };
    this.visitSome = (fn) => {
      this.visitWithNext([], fn, true);
    };
    this.visitDepthFirst = (fn) => {
      this.visitWithNext([], fn, false);
    };
    this.visitWithNext = (parentKeys, fn, earlyReturn, currentMap = this.map, depthLimit, skipSelfValue) => {
      if (!currentMap) {
        return;
      }
      let i = 0;
      const hasEmptyKey = currentMap.has(this.emptyKey);
      let allowEmptyKey = skipSelfValue ? false : true;
      if (depthLimit !== void 0) {
        if (depthLimit < 0) {
          return;
        }
        depthLimit--;
      }
      const iterator = (_, key) => {
        const pair = currentMap.get(key);
        if (!pair) {
          return;
        }
        const { map: map2 } = pair;
        const isEmptyKey = key === this.emptyKey;
        if (isEmptyKey && !allowEmptyKey) {
          return;
        }
        const keys = isEmptyKey ? [] : [...parentKeys, key];
        let next = map2 ? () => this.visitWithNext(
          keys,
          fn,
          earlyReturn,
          map2,
          depthLimit !== void 0 ? depthLimit - 1 : void 0
        ) : void 0;
        if (pair.hasOwnProperty("value")) {
          const res = fn(pair.value, keys, i, next, pair);
          if (earlyReturn && res === true) {
            return true;
          }
          i++;
        } else {
          next?.();
        }
        return;
      };
      if (hasEmptyKey) {
        iterator(void 0, this.emptyKey);
        allowEmptyKey = false;
        i = 0;
      }
      for (const [key, pair] of currentMap) {
        const res = iterator(pair, key);
        if (earlyReturn && res === true) {
          return res;
        }
      }
      return;
    };
    this.fill(initial);
  }
  static clone(map2) {
    const clone = new _DeepMap();
    map2.visit((pair, keys) => {
      clone.set(keys, pair.value);
    });
    return clone;
  }
  fill(initial) {
    if (initial) {
      initial.forEach((entry) => {
        const [keys, value] = entry;
        this.set(keys, value);
      });
    }
  }
  getValuesStartingWith(keys, options) {
    const result = [];
    this.getStartingWith(
      keys,
      (_keys, value) => {
        result.push(value);
      },
      options
    );
    return result;
  }
  getEntriesStartingWith(keys, options) {
    const result = [];
    this.getStartingWith(
      keys,
      (keys2, value) => {
        result.push([keys2, value]);
      },
      options
    );
    return result;
  }
  getLeafNodesStartingWith(keys, withPair, options) {
    const { respectOrder = false } = options || {};
    const pairs = [];
    const result = [];
    this.getStartingWith(
      keys,
      (_keys, _value, pair) => {
        if (!pair.map && pair.hasOwnProperty("value")) {
          if (respectOrder) {
            pairs.push(pair);
          } else {
            result.push(withPair(pair));
          }
        }
      },
      options
    );
    if (respectOrder) {
      return pairs.sort(SORT_ASC_REVISION).map(withPair);
    }
    return result;
  }
  getKeysForLeafNodesStartingWith(keys, options) {
    return this.getLeafNodesStartingWith(keys, (pair) => pair.keys, options);
  }
  getKeysAndValuesForLeafNodesStartingWith(keys, options) {
    return this.getLeafNodesStartingWith(
      keys,
      (pair) => [pair.keys, pair.value],
      options
    );
  }
  /**
   * @param keys - the keys of the node to start from
   * @param excludeSelf - whether to exclude the start node
   * @param depthLimit - the depth limit
   * @returns the keys of the first child on each branch (starting from the node with the given keys)
   */
  getKeysOfFirstChildOnEachBranchStartingWith(keys, options) {
    const { excludeSelf, depthLimit, respectOrder = true } = options || {};
    const pairs = [];
    const result = [];
    const fn = (pair2) => {
      if (respectOrder) {
        pairs.push(pair2);
      } else {
        result.push(pair2.keys);
      }
    };
    let currentMap = this.map;
    let pair;
    let stop = false;
    if (keys.length) {
      for (let i = 0, len = keys.length; i < len; i++) {
        const key = keys[i];
        pair = currentMap.get(key);
        if (!pair || !pair.map) {
          stop = true;
          if (i === len - 1) {
            stop = true;
            break;
          } else {
            return [];
          }
        }
        currentMap = pair.map;
      }
    } else {
      if (!excludeSelf) {
        const hasEmptyKey = currentMap.has(this.emptyKey);
        if (hasEmptyKey) {
          return [[]];
        }
      }
    }
    if (pair && pair.value !== void 0) {
      if (!excludeSelf) {
        fn({ ...pair, keys });
        stop = true;
      }
    }
    if (stop) {
      if (respectOrder) {
        return pairs.sort(SORT_ASC_REVISION).map((pair2) => pair2.keys);
      }
      return result;
    }
    this.visitWithNext(
      keys,
      (_value, keys2, _i, _next, pair2) => {
        fn({ ...pair2, keys: keys2 });
      },
      false,
      currentMap,
      depthLimit,
      excludeSelf
    );
    if (respectOrder) {
      return pairs.sort(SORT_ASC_REVISION).map((pair2) => pair2.keys);
    }
    return result;
  }
  getKeysStartingWith(keys, options) {
    const result = [];
    this.getStartingWith(
      keys,
      (keys2) => {
        result.push(keys2);
      },
      options
    );
    return result;
  }
  getStartingWith(keys, fn, options) {
    const { excludeSelf, depthLimit } = options || {};
    let currentMap = this.map;
    let pair;
    let stop = false;
    if (keys.length) {
      for (let i = 0, len = keys.length; i < len; i++) {
        const key = keys[i];
        pair = currentMap.get(key);
        if (!pair || !pair.map) {
          stop = true;
          if (i === len - 1) {
            stop = true;
            break;
          } else {
            return;
          }
        }
        currentMap = pair.map;
      }
    }
    if (pair && pair.value !== void 0) {
      if (!excludeSelf) {
        fn(keys, pair.value, { ...pair, keys });
      }
    }
    if (stop) {
      return;
    }
    this.visitWithNext(
      keys,
      (value, keys2, _i, next, pair2) => {
        fn(keys2, value, { ...pair2, keys: keys2 });
        next?.();
      },
      false,
      currentMap,
      depthLimit,
      excludeSelf
    );
  }
  getMapAt(keys) {
    let currentMap = this.map;
    let pair;
    if (!keys.length) {
      return this.map;
    }
    for (let i = 0, len = keys.length; i < len; i++) {
      const key = keys[i];
      pair = currentMap.get(key);
      if (!pair || !pair.map) {
        return void 0;
      }
      currentMap = pair.map;
    }
    return currentMap;
  }
  getAllChildrenSizeFor(keys) {
    let currentMap = this.map;
    let pair;
    if (!keys.length) {
      return this.length;
    }
    for (let i = 0, len = keys.length; i < len; i++) {
      const key = keys[i];
      pair = currentMap.get(key);
      if (!pair || !pair.map) {
        return 0;
      }
      currentMap = pair.map;
    }
    return pair.length;
  }
  getDirectChildrenSizeFor(keys) {
    let currentMap = this.map;
    if (!keys.length) {
      keys = [this.emptyKey];
    }
    for (let i = 0, len = keys.length; i < len; i++) {
      const key = keys[i];
      const last = i === len - 1;
      const pair = currentMap.get(key);
      if (!pair || !pair.map) {
        return 0;
      }
      currentMap = pair.map;
      if (last) {
        return currentMap?.size ?? 0;
      }
    }
    return 0;
  }
  set(keys, value) {
    let currentMap = this.map;
    if (!keys.length) {
      keys = [this.emptyKey];
    }
    for (let i = 0, len = keys.length; i < len; i++) {
      const key = keys[i];
      const last = i === len - 1;
      const pair = currentMap.get(key) || {
        length: 0
      };
      if (last) {
        pair.revision = this.revision++;
        pair.value = value;
        currentMap.set(key, pair);
        this.length++;
      } else {
        if (!pair.map) {
          pair.map = /* @__PURE__ */ new Map();
          currentMap.set(key, pair);
        }
        pair.length++;
        currentMap = pair.map;
      }
    }
    return this;
  }
  get(keys) {
    let currentMap = this.map;
    if (!keys.length) {
      keys = [this.emptyKey];
    }
    for (let i = 0, len = keys.length; i < len; i++) {
      const key = keys[i];
      const last = i === len - 1;
      const pair = currentMap.get(key);
      if (last) {
        return pair ? pair.value : void 0;
      } else {
        if (!pair || !pair.map) {
          return;
        }
        currentMap = pair.map;
      }
    }
    return;
  }
  get size() {
    return this.length;
  }
  clear() {
    const clearMap = (map2) => {
      map2.forEach((value, _key) => {
        const { map: map3 } = value;
        if (map3) {
          clearMap(map3);
        }
      });
      map2.clear();
    };
    clearMap(this.map);
    this.length = 0;
    this.revision = 0;
  }
  delete(keys) {
    let currentMap = this.map;
    if (!keys.length) {
      keys = [this.emptyKey];
    } else {
      keys = [...keys];
    }
    const maps = [currentMap];
    const pairs = [];
    let result = false;
    for (let i = 0, len = keys.length; i < len; i++) {
      const key = keys[i];
      const last = i === len - 1;
      const pair = currentMap.get(key);
      if (last) {
        if (pair) {
          if (pair.hasOwnProperty("value")) {
            delete pair.value;
            delete pair.revision;
            result = true;
            pairs.forEach((pair2) => {
              pair2.length--;
            });
            this.length--;
          }
          if (pair.map && pair.map.size === 0) {
            delete pair.map;
          }
          if (!pair.map) {
            currentMap.delete(key);
          }
        }
        break;
      } else {
        if (!pair || !pair.map) {
          result = false;
          break;
        }
        pairs.push(pair);
        currentMap = pair.map;
        maps.push(currentMap);
      }
    }
    while (maps.length) {
      const map2 = maps.pop();
      const keysLen = keys.length;
      keys.pop();
      if (keysLen > 0 && map2?.size === 0) {
        const parentMap = maps[maps.length - 1];
        const parentKey = keys[keys.length - 1];
        const pair = parentMap?.get(parentKey);
        if (pair) {
          delete pair.map;
          if (!pair.hasOwnProperty("value")) {
            parentMap.delete(parentKey);
          }
        }
      }
    }
    return result;
  }
  has(keys) {
    let currentMap = this.map;
    if (!keys.length) {
      keys = [this.emptyKey];
    }
    for (let i = 0, len = keys.length; i < len; i++) {
      const key = keys[i];
      const last = i === len - 1;
      const pair = currentMap.get(key);
      if (last) {
        return pair ? pair.hasOwnProperty("value") : false;
      } else {
        if (!pair || !pair.map) {
          return false;
        }
        currentMap = pair.map;
      }
    }
    return false;
  }
  visitKey(key, currentMap, parentKeys, fn, earlyReturn) {
    const pair = currentMap.get(key);
    if (!pair) {
      return;
    }
    const { map: map2 } = pair;
    const keys = key === this.emptyKey ? [] : [...parentKeys, key];
    const next = once(() => {
      if (map2) {
        for (const [k] of map2) {
          const res = this.visitKey(k, map2, keys, fn, earlyReturn);
          if (earlyReturn && res === true) {
            return true;
          }
        }
      }
      return false;
    });
    if (pair.hasOwnProperty("value")) {
      const res = fn(pair, keys, next);
      if (earlyReturn && res === true) {
        return true;
      }
    }
    next();
    return;
  }
  getArray(fn) {
    const result = [];
    this.visit((pair, keys) => {
      const res = fn({ ...pair, keys });
      if (keys.length === 0) {
        result.splice(0, 0, res);
      } else {
        result.push(res);
      }
    });
    return result;
  }
  rawKeysAt(keys) {
    const map2 = this.getMapAt(keys);
    if (!map2) {
      return [];
    }
    return [...map2.keys()];
  }
  valuesAt(keys) {
    const map2 = this.getMapAt(keys);
    if (!map2) {
      return [];
    }
    const result = [];
    map2.forEach((bag) => {
      if (bag.value !== void 0) {
        result.push(bag.value);
      }
    });
    return result;
  }
  values() {
    return this.sortedIterator((pair) => pair.value);
  }
  keys() {
    const keys = this.sortedIterator((pair) => pair.keys);
    return keys;
  }
  entries() {
    return this.sortedIterator((pair) => [
      pair.keys,
      pair.value
    ]);
  }
  topDownEntries() {
    return this.getArray((pair) => [
      pair.keys,
      pair.value
    ]);
  }
  topDownKeys() {
    return this.getArray((pair) => pair.keys);
  }
  topDownValues() {
    return this.getArray((pair) => pair.value);
  }
  sortedIterator(fn) {
    const result = [];
    this.visit((pair, keys) => {
      result.push({ ...pair, keys });
    });
    result.sort(SORT_ASC_REVISION);
    function* makeIterator() {
      for (let i = 0, len = result.length; i < len; i++) {
        yield fn(result[i]);
      }
    }
    return makeIterator();
  }
  // private iterator<ReturnType>(
  //   fn: (pair: Pair<KeyType, ValueType> & { keys: KeyType[] }) => ReturnType,
  // ) {
  //   const result: (Pair<KeyType, ValueType> & { keys: KeyType[] })[] = [];
  //   this.visit((pair, keys) => {
  //     result.push({ ...pair, keys });
  //   });
  //   function* makeIterator() {
  //     for (let i = 0, len = result.length; i < len; i++) {
  //       yield fn(result[i]);
  //     }
  //   }
  //   return makeIterator();
  // }
};
globalThis.DeepMap = DeepMap;

// src/utils/getGlobal.ts
function getGlobal() {
  return globalThis;
}

// src/utils/debugPackage.ts
var COLORS = [
  // '#0000CC',
  // '#0000FF',
  // '#0033CC',
  // '#0033FF',
  "#0066CC",
  "#0066FF",
  "#0099CC",
  "#0099FF",
  "#00CC00",
  "#00CC33",
  "#00CC66",
  "#00CC99",
  "#00CCCC",
  "#00CCFF",
  "#3300CC",
  "#3300FF",
  "#3333CC",
  "#3333FF",
  "#3366CC",
  "#3366FF",
  "#3399CC",
  "#3399FF",
  "#33CC00",
  "#33CC33",
  "#33CC66",
  "#33CC99",
  "#33CCCC",
  "#33CCFF",
  "#6600CC",
  "#6600FF",
  "#6633CC",
  "#6633FF",
  "#66CC00",
  "#66CC33",
  "#9900CC",
  "#9900FF",
  "#9933CC",
  "#9933FF",
  "#99CC00",
  "#99CC33",
  "#CC0000",
  "#CC0033",
  "#CC0066",
  "#CC0099",
  "#CC00CC",
  "#CC00FF",
  "#CC3300",
  "#CC3333",
  "#CC3366",
  "#CC3399",
  "#CC33CC",
  "#CC33FF",
  "#CC6600",
  "#CC6633",
  "#CC9900",
  "#CC9933",
  "#CCCC00",
  "#CCCC33",
  "#FF0000",
  "#FF0033",
  "#FF0066",
  "#FF0099",
  "#FF00CC",
  "#FF00FF",
  "#FF3300",
  "#FF3333",
  "#FF3366",
  "#FF3399",
  "#FF33CC",
  "#FF33FF",
  "#FF6600",
  "#FF6633",
  "#FF9900",
  "#FF9933",
  "#FFCC00",
  "#FFCC33"
];
var COLOR_SYMBOL = Symbol("color");
var USED_COLORS_MAP = /* @__PURE__ */ new WeakMap();
var GLOBAL_LOG_INTENT = buildSubscriptionCallback();
function initUsedColors(colors = COLORS) {
  USED_COLORS_MAP.set(
    colors,
    colors.map((_) => 0)
  );
}
initUsedColors();
var getNextColor = (colors = COLORS) => {
  let usedColors = [];
  if (USED_COLORS_MAP.has(colors)) {
    usedColors = USED_COLORS_MAP.get(colors);
  } else {
    usedColors = colors.map((_) => 0);
    USED_COLORS_MAP.set(colors, usedColors);
  }
  const index = usedColors.reduce(
    (iMin, x, i, arr) => x < arr[iMin] ? i : iMin,
    0
  );
  if (usedColors[index] != void 0) {
    usedColors[index]++;
  }
  return colors[index] ?? colors[0] ?? COLORS[0];
};
var CHANNEL_SEPARATOR = ":";
var CHANNEL_WILDCARD = "*";
var CHANNEL_NEGATION_CHAR = "-";
var STORAGE_SEPARATOR = ",";
var STORAGE_KEY = "debug";
var STORAGE_DIFF_KEY = "diffdebug";
var DEFAULT_LOG_DIFF = false;
var loggers = new DeepMap();
var enabledChannelsCache = /* @__PURE__ */ new Map();
function isChannelTargeted(channel, permissionToken) {
  const parts = channel.split(CHANNEL_SEPARATOR);
  const partsMap = new DeepMap();
  partsMap.set(parts, true);
  const tokenParts = permissionToken.split(CHANNEL_SEPARATOR);
  const hasWildcard = new Set(tokenParts).has(CHANNEL_WILDCARD);
  const indexOfToken = tokenParts.indexOf(CHANNEL_WILDCARD);
  const storagePartsWithoutWildcard = hasWildcard ? tokenParts.slice(0, indexOfToken) : tokenParts;
  if (partsMap.getKeysStartingWith(storagePartsWithoutWildcard, {
    excludeSelf: hasWildcard
  }).length > 0) {
    const remainingParts = tokenParts.slice(indexOfToken + 1);
    if (remainingParts.length) {
      return channel.endsWith(remainingParts.join(CHANNEL_SEPARATOR));
    }
    return true;
  }
  return void 0;
}
function isChannelEnabled(channel, permissions) {
  const cacheKey = `channel=${channel}_permissions=${permissions}`;
  if (enabledChannelsCache.has(cacheKey)) {
    return enabledChannelsCache.get(cacheKey);
  }
  const permissionTokens = permissions.split(STORAGE_SEPARATOR);
  function done(result) {
    enabledChannelsCache.set(cacheKey, result);
    return result;
  }
  const exactTokens = [];
  const wildcardTokens = [];
  permissionTokens.forEach((permissionToken) => {
    if (permissionToken.includes(CHANNEL_WILDCARD)) {
      wildcardTokens.push(permissionToken);
    } else {
      exactTokens.push(permissionToken);
    }
  });
  for (let i = 0; i < exactTokens.length; i++) {
    let exactToken = exactTokens[i];
    const negative = exactToken.startsWith(CHANNEL_NEGATION_CHAR);
    if (negative) {
      exactToken = exactToken.substring(CHANNEL_NEGATION_CHAR.length);
    }
    if (isChannelTargeted(channel, exactToken)) {
      return done(negative ? false : true);
    }
  }
  for (let i = 0; i < wildcardTokens.length; i++) {
    let permissionToken = wildcardTokens[i];
    const negated = permissionToken.startsWith("-");
    if (negated) {
      permissionToken = permissionToken.substring(1);
    }
    if (isChannelTargeted(channel, permissionToken)) {
      return done(negated ? false : true);
    }
  }
  return done(false);
}
var getStorageKeyValue = () => debug.enable ?? (getGlobal() && getGlobal().localStorage?.getItem(STORAGE_KEY)) ?? "";
var getDiffStorageKeyValue = () => debug.diffenable ?? (getGlobal() && getGlobal().localStorage?.getItem(STORAGE_DIFF_KEY)) ?? `${DEFAULT_LOG_DIFF}`;
var storageKeyValue = "";
var logDiffs = DEFAULT_LOG_DIFF;
function updateStorageKeyValue(value) {
  logDiffs = `${getDiffStorageKeyValue()}` == "true";
  if (storageKeyValue === value) {
    return;
  }
  storageKeyValue = value;
  enabledChannelsCache.clear();
}
function debugPackage(channelName) {
  updateStorageKeyValue(getStorageKeyValue());
  typeof getGlobal() !== "undefined" && getGlobal().addEventListener && getGlobal().addEventListener("storage", function() {
    updateStorageKeyValue(getStorageKeyValue());
  });
  function debugFactory(channelName2, parentChannel) {
    const channel = parentChannel ? `${parentChannel}${CHANNEL_SEPARATOR}${channelName2}` : channelName2;
    const channelParts = channel.split(CHANNEL_SEPARATOR);
    const foundLogger = loggers.get(channelParts);
    if (foundLogger) {
      return foundLogger;
    }
    const parentLogger = loggers.get(channelParts.slice(0, -1));
    const defaultLogFn = (parentLogger ? parentLogger.logFn : debug.logFn) ?? defaultLogger;
    let logFn = defaultLogFn;
    let enabled;
    let lastMessageTimestamp = 0;
    const isEnabled = () => enabled ?? isChannelEnabled(channel, storageKeyValue);
    const color = getNextColor(debug.colors);
    const logger2 = Object.defineProperties(
      (...args) => {
        const intentListenersCount = GLOBAL_LOG_INTENT.getListenersCount();
        let now;
        if (intentListenersCount > 0) {
          now = now ?? Date.now();
          GLOBAL_LOG_INTENT({
            color,
            channel,
            args,
            timestamp: now
          });
        }
        if (isEnabled()) {
          now = now ?? Date.now();
          if (lastMessageTimestamp && logDiffs) {
            const diff = now - lastMessageTimestamp;
            logFn(`%c[${channel}]`, `color: ${color}`, `+${diff}ms:`);
          }
          lastMessageTimestamp = now;
          const argsToLog = [];
          let textWithColors = void 0;
          args.forEach((arg) => {
            if (arg[COLOR_SYMBOL]) {
              if (textWithColors === void 0) {
                textWithColors = true;
              }
              argsToLog.push(...arg);
            } else {
              if (typeof arg !== "string" && typeof arg !== "number") {
                textWithColors = false;
                return;
              }
              argsToLog.push(`${arg}%s`);
            }
          });
          if (textWithColors) {
            const theArgs = [
              `%c[${channel}]%c %s`,
              `color: ${color}`,
              "",
              ...argsToLog,
              ""
            ];
            logFn(...theArgs);
          } else {
            logFn(`%c[${channel}]%c %s`, `color: ${color}`, "", ...args);
          }
        }
      },
      {
        channel: {
          value: channel
        },
        color: {
          value: (colorName, ...args) => {
            const result = [
              `%c${args.join(" ")}%c%s`,
              `color: ${colorName}`,
              ""
            ];
            result.toString = () => args.join(" ");
            result[COLOR_SYMBOL] = true;
            return result;
          }
        },
        extend: {
          value: (nextChannel) => {
            return debugFactory(nextChannel, channel);
          }
        },
        enabled: {
          get: () => isEnabled(),
          set: (value) => {
            enabled = value;
          }
        },
        logFn: {
          configurable: false,
          get: () => logFn,
          set: (fn) => {
            logFn = fn ?? defaultLogFn;
          }
        },
        destroy: {
          value: () => {
            loggers.delete(channelParts);
          }
        }
      }
    );
    loggers.set(channelParts, logger2);
    return logger2;
  }
  return debugFactory(channelName);
}
var defaultLogger = console.log.bind(console);
var GLOBAL_ENABLE = void 0;
Object.defineProperty(debugPackage, "enable", {
  get: () => GLOBAL_ENABLE,
  set: (value) => {
    GLOBAL_ENABLE = value;
    updateStorageKeyValue(getStorageKeyValue());
  }
});
var debug = debugPackage;
debug.colors = COLORS;
debug.logFn = defaultLogger;
var onLogIntentGlobal = (intentChannel, fn) => {
  return GLOBAL_LOG_INTENT.onChange((options) => {
    if (!options) {
      return;
    }
    const { channel, args, color, timestamp } = options;
    if (isChannelTargeted(channel, intentChannel)) {
      fn({
        channel,
        color,
        args,
        timestamp
      });
    }
  });
};
debug.onLogIntent = onLogIntentGlobal;
debug.isChannelEnabled = isChannelEnabled;
debug.destroyAll = () => {
  initUsedColors();
  initUsedColors(debug.colors);
  loggers.clear();
  enabledChannelsCache.clear();
};
if (false) {
  globalThis.debugPackage = debug;
}

// src/utils/debugLoggers.ts
var dbg = (channelName) => {
  const result = debug(
    channelName ? `IT:${channelName}:TYPE=debug` : "IT:TYPE=debug"
  );
  result.logFn = console.log.bind(console);
  return result;
};
var err = (channelName) => {
  const result = debug(
    channelName ? `IT:${channelName}:TYPE=error` : "IT:TYPE=error"
  );
  result.logFn = console.error.bind(console);
  return result;
};
var emptyLogFn = () => emptyLogFn;
emptyLogFn.extend = () => emptyLogFn;
var Logger = class {
  constructor(channelName) {
    this.debug = emptyLogFn;
    this.error = emptyLogFn;
    if (false) {
      this.debug = dbg(channelName);
      this.error = err(channelName);
    }
  }
};

// src/components/ResizeObserver/index.tsx
import * as React from "react";
import {
  useMemo,
  useRef,
  useEffect,
  useLayoutEffect,
  useCallback
} from "react";
var setupResizeObserver = (node, callback, config = { debounce: 0 }) => {
  const debounceTime = config.debounce ?? 0;
  const RO = window.ResizeObserver;
  const onResizeCallback = debounceTime ? debounce(callback, { wait: debounceTime }) : callback;
  const observer = new RO((entries) => {
    const entry = entries[0];
    let { width, height: height2 } = entry.contentRect;
    if (entry.borderBoxSize?.[0]) {
      height2 = entry.borderBoxSize[0].blockSize;
      width = entry.borderBoxSize[0].inlineSize;
    } else {
      const rect = node.getBoundingClientRect();
      height2 = rect.height;
      width = rect.width;
    }
    onResizeCallback({ width, height: height2 });
  });
  observer.observe(node);
  return () => {
    observer.disconnect();
  };
};
var useResizeObserver = (ref, callback, config = {
  earlyAttach: false,
  debounce: 0
}) => {
  const sizeRef = useRef({
    width: 0,
    height: 0
  });
  const effectFn = (callback2) => {
    let disconnect;
    if (ref.current) {
      disconnect = setupResizeObserver(
        ref.current,
        (size) => {
          size = {
            width: Math.round(size.width),
            height: Math.round(size.height)
          };
          const prevSize = sizeRef.current;
          if (prevSize.width !== size.width || prevSize.height !== size.height) {
            sizeRef.current = size;
            callback2(size);
          }
        },
        { debounce: config.debounce }
      );
    }
    return () => {
      if (disconnect) {
        disconnect();
      }
    };
  };
  useEffect(() => {
    if (!config.earlyAttach) {
      return effectFn(callback);
    }
    return () => {
    };
  }, [ref.current, callback, config.earlyAttach, config.debounce]);
  useLayoutEffect(() => {
    if (config.earlyAttach) {
      return effectFn(callback);
    }
    return () => {
    };
  }, [ref.current, callback, config.earlyAttach]);
};

// src/components/CSSNumericVariableWatch.tsx
var error = err("CSSVariableWatch");
var debug2 = dbg("CSSVariableWatch");
var WRAPPER_STYLE = {
  position: "absolute",
  pointerEvents: "none",
  width: 0,
  height: 0,
  lineHeight: 0,
  fontSize: 0,
  overflow: "hidden"
};
var useCSSVariableWatch = (params) => {
  const lastValueRef = useRef2(0);
  const onResize = React2.useCallback(
    ({ height: height2 }) => {
      if (height2 != null && height2 !== lastValueRef.current) {
        lastValueRef.current = height2;
        params.onChange(height2);
      }
    },
    [params.onChange]
  );
  useResizeObserver(params.ref, onResize, { earlyAttach: true });
  React2.useLayoutEffect(() => {
    const value = params.ref.current.getBoundingClientRect().height;
    if (value != null) {
      lastValueRef.current = value;
      debug2(`Variable ${params.varName} found and equals ${value}.`);
      return params.onChange(value);
    } else {
      error(
        `Specified variable ${params.varName} not found or does not have a numeric value.`
      );
    }
  }, []);
};
var CSSNumericVariableWatch = (props) => {
  const domRef = useRef2(null);
  useCSSVariableWatch({
    ...props,
    ref: domRef
  });
  const height2 = props.varName.startsWith("var(") ? props.varName : `var(${props.varName})`;
  const { allowInts = false } = props;
  return /* @__PURE__ */ React2.createElement(
    "div",
    {
      "data-name": "css-variable-watcher",
      "data-var": props.varName,
      style: WRAPPER_STYLE
    },
    /* @__PURE__ */ React2.createElement(
      "div",
      {
        ref: domRef,
        style: {
          height: allowInts ? `calc(1px * ${height2})` : height2
          // we do multiplication in order to support integer (without px) values as well
        }
      }
    )
  );
};

// src/components/DataSource/publicHooks/useDataSourceMasterDetailSelector.ts
import { useCallback as useCallback4, useContext } from "react";

// src/utils/ComponentStore.ts
import { useCallback as useCallback3, useRef as useRef3, useSyncExternalStore } from "react";

// src/utils/shallowEqualObjects.ts
function shallowEqualObjects(objA, objB, ignoreKeys) {
  if (objA === objB) {
    return true;
  }
  if (!objA || !objB) {
    return false;
  }
  const typeA = typeof objA;
  const typeB = typeof objB;
  if (typeA !== typeB) {
    return false;
  }
  if (typeA !== "object") {
    return false;
  }
  var aKeys = Object.keys(objA);
  var bKeys = Object.keys(objB);
  if (ignoreKeys) {
    aKeys = aKeys.filter((key2) => !ignoreKeys.has(key2));
    bKeys = bKeys.filter((key2) => !ignoreKeys.has(key2));
  }
  var len = aKeys.length;
  if (bKeys.length !== len) {
    return false;
  }
  for (var i = 0; i < len; i++) {
    var key = aKeys[i];
    if (ignoreKeys) {
      if (ignoreKeys.has(key)) {
        continue;
      }
    }
    if (objA[key] !== objB[key] || !Object.prototype.hasOwnProperty.call(objB, key)) {
      return false;
    }
  }
  return true;
}

// src/utils/ComponentStore.ts
function createComponentStore() {
  let snapshot = null;
  const listeners = /* @__PURE__ */ new Set();
  return {
    getSnapshot() {
      return snapshot;
    },
    setSnapshot(value) {
      snapshot = value;
    },
    subscribe(listener) {
      listeners.add(listener);
      return () => {
        listeners.delete(listener);
      };
    },
    notify() {
      for (const listener of listeners) {
        listener();
      }
    }
  };
}
function useComponentStoreSelectorImpl(store, selector2, isEqual) {
  const selectorRef = useRef3(selector2);
  selectorRef.current = selector2;
  const isEqualRef = useRef3(isEqual);
  isEqualRef.current = isEqual;
  const resultRef = useRef3(void 0);
  const initializedRef = useRef3(false);
  const getSnapshot = useCallback3(() => {
    const snapshot = store.getSnapshot();
    const nextResult = selectorRef.current(snapshot);
    if (initializedRef.current && isEqualRef.current(resultRef.current, nextResult)) {
      return resultRef.current;
    }
    resultRef.current = nextResult;
    initializedRef.current = true;
    return nextResult;
  }, [store]);
  return useSyncExternalStore(store.subscribe, getSnapshot, getSnapshot);
}
function useComponentStoreSingleValue(componentStore, selector2) {
  return useComponentStoreSelectorImpl(componentStore, selector2, Object.is);
}
function useComponentStoreSelector(componentStore, selector2) {
  return useComponentStoreSelectorImpl(
    componentStore,
    selector2,
    shallowEqualObjects
  );
}

// src/components/DataSource/DataSourceMasterDetailContext.ts
import * as React3 from "react";
var DSMasterDetailStoreContext;
function getDataSourceMasterDetailStoreContext() {
  if (DSMasterDetailStoreContext) {
    return DSMasterDetailStoreContext;
  }
  return DSMasterDetailStoreContext = React3.createContext(null);
}

// src/components/DataSource/publicHooks/useDataSourceMasterDetailSelector.ts
var NOOP_STORE = createComponentStore();
var NOOP_SELECTOR = () => void 0;
function useMasterDetailStore() {
  const StoreContext = getDataSourceMasterDetailStoreContext();
  const store = useContext(StoreContext);
  return store || void 0;
}
function useGetMasterDetailContext() {
  const store = useMasterDetailStore();
  return useCallback4(() => store?.getSnapshot(), [store]);
}
function useDataSourceMasterDetailSelector(selector2) {
  const StoreContext = getDataSourceMasterDetailStoreContext();
  const store = useContext(StoreContext);
  const result = useComponentStoreSelector(
    store || NOOP_STORE,
    store ? selector2 : NOOP_SELECTOR
  );
  return store ? result ?? void 0 : void 0;
}
function useMasterRowInfo() {
  const StoreContext = getDataSourceMasterDetailStoreContext();
  const store = useContext(StoreContext);
  const masterRowInfoSelector = store ? (ctx) => ctx.masterRowInfo : NOOP_SELECTOR;
  const result = useComponentStoreSingleValue(
    store || NOOP_STORE,
    masterRowInfoSelector
  );
  return store ? result : void 0;
}

// src/components/hooks/useComponentState/index.tsx
import * as React4 from "react";
import {
  useReducer,
  createContext as createContext2,
  useMemo as useMemo2,
  useEffect as useEffect3,
  useState as useState2,
  useRef as useRef7,
  useLayoutEffect as useLayoutEffect4
} from "react";

// src/utils/proxyFnCall.ts
function proxyFn(fn, config) {
  const propertyReads = /* @__PURE__ */ new Set();
  function proxiedFn(...params) {
    const paramToProxy = config ? config.getProxyTargetFromArgs(...params) : params[0];
    propertyReads.clear();
    const handler = {
      get: function(obj, prop) {
        propertyReads.add(prop);
        return obj[prop];
      }
    };
    const proxy = new Proxy(
      paramToProxy,
      handler
    );
    const newParams = config ? config.putProxyToArgs(proxy, ...params) : [proxy];
    return fn.apply(this, newParams);
  }
  return {
    fn: proxiedFn,
    propertyReads
  };
}

// src/utils/toUpperFirst.ts
var toUpperFirst = (s) => {
  return s ? s.substr(0, 1).toUpperCase() + s.substr(1) : s;
};

// src/components/InfiniteTable/types/Utility.ts
function notNullable(value) {
  if (value === null || value === void 0) return false;
  const testDummyForCompileError = value;
  return true;
}

// src/components/utils/isControlledValue.ts
function isControlledValue(value) {
  const controlled = value !== void 0;
  return controlled;
}

// src/components/utils/isControlled.ts
function isControlled(propName, props) {
  const propValue = props[propName];
  const controlled = isControlledValue(propValue);
  return controlled;
}

// src/components/hooks/useEffectOnceWithProperUnmount.ts
import { useCallback as useCallback6, useEffect as useEffect2, useRef as useRef4 } from "react";

// src/components/hooks/useRerender.ts
import { useCallback as useCallback5, useState } from "react";
var useRerender = () => {
  const [state, setState] = useState(0);
  return [
    state,
    useCallback5(() => {
      setState((state2) => state2 + 1);
    }, [setState])
  ];
};

// src/components/hooks/useEffectOnceWithProperUnmount.ts
var useEffectOnce = (effectCallback) => {
  const effectFunction = useCallback6(effectCallback, []);
  const effectCalled = useRef4(false);
  const componentRendered = useRef4(false);
  const destroyFn = useRef4(void 0);
  const [_, rerender] = useRerender();
  if (effectCalled.current) {
    componentRendered.current = true;
  }
  useEffect2(() => {
    if (!effectCalled.current) {
      destroyFn.current = effectFunction;
      effectCalled.current = true;
    }
    rerender();
    return () => {
      if (!componentRendered.current) {
        return;
      }
      if (destroyFn.current) {
        destroyFn.current();
      }
    };
  }, []);
};

// src/components/hooks/useLatest.tsx
import { useCallback as useCallback7, useRef as useRef5 } from "react";
function useLatest(value) {
  const ref = useRef5(value);
  ref.current = value;
  return useCallback7(() => ref.current, []);
}

// src/components/hooks/usePrevious.ts
import { useRef as useRef6, useLayoutEffect as useLayoutEffect3 } from "react";
var usePrevious = (value, initialValue) => {
  const ref = useRef6(initialValue === void 0 ? value : initialValue);
  useLayoutEffect3(() => {
    ref.current = value;
  });
  return ref.current;
};

// src/utils/devTools/devToolsTracks.ts
var DevToolsTracks = {
  DataSource: {
    track: "DataSource",
    labels: {
      RemoteDataLoad: "Remote data load",
      TreeUnfilteredTreePaths: "Computing unfiltered tree paths",
      Filter: "Filter",
      Sort: "Sort",
      Group: "Group",
      LazyGroup: "Lazy group",
      Tree: "Tree",
      FlattenTree: "Flatten tree",
      Flatten: "Flatten groups",
      PrepareData: "Preparing data",
      ComputeSelectionCount: "Computing selection count",
      ComputeSelectionCountLazy: "Computing selection count (lazy)",
      PrepareRowInfo: "Preparing row info array",
      DiffRowInfoInStore: "setDataArray diffing in RowInfoStore"
    }
  },
  InfiniteTable: {
    track: "InfiniteTable",
    labels: {
      Render: "Rendering"
    }
  },
  MatrixBrain: {
    track: "Layout Computations",
    labels: {
      ComputeRenderRange: "Computing render range"
    }
  },
  ComponentState: {
    track: "ComponentState",
    labels: {
      PropUpdate: "Prop update"
    }
  }
};

// src/utils/devTools/index.ts
var DevToolsMarker = class _DevToolsMarker {
  constructor(debugId) {
    this.debugId = debugId;
    this.markerDetails = {
      label: "",
      track: "",
      trackGroup: void 0,
      color: void 0,
      details: [],
      tooltip: void 0
    };
    this.stopped = false;
    this.start = (startDetails) => {
      if (this.markerDetails.startTs) {
        return this;
      }
      const start = performance.now();
      this.markerDetails.details = startDetails?.details ?? [];
      this.markerDetails.startTs = start;
      return this;
    };
    this.end = (markerDetails = {}) => {
      if (this.stopped) {
        return this;
      }
      this.stopped = true;
      const start = markerDetails.startTs ?? this.markerDetails.startTs;
      const end = markerDetails.endTs ?? this.markerDetails.endTs ?? performance.now();
      const color = markerDetails.color || this.markerDetails.color || "primary";
      const trackGroup = markerDetails.trackGroup || this.markerDetails.trackGroup || `Infinite Table (${this.debugId})`;
      const details = [
        ...this.markerDetails.details || [],
        ...markerDetails.details || []
      ];
      const tooltip = markerDetails.tooltip || this.markerDetails.tooltip;
      const label = markerDetails.label || this.markerDetails.label || "Unknown";
      const track = markerDetails.track || this.markerDetails.track || "Unknown";
      performance.measure(label, {
        start,
        end,
        detail: {
          devtools: {
            dataType: "track-entry",
            trackGroup,
            track,
            color,
            properties: details.length > 0 ? details.map((detail) => [detail.name, detail.value]) : void 0,
            tooltipText: tooltip
          }
        }
      });
      return this;
    };
    this.debugId = debugId;
  }
  static create(debugId) {
    return new _DevToolsMarker(debugId);
  }
  get startTimestamp() {
    return this.markerDetails.startTs;
  }
  get track() {
    const self = this;
    return Object.keys(DevToolsTracks).reduce(
      (acc, track) => {
        const trackObj = {
          start: self.start,
          end: (markerDetails) => {
            return self.end({
              ...markerDetails,
              track: DevToolsTracks[track].track,
              label: markerDetails.label
            });
          },
          get label() {
            const currentTrack = DevToolsTracks[track];
            return Object.keys(currentTrack.labels).reduce(
              (labelAcc, label) => {
                const labelObj = {
                  start: self.start,
                  end: (markerDetails) => {
                    return self.end({
                      ...markerDetails,
                      track: currentTrack.track,
                      label: currentTrack.labels[label]
                    });
                  }
                };
                Object.defineProperty(labelAcc, label, {
                  get: () => {
                    self.markerDetails.label = currentTrack.labels[label];
                    return labelObj;
                  }
                });
                return labelAcc;
              },
              {}
            );
          }
        };
        Object.defineProperty(acc, track, {
          get: () => {
            const currentTrack = DevToolsTracks[track];
            self.markerDetails.track = currentTrack.track;
            return trackObj;
          }
        });
        return acc;
      },
      {}
    );
  }
};
function getMarker(debugId) {
  return DevToolsMarker.create(debugId);
}

// src/components/hooks/useComponentState/index.tsx
var notifyChange = (props, callbackPropName, values) => {
  const callbackProp = props[callbackPropName];
  if (typeof callbackProp === "function") {
    callbackProp(...values);
  }
};
var ComponentContext;
function getComponentStateContext() {
  if (ComponentContext) {
    return ComponentContext;
  }
  return ComponentContext = createContext2(null);
}
function getReducerGeneratedActions(dispatch, getState, getProps, propsToForward, allowedControlledPropOverrides, interceptedActions, mappedCallbacks) {
  const state = getState();
  return Object.keys(state).reduce((actions, stateKey) => {
    const key = stateKey;
    const setter = (value) => {
      const props = getProps();
      const state2 = getState();
      const currentValue = state2[key];
      if (currentValue === value) {
      }
      let notifyTheChange = true;
      if (interceptedActions && typeof interceptedActions[key] === "function") {
        if (interceptedActions[key](value, { actions, state: state2 }) === false) {
          notifyTheChange = false;
        }
      }
      if (notifyTheChange) {
        let callbackParams = [value];
        let callbackName = `on${toUpperFirst(stateKey)}Change`;
        if (mappedCallbacks && mappedCallbacks[key]) {
          const res = mappedCallbacks[key](value, state2);
          callbackName = res.callbackName || callbackName;
          callbackParams = res.callbackParams;
        }
        notifyChange(props, callbackName, callbackParams);
      }
      const forwardFn = propsToForward[key];
      if (typeof forwardFn === "function") {
        value = forwardFn(value);
      }
      const allowControlled = !!allowedControlledPropOverrides?.[key];
      if (isControlled(stateKey, props) && !allowControlled) {
        return;
      }
      dispatch({
        payload: {
          updatedProps: null,
          mappedState: {
            [stateKey]: value
          }
        }
      });
    };
    Object.defineProperty(actions, stateKey, {
      set: setter
    });
    return actions;
  }, {});
}
function forwardProps(propsToForward, props, setupState) {
  const mappedState = {};
  for (let k in propsToForward)
    if (propsToForward.hasOwnProperty(k)) {
      const forwardFn = propsToForward[k];
      let propValue = isControlled(k, props) ? props[k] : props[`default${toUpperFirst(k)}`];
      if (typeof forwardFn === "function") {
        propValue = forwardFn(propValue, setupState);
      }
      mappedState[k] = propValue;
    }
  return mappedState;
}
function buildManagedComponent(config) {
  const useParentStateFn = config.getParentState || (() => null);
  function useManagedComponent(props) {
    const [initialSetupState] = useState2(() => {
      return config.initSetupState ? config.initSetupState(props) : {};
    });
    const propsToStateSetRef = useRef7(/* @__PURE__ */ new Set());
    const propsToForward = useMemo2(
      () => config.forwardProps ? config.forwardProps(initialSetupState, props) : {},
      [initialSetupState]
    );
    const parentState = useParentStateFn();
    const getParentState = useLatest(parentState);
    function initStateOnce() {
      let mappedState = {};
      if (propsToForward) {
        mappedState = forwardProps(propsToForward, props, initialSetupState);
      }
      const state2 = { ...initialSetupState, ...mappedState };
      if (config.mapPropsToState) {
        const { fn: mapPropsToState2, propertyReads } = proxyFn(
          config.mapPropsToState,
          {
            getProxyTargetFromArgs: (initialArg) => initialArg.props,
            putProxyToArgs: (props2, initialArg) => {
              return [{ ...initialArg, props: props2 }];
            }
          }
        );
        const stateFromProps = mapPropsToState2({
          props,
          state: state2,
          oldState: null,
          parentState
          // getState: getComponentState,
        });
        propsToStateSetRef.current = /* @__PURE__ */ new Set([
          ...propsToStateSetRef.current,
          ...propertyReads
        ]);
        return {
          ...state2,
          ...stateFromProps
        };
      }
      return state2;
    }
    const [wholeState] = useState2(initStateOnce);
    const getProps = useLatest(props);
    const theReducer = (previousState, action) => {
      if (action.type === "REPLACE_STATE") {
        return action.payload;
      }
      const parentState2 = getParentState?.() ?? null;
      const mappedState = action.payload.mappedState;
      const updatedProps = action.payload.updatedPropsToState;
      const newState = { ...previousState };
      if (mappedState) {
        Object.assign(newState, mappedState);
      }
      if (config.mapPropsToState) {
        const { fn: mapPropsToState2, propertyReads } = proxyFn(
          config.mapPropsToState,
          {
            getProxyTargetFromArgs: (initialArg) => initialArg.props,
            putProxyToArgs: (props2, initialArg) => {
              return [{ ...initialArg, props: props2 }];
            }
          }
        );
        const stateFromProps = mapPropsToState2({
          props: getProps(),
          state: newState,
          oldState: previousState,
          parentState: parentState2
          // getState: getComponentState
        });
        propsToStateSetRef.current = /* @__PURE__ */ new Set([
          ...propsToStateSetRef.current,
          ...propertyReads
        ]);
        Object.assign(newState, stateFromProps);
      }
      if (action.type === "