@ni/ok-components 1.9.0 → 1.9.1

package/dist/all-components-bundle.js

@@ -108,12 +108,10 @@
       try {
           // Hopefully we never get here...
           // Not all environments allow eval and Function. Use only as a last resort:
-          // eslint-disable-next-line no-new-func
           return new Function("return this")();
       }
       catch {
           // If all fails, give up and create an object.
-          // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
           return {};
       }
   })();
@@ -194,6 +192,17 @@
           ...propConfig,
       });
   }
+  /**
+   * Core services shared across FAST instances.
+   * @internal
+   */
+  var KernelServiceId;
+  (function (KernelServiceId) {
+      KernelServiceId[KernelServiceId["updateQueue"] = 1] = "updateQueue";
+      KernelServiceId[KernelServiceId["observable"] = 2] = "observable";
+      KernelServiceId[KernelServiceId["contextEvent"] = 3] = "contextEvent";
+      KernelServiceId[KernelServiceId["elementRegistry"] = 4] = "elementRegistry";
+  })(KernelServiceId || (KernelServiceId = {}));
   /**
    * A readonly, empty array.
    * @remarks
@@ -224,7 +233,7 @@
       };
   }
 
-  const updateQueue = $global.FAST.getById(1 /* KernelServiceId.updateQueue */, () => {
+  const updateQueue = $global.FAST.getById(KernelServiceId.updateQueue, () => {
       const tasks = [];
       const pendingErrors = [];
       function throwFirstError() {
@@ -275,11 +284,9 @@
           process,
       });
   });
-  /* eslint-disable */
   const fastHTMLPolicy = $global.trustedTypes.createPolicy("fast-html", {
       createHTML: html => html,
   });
-  /* eslint-enable */
   let htmlPolicy = fastHTMLPolicy;
   const marker = `fast-${Math.random().toString(36).substring(2, 8)}`;
   /** @internal */
@@ -610,7 +617,7 @@
    * Common Observable APIs.
    * @public
    */
-  const Observable = FAST.getById(2 /* KernelServiceId.observable */, () => {
+  const Observable = FAST.getById(KernelServiceId.observable, () => {
       const volatileRegex = /(\?\?|:|&&|\|\||if)/;
       const notifierLookup = new WeakMap();
       const queueUpdate = DOM.queueUpdate;
@@ -864,7 +871,7 @@
           },
       });
   }
-  const contextEvent = FAST.getById(3 /* KernelServiceId.contextEvent */, () => {
+  const contextEvent = FAST.getById(KernelServiceId.contextEvent, () => {
       let current = null;
       return {
           get() {
@@ -1821,7 +1828,9 @@
   function separateSheetsToPrepend(sheets) {
       const prepend = [];
       const append = [];
-      sheets.forEach(x => (x[prependToAdoptedStyleSheetsSymbol] ? prepend : append).push(x));
+      sheets.forEach(x => 
+      // @ts-expect-error
+      (x[prependToAdoptedStyleSheetsSymbol] ? prepend : append).push(x));
       return { prepend, append };
   }
   let addAdoptedStyleSheets = (target, sheets) => {
@@ -2035,15 +2044,18 @@
        * @param value - The value to set the attribute/property to.
        */
       setValue(source, newValue) {
+          // @ts-expect-error
           const oldValue = source[this.fieldName];
           const converter = this.converter;
           if (converter !== void 0) {
               newValue = converter.fromView(newValue);
           }
           if (oldValue !== newValue) {
+              // @ts-expect-error
               source[this.fieldName] = newValue;
               this.tryReflectToAttribute(source);
               if (this.hasCallback) {
+                  // @ts-expect-error
                   source[this.callbackName](oldValue, newValue);
               }
               source.$fastController.notify(this.name);
@@ -2055,6 +2067,7 @@
        */
       getValue(source) {
           Observable.track(source, this.name);
+          // @ts-expect-error
           return source[this.fieldName];
       }
       /** @internal */
@@ -2074,6 +2087,7 @@
           }
           DOM.queueUpdate(() => {
               guards.add(element);
+              // @ts-expect-error
               const latestValue = element[this.fieldName];
               switch (mode) {
                   case "reflect":
@@ -2143,7 +2157,7 @@
 
   const defaultShadowOptions = { mode: "open" };
   const defaultElementOptions = {};
-  const fastRegistry = FAST.getById(4 /* KernelServiceId.elementRegistry */, () => {
+  const fastRegistry = FAST.getById(KernelServiceId.elementRegistry, () => {
       const typeToDefinition = new Map();
       return Object.freeze({
           register(definition) {
@@ -2613,11 +2627,9 @@
       }
   }
 
-  /* eslint-disable-next-line @typescript-eslint/explicit-function-return-type */
   function createFASTElement(BaseType) {
       return class extends BaseType {
           constructor() {
-              /* eslint-disable-next-line */
               super();
               Controller.forCustomElement(this);
           }
@@ -3178,7 +3190,6 @@
       }
   }
   /* eslint-disable prefer-rest-params */
-  /* eslint-disable @typescript-eslint/explicit-function-return-type */
   /**
    * Enables the array observation mechanism.
    * @remarks
@@ -3282,7 +3293,6 @@
       };
   }
   /* eslint-enable prefer-rest-params */
-  /* eslint-enable @typescript-eslint/explicit-function-return-type */
 
   /**
    * The runtime behavior for template references.
@@ -3310,7 +3320,6 @@
        * Unbinds this behavior from the source.
        * @param source - The source to unbind from.
        */
-      /* eslint-disable-next-line @typescript-eslint/no-empty-function */
       unbind() { }
   }
   /**
@@ -3917,7 +3926,7 @@
        * @returns The resolver.
        */
       instance(value) {
-          return this.registerResolver(0 /* ResolverStrategy.instance */, value);
+          return this.registerResolver(ResolverStrategy.instance, value);
       }
       /**
        * Creates a resolver that enforces a singleton lifetime.
@@ -3925,7 +3934,7 @@
        * @returns The resolver.
        */
       singleton(value) {
-          return this.registerResolver(1 /* ResolverStrategy.singleton */, value);
+          return this.registerResolver(ResolverStrategy.singleton, value);
       }
       /**
        * Creates a resolver that creates a new instance for every dependency request.
@@ -3933,7 +3942,7 @@
        * @returns - The resolver.
        */
       transient(value) {
-          return this.registerResolver(2 /* ResolverStrategy.transient */, value);
+          return this.registerResolver(ResolverStrategy.transient, value);
       }
       /**
        * Creates a resolver that invokes a callback function for every dependency resolution
@@ -3942,7 +3951,7 @@
        * @returns The resolver.
        */
       callback(value) {
-          return this.registerResolver(3 /* ResolverStrategy.callback */, value);
+          return this.registerResolver(ResolverStrategy.callback, value);
       }
       /**
        * Creates a resolver that invokes a callback function the first time that a dependency
@@ -3952,7 +3961,7 @@
        * @returns The resolver.
        */
       cachedCallback(value) {
-          return this.registerResolver(3 /* ResolverStrategy.callback */, cacheCallbackResult(value));
+          return this.registerResolver(ResolverStrategy.callback, cacheCallbackResult(value));
       }
       /**
        * Aliases the current key to a different key.
@@ -3960,11 +3969,10 @@
        * @returns The resolver.
        */
       aliasTo(destinationKey) {
-          return this.registerResolver(5 /* ResolverStrategy.alias */, destinationKey);
+          return this.registerResolver(ResolverStrategy.alias, destinationKey);
       }
       registerResolver(strategy, state) {
           const { container, key } = this;
-          /* eslint-disable-next-line @typescript-eslint/no-non-null-assertion */
           this.container = this.key = (void 0);
           return container.registerResolver(key, new ResolverImpl(key, strategy, state));
       }
@@ -4000,7 +4008,7 @@
        * @returns The resolver.
        */
       singleton(key) {
-          return new ResolverImpl(key, 1 /* ResolverStrategy.singleton */, key);
+          return new ResolverImpl(key, ResolverStrategy.singleton, key);
       },
       /**
        * Provides default transient resolution behavior during auto-registration.
@@ -4008,7 +4016,7 @@
        * @returns The resolver.
        */
       transient(key) {
-          return new ResolverImpl(key, 2 /* ResolverStrategy.transient */, key);
+          return new ResolverImpl(key, ResolverStrategy.transient, key);
       },
   });
   /**
@@ -4230,8 +4238,10 @@
                           const handleChange = () => {
                               const newContainer = DI.findResponsibleContainer(this);
                               const newValue = newContainer.get(key);
+                              // @ts-expect-error
                               const oldValue = this[diPropertyKey];
                               if (newValue !== oldValue) {
+                                  // @ts-expect-error
                                   this[diPropertyKey] = value;
                                   notifier.notify(propertyName);
                               }
@@ -4414,6 +4424,16 @@
   DI.inject;
   const defaultSingletonOptions = { scoped: false };
   /** @internal */
+  var ResolverStrategy;
+  (function (ResolverStrategy) {
+      ResolverStrategy[ResolverStrategy["instance"] = 0] = "instance";
+      ResolverStrategy[ResolverStrategy["singleton"] = 1] = "singleton";
+      ResolverStrategy[ResolverStrategy["transient"] = 2] = "transient";
+      ResolverStrategy[ResolverStrategy["callback"] = 3] = "callback";
+      ResolverStrategy[ResolverStrategy["array"] = 4] = "array";
+      ResolverStrategy[ResolverStrategy["alias"] = 5] = "alias";
+  })(ResolverStrategy || (ResolverStrategy = {}));
+  /** @internal */
   class ResolverImpl {
       constructor(key, strategy, state) {
           this.key = key;
@@ -4429,9 +4449,9 @@
       }
       resolve(handler, requestor) {
           switch (this.strategy) {
-              case 0 /* ResolverStrategy.instance */:
+              case ResolverStrategy.instance:
                   return this.state;
-              case 1 /* ResolverStrategy.singleton */: {
+              case ResolverStrategy.singleton: {
                   if (this.resolving) {
                       throw new Error(`Cyclic dependency found: ${this.state.name}`);
                   }
@@ -4439,11 +4459,11 @@
                   this.state = handler
                       .getFactory(this.state)
                       .construct(requestor);
-                  this.strategy = 0 /* ResolverStrategy.instance */;
+                  this.strategy = ResolverStrategy.instance;
                   this.resolving = false;
                   return this.state;
               }
-              case 2 /* ResolverStrategy.transient */: {
+              case ResolverStrategy.transient: {
                   // Always create transients from the requesting container
                   const factory = handler.getFactory(this.state);
                   if (factory === null) {
@@ -4451,11 +4471,11 @@
                   }
                   return factory.construct(requestor);
               }
-              case 3 /* ResolverStrategy.callback */:
+              case ResolverStrategy.callback:
                   return this.state(handler, requestor, this);
-              case 4 /* ResolverStrategy.array */:
+              case ResolverStrategy.array:
                   return this.state[0].resolve(handler, requestor);
-              case 5 /* ResolverStrategy.alias */:
+              case ResolverStrategy.alias:
                   return requestor.get(this.state);
               default:
                   throw new Error(`Invalid resolver strategy specified: ${this.strategy}.`);
@@ -4463,10 +4483,10 @@
       }
       getFactory(container) {
           switch (this.strategy) {
-              case 1 /* ResolverStrategy.singleton */:
-              case 2 /* ResolverStrategy.transient */:
+              case ResolverStrategy.singleton:
+              case ResolverStrategy.transient:
                   return container.getFactory(this.state);
-              case 5 /* ResolverStrategy.alias */:
+              case ResolverStrategy.alias:
                   return container.getResolver(this.state)?.getFactory?.(container) ?? null;
               default:
                   return null;
@@ -4653,11 +4673,11 @@
               resolvers.set(key, resolver);
           }
           else if (result instanceof ResolverImpl &&
-              result.strategy === 4 /* ResolverStrategy.array */) {
+              result.strategy === ResolverStrategy.array) {
               result.state.push(resolver);
           }
           else {
-              resolvers.set(key, new ResolverImpl(key, 4 /* ResolverStrategy.array */, [result, resolver]));
+              resolvers.set(key, new ResolverImpl(key, ResolverStrategy.array, [result, resolver]));
           }
           return resolver;
       }
@@ -4749,9 +4769,7 @@
               while (current != null) {
                   resolver = current.resolvers.get(key);
                   if (resolver != null) {
-                      resolutions = resolutions.concat(
-                      /* eslint-disable-next-line @typescript-eslint/no-non-null-assertion */
-                      buildAllResponse(resolver, current, requestor));
+                      resolutions = resolutions.concat(buildAllResponse(resolver, current, requestor));
                   }
                   current = current.parent;
               }
@@ -4857,7 +4875,7 @@
        * @param value - The instance to return when the key is requested.
        */
       instance(key, value) {
-          return new ResolverImpl(key, 0 /* ResolverStrategy.instance */, value);
+          return new ResolverImpl(key, ResolverStrategy.instance, value);
       },
       /**
        * Creates an instance from the class.
@@ -4872,7 +4890,7 @@
        * @param value - The class to instantiate as a singleton when first requested.
        */
       singleton(key, value) {
-          return new ResolverImpl(key, 1 /* ResolverStrategy.singleton */, value);
+          return new ResolverImpl(key, ResolverStrategy.singleton, value);
       },
       /**
        * Creates an instance from a class.
@@ -4887,7 +4905,7 @@
        * @param value - The class to instantiate each time the key is requested.
        */
       transient(key, value) {
-          return new ResolverImpl(key, 2 /* ResolverStrategy.transient */, value);
+          return new ResolverImpl(key, ResolverStrategy.transient, value);
       },
       /**
        * Delegates to a callback function to provide the dependency.
@@ -4904,7 +4922,7 @@
        * @param callback - The function that is expected to return the dependency.
        */
       callback(key, callback) {
-          return new ResolverImpl(key, 3 /* ResolverStrategy.callback */, callback);
+          return new ResolverImpl(key, ResolverStrategy.callback, callback);
       },
       /**
        * Delegates to a callback function to provide the dependency and then caches the
@@ -4923,7 +4941,7 @@
        * Should all references to the resolver returned be removed, the cache will expire.
        */
       cachedCallback(key, callback) {
-          return new ResolverImpl(key, 3 /* ResolverStrategy.callback */, cacheCallbackResult(callback));
+          return new ResolverImpl(key, ResolverStrategy.callback, cacheCallbackResult(callback));
       },
       /**
        * Creates an alternate {@link Key} to retrieve an instance by.
@@ -4940,7 +4958,7 @@
        * @param aliasKey - The alias to the original key.
        */
       aliasTo(originalKey, aliasKey) {
-          return new ResolverImpl(aliasKey, 5 /* ResolverStrategy.alias */, originalKey);
+          return new ResolverImpl(aliasKey, ResolverStrategy.alias, originalKey);
       },
   });
   /** @internal */
@@ -4951,7 +4969,7 @@
   }
   function buildAllResponse(resolver, handler, requestor) {
       if (resolver instanceof ResolverImpl &&
-          resolver.strategy === 4 /* ResolverStrategy.array */) {
+          resolver.strategy === ResolverStrategy.array) {
           const state = resolver.state;
           let i = state.length;
           const results = new Array(i);
@@ -5268,9 +5286,7 @@
       baseCtors.forEach(baseCtor => {
           Object.getOwnPropertyNames(baseCtor.prototype).forEach(name => {
               if (name !== "constructor") {
-                  Object.defineProperty(derivedCtor.prototype, name, 
-                  /* eslint-disable-next-line @typescript-eslint/no-non-null-assertion */
-                  Object.getOwnPropertyDescriptor(baseCtor.prototype, name));
+                  Object.defineProperty(derivedCtor.prototype, name, Object.getOwnPropertyDescriptor(baseCtor.prototype, name));
               }
           });
           const baseAttributes = AttributeConfiguration.locate(baseCtor);
@@ -5366,7 +5382,7 @@
           styleElement.sheet.insertRule("foo:focus-visible {color:inherit}", 0);
           _canUseFocusVisible = true;
       }
-      catch (_a) {
+      catch {
           _canUseFocusVisible = false;
       }
       finally {
@@ -9087,6 +9103,7 @@
       constructor(source) {
           super();
           const sheet = new CSSStyleSheet();
+          // @ts-expect-error
           sheet[prependToAdoptedStyleSheetsSymbol] = true;
           this.target = sheet.cssRules[sheet.insertRule(":host{}")].style;
           source.$fastController.addStyles(ElementStyles.create([sheet]));
@@ -9266,7 +9283,6 @@
               };
           }
           if (propertyTargetCache.has(source)) {
-              /* eslint-disable-next-line @typescript-eslint/no-non-null-assertion */
               return propertyTargetCache.get(source);
           }
           let target;
@@ -9938,9 +9954,7 @@
           RootStyleSheetTarget.unregisterRoot(target);
       },
   });
-  /* eslint-enable @typescript-eslint/no-non-null-assertion */
 
-  /* eslint-disable @typescript-eslint/no-non-null-assertion */
   /**
    * Indicates what to do with an ambiguous (duplicate) element.
    * @public
@@ -10144,7 +10158,6 @@
           return DesignSystem.tagFor(type);
       }
   }
-  /* eslint-enable @typescript-eslint/no-non-null-assertion */
 
   /*!
   * tabbable 6.5.0
@@ -11994,6 +12007,7 @@
           return (this.parentToolbar ?? false);
       }
       get isInsideFoundationToolbar() {
+          // @ts-expect-error
           return !!this.parentToolbar?.["$fastController"];
       }
       /**
@@ -12964,8 +12978,11 @@
                   }
                   // If the original property isn't emptied out,
                   // the next set will morph into a grid-area style setting that is not what we want
+                  // @ts-expect-error
                   tab.style[gridHorizontalProperty] = "";
+                  // @ts-expect-error
                   tab.style[gridVerticalProperty] = "";
+                  // @ts-expect-error
                   tab.style[gridProperty] = `${index + 1}`;
                   if (!this.isHorizontal()) {
                       tab.classList.add("vertical");
@@ -13183,15 +13200,20 @@
               ? "translateX"
               : "translateY";
           const offsetProperty = this.isHorizontal() ? "offsetLeft" : "offsetTop";
+          // @ts-expect-error
           const prev = this.activeIndicatorRef[offsetProperty];
+          // @ts-expect-error
           this.activeIndicatorRef.style[gridProperty] = `${this.activeTabIndex + 1}`;
+          // @ts-expect-error
           const next = this.activeIndicatorRef[offsetProperty];
+          // @ts-expect-error
           this.activeIndicatorRef.style[gridProperty] = `${this.prevActiveTabIndex + 1}`;
           const dif = next - prev;
           this.activeIndicatorRef.style.transform = `${translateProperty}(${dif}px)`;
           this.activeIndicatorRef.classList.add("activeIndicatorTransition");
           this.activeIndicatorRef.addEventListener("transitionend", () => {
               this.ticking = false;
+              // @ts-expect-error
               this.activeIndicatorRef.style[gridProperty] = `${this.activeTabIndex + 1}`;
               this.activeIndicatorRef.style.transform = `${translateProperty}(0px)`;
               this.activeIndicatorRef.classList.remove("activeIndicatorTransition");
@@ -13590,7 +13612,10 @@
        * @internal
        */
       getDirectionalIncrementer(key) {
-          return (ToolbarArrowKeyMap[key]?.[this.orientation]?.[this.direction] ??
+          return (
+          // @ts-expect-error
+          ToolbarArrowKeyMap[key]?.[this.orientation]?.[this.direction] ??
+              // @ts-expect-error
               ToolbarArrowKeyMap[key]?.[this.orientation] ??
               0);
       }
@@ -15197,6 +15222,30 @@
           this.b = blue;
           this.a = typeof alpha === "number" && !isNaN(alpha) ? alpha : 1;
       }
+      /**
+       * The red value
+       * @remarks
+       * Scaled to the range [0.0 , 1.0]. Values outside this range are allowed but any methods that convert or tostring the values will also be clamped
+       */
+      r;
+      /**
+       * The green value
+       * @remarks
+       * Scaled to the range [0.0 , 1.0]. Values outside this range are allowed but any methods that convert or tostring the values will also be clamped
+       */
+      g;
+      /**
+       * The blue value
+       * @remarks
+       * Scaled to the range [0.0 , 1.0]. Values outside this range are allowed but any methods that convert or tostring the values will also be clamped
+       */
+      b;
+      /**
+       * The alpha value
+       * @remarks
+       * Scaled to the range [0.0 , 1.0]. Values outside this range are allowed but any methods that convert or tostring the values will also be clamped
+       */
+      a;
       /**
        * Determines if one color is equal to another.
        * @param rhs - the color to compare
@@ -52306,6 +52355,19 @@ img.ProseMirror-separator {
   const QUOTE_TEST_RE = /['"]/;
   const QUOTE_RE = /['"]/g;
   const APOSTROPHE$1 = '\u2019'; /* ’ */
+  // Caps memory on malicious input
+  const MAX_OPENERS = 1000;
+
+  function truncateStack (stack, heads, length) {
+    while (stack.length > length) {
+      const item = stack.pop();
+      if (item.isSingleQuote) {
+        heads.single = item.prevSameQuoteIdx;
+      } else {
+        heads.double = item.prevSameQuoteIdx;
+      }
+    }
+  }
 
   function addReplacement (replacements, tokenIdx, pos, ch) {
     if (!replacements[tokenIdx]) {
@@ -52335,6 +52397,8 @@ img.ProseMirror-separator {
     let j;
 
     const stack = [];
+    // stack indexes of topmost openers of each type (-1 if none)
+    const heads = { single: -1, double: -1 };
     // token index -> list of replacements in the original token content
     const replacements = {};
 
@@ -52346,7 +52410,7 @@ img.ProseMirror-separator {
       for (j = stack.length - 1; j >= 0; j--) {
         if (stack[j].level <= thisLevel) { break }
       }
-      stack.length = j + 1;
+      truncateStack(stack, heads, j + 1);
 
       if (token.type !== 'text') { continue }
 
@@ -52450,39 +52514,45 @@ img.ProseMirror-separator {
         }
 
         if (canClose) {
-          // this could be a closing quote, rewind the stack to get a match
-          for (j = stack.length - 1; j >= 0; j--) {
-            let item = stack[j];
-            if (stack[j].level < thisLevel) { break }
-            if (item.single === isSingle && stack[j].level === thisLevel) {
-              item = stack[j];
-
-              let openQuote;
-              let closeQuote;
-              if (isSingle) {
-                openQuote = state.md.options.quotes[2];
-                closeQuote = state.md.options.quotes[3];
-              } else {
-                openQuote = state.md.options.quotes[0];
-                closeQuote = state.md.options.quotes[1];
-              }
+          // Stack levels never decrease, so an opener of this type below
+          // the current level means there is no match
+          j = isSingle ? heads.single : heads.double;
+          if (j >= 0 && stack[j].level === thisLevel) {
+            const item = stack[j];
+
+            let openQuote;
+            let closeQuote;
+            if (isSingle) {
+              openQuote = state.md.options.quotes[2];
+              closeQuote = state.md.options.quotes[3];
+            } else {
+              openQuote = state.md.options.quotes[0];
+              closeQuote = state.md.options.quotes[1];
+            }
 
-              addReplacement(replacements, i, t.index, closeQuote);
-              addReplacement(replacements, item.token, item.pos, openQuote);
+            addReplacement(replacements, i, t.index, closeQuote);
+            addReplacement(replacements, item.tokenIdx, item.contentPos, openQuote);
 
-              stack.length = j;
-              continue OUTER
-            }
+            truncateStack(stack, heads, j);
+            continue OUTER
           }
         }
 
         if (canOpen) {
+          if (stack.length >= MAX_OPENERS) { return }
           stack.push({
-            token: i,
-            pos: t.index,
-            single: isSingle,
-            level: thisLevel
+            tokenIdx: i,
+            contentPos: t.index,
+            isSingleQuote: isSingle,
+            level: thisLevel,
+            // stack index of the previous opener of the same quote type, -1 if none
+            prevSameQuoteIdx: isSingle ? heads.single : heads.double
           });
+          if (isSingle) {
+            heads.single = stack.length - 1;
+          } else {
+            heads.double = stack.length - 1;
+          }
         } else if (canClose && isSingle) {
           addReplacement(replacements, i, t.index, APOSTROPHE$1);
         }
@@ -76449,8 +76519,11 @@ focus outline in that case.
     </template>
 `;
 
-  function createLazyMeasurementsView(count, flat, getItemKey) {
-    const cache = new Array(count);
+  function getMeasurementKey(item) {
+    return typeof item === "object" ? item.key : item;
+  }
+  function createLazyMeasurementsView(cache, flat) {
+    const count = cache.length;
     return new Proxy(cache, {
       get(target, prop, receiver) {
         if (typeof prop === "string") {
@@ -76459,11 +76532,11 @@ focus outline in that case.
             const i = +prop;
             if (Number.isInteger(i) && i >= 0 && i < count) {
               let v = target[i];
-              if (!v) {
+              if (typeof v !== "object") {
                 const s = flat[i * 2];
                 v = target[i] = {
                   index: i,
-                  key: getItemKey(i),
+                  key: v,
                   start: s,
                   size: flat[i * 2 + 1],
                   end: s + flat[i * 2 + 1],
@@ -76635,7 +76708,7 @@ focus outline in that case.
     let offset = 0;
     const fallback = registerScrollendEvent ? null : debounce(
       targetWindow,
-      () => cb(offset, false),
+      () => cb(readOffset(element), false),
       instance.options.isScrollingResetDelay
     );
     const createHandler = (isScrolling) => () => {
@@ -76697,6 +76770,27 @@ focus outline in that case.
     });
   };
   const elementScroll = scrollWithAdjustments;
+  function isAppendWithTrim(prevCount, nextCount, getPreviousKey, getNextKey) {
+    if (nextCount === 0) return false;
+    const firstKey = getNextKey(0);
+    const removedKeys = /* @__PURE__ */ new Set();
+    let removedCount = 0;
+    while (removedCount < prevCount) {
+      const key = getPreviousKey(removedCount);
+      if (key === firstKey) break;
+      removedKeys.add(key);
+      removedCount++;
+    }
+    const retainedCount = prevCount - removedCount;
+    if (retainedCount === 0 || retainedCount >= nextCount) return false;
+    for (let i = 0; i < retainedCount; i++) {
+      if (getNextKey(i) !== getPreviousKey(removedCount + i)) return false;
+    }
+    for (let i = retainedCount; i < nextCount; i++) {
+      if (removedKeys.has(getNextKey(i))) return false;
+    }
+    return true;
+  }
   let Virtualizer$1 = class Virtualizer {
     constructor(opts) {
       this.unsubs = [];
@@ -76705,7 +76799,7 @@ focus outline in that case.
       this.isScrolling = false;
       this.scrollState = null;
       this.measurementsCache = [];
-      this._flatMeasurements = null;
+      this._singleLaneMeasurements = null;
       this.itemSizeCache = /* @__PURE__ */ new Map();
       this.itemSizeCacheVersion = 0;
       this.laneAssignments = /* @__PURE__ */ new Map();
@@ -76723,6 +76817,7 @@ focus outline in that case.
       this._iosJustTouchEnded = false;
       this._iosTouchEndTimerId = null;
       this._intendedScrollOffset = null;
+      this._clampedAdjustment = null;
       this.elementsCache = /* @__PURE__ */ new Map();
       this.now = () => {
         var _a, _b, _c;
@@ -76782,7 +76877,7 @@ focus outline in that case.
       })();
       this.range = null;
       this.setOptions = (opts2) => {
-        var _a, _b;
+        var _a;
         const merged = {
           debug: false,
           initialOffset: 0,
@@ -76826,8 +76921,10 @@ focus outline in that case.
           const prevCount = prevOptions.count;
           const nextCount = merged.count;
           const measurements = this.getMeasurements();
-          const prevFirstKey = prevCount > 0 ? ((_a = measurements[0]) == null ? void 0 : _a.key) ?? prevOptions.getItemKey(0) : null;
-          const prevLastKey = prevCount > 0 ? ((_b = measurements[prevCount - 1]) == null ? void 0 : _b.key) ?? prevOptions.getItemKey(prevCount - 1) : null;
+          const previousItems = ((_a = this._singleLaneMeasurements) == null ? void 0 : _a.items) ?? measurements;
+          const getPreviousKey = (index) => getMeasurementKey(previousItems[index]);
+          const prevFirstKey = prevCount > 0 ? getPreviousKey(0) : null;
+          const prevLastKey = prevCount > 0 ? getPreviousKey(prevCount - 1) : null;
           const didCountChange = nextCount !== prevCount;
           const didEdgeKeysChange = didCountChange || prevCount > 0 && nextCount > 0 && (merged.getItemKey(0) !== prevFirstKey || merged.getItemKey(nextCount - 1) !== prevLastKey);
           if (didEdgeKeysChange) {
@@ -76837,8 +76934,15 @@ focus outline in that case.
               anchor = [item.key, this.getScrollOffset() - item.start];
             }
             const behavior = merged.followOnAppend === true ? "auto" : merged.followOnAppend || null;
-            if (behavior && nextCount > prevCount && this.isAtEnd(prevOptions.scrollEndThreshold) && (prevCount === 0 || merged.getItemKey(nextCount - 1) !== prevLastKey)) {
-              followOnAppend = behavior;
+            if (behavior && nextCount > 0 && this.isAtEnd(prevOptions.scrollEndThreshold) && (prevCount === 0 || merged.getItemKey(nextCount - 1) !== prevLastKey)) {
+              if (nextCount > prevCount || isAppendWithTrim(
+                prevCount,
+                nextCount,
+                getPreviousKey,
+                merged.getItemKey
+              )) {
+                followOnAppend = behavior;
+              }
             }
           }
         }
@@ -76861,7 +76965,7 @@ focus outline in that case.
             const anchorItem = newMeasurements[idx];
             if (anchorItem) {
               const newOffset = Math.max(0, anchorItem.start + anchorOffset);
-              if (newOffset !== this.scrollOffset) {
+              if (!followOnAppend && newOffset !== this.scrollOffset) {
                 anchorDelta = newOffset - this.scrollOffset;
                 this.scrollOffset = newOffset;
                 anchorResolved = true;
@@ -76918,6 +77022,7 @@ focus outline in that case.
         this._iosDeferredAdjustment = 0;
         this._iosTouching = false;
         this._iosJustTouchEnded = false;
+        this._clampedAdjustment = null;
         this.scrollElement = null;
         this.targetWindow = null;
       };
@@ -76927,7 +77032,7 @@ focus outline in that case.
         };
       };
       this._willUpdate = () => {
-        var _a;
+        var _a, _b;
         const scrollElement = this.options.enabled ? this.options.getScrollElement() : null;
         if (this.scrollElement !== scrollElement) {
           this.cleanup();
@@ -76959,6 +77064,9 @@ focus outline in that case.
                 offset = this._intendedScrollOffset;
               }
               this._intendedScrollOffset = null;
+              if (this._clampedAdjustment !== null && Math.abs(offset - this._clampedAdjustment.maxAtWrite) >= 1.5) {
+                this._clampedAdjustment = null;
+              }
               this.scrollAdjustments = 0;
               const prevOffset = this.getScrollOffset();
               this.scrollDirection = isScrolling ? prevOffset === offset ? this.scrollDirection : prevOffset < offset ? "forward" : "backward" : null;
@@ -77026,7 +77134,11 @@ focus outline in that case.
               if (anchorDelta !== 0) {
                 this._iosDeferredAdjustment += anchorDelta;
               }
-            } else {
+            } else if (((_b = this.scrollState) == null ? void 0 : _b.behavior) === "smooth" && !approxEqual(
+              this.getScrollOffset() - anchorDelta,
+              this.scrollState.lastTargetOffset
+            )) ;
+            else {
               this._scrollToOffset(this.getScrollOffset(), {
                 adjustments: void 0,
                 behavior: void 0
@@ -77037,6 +77149,21 @@ focus outline in that case.
             this.scrollToEnd({ behavior: followOnAppend });
           }
         }
+        this._retryClampedAdjustment();
+      };
+      this._retryClampedAdjustment = () => {
+        if (this._clampedAdjustment === null || !this.scrollElement || !this.options.enabled) {
+          return;
+        }
+        const { target, maxAtWrite } = this._clampedAdjustment;
+        const max = this.getMaxScrollOffset();
+        if (max > maxAtWrite + 0.5) {
+          this._clampedAdjustment = target > max + 0.5 ? { target, maxAtWrite: max } : null;
+          this._scrollToOffset(target, {
+            adjustments: void 0,
+            behavior: void 0
+          });
+        }
       };
       this._flushIosDeferredIfReady = () => {
         if (this._iosDeferredAdjustment === 0) return;
@@ -77120,9 +77247,11 @@ focus outline in that case.
           laneAssignmentMode,
           gap
         }, _itemSizeCacheVersion) => {
+          var _a;
           const itemSizeCache = this.itemSizeCache;
           if (!enabled) {
             this.measurementsCache = [];
+            this._singleLaneMeasurements = null;
             this.itemSizeCache.clear();
             this.laneAssignments.clear();
             return [];
@@ -77138,6 +77267,7 @@ focus outline in that case.
             this.lanesChangedFlag = false;
             this.lanesSettling = true;
             this.measurementsCache = [];
+            this._singleLaneMeasurements = null;
             this.itemSizeCache.clear();
             this.laneAssignments.clear();
             this.pendingMin = null;
@@ -77155,13 +77285,13 @@ focus outline in that case.
           }
           if (lanes === 1) {
             const need = count * 2;
-            let flat = this._flatMeasurements;
+            let flat = (_a = this._singleLaneMeasurements) == null ? void 0 : _a.flat;
             if (!flat || flat.length < need) {
               const next = new Float64Array(need);
               if (flat && min > 0) next.set(flat.subarray(0, min * 2));
               flat = next;
-              this._flatMeasurements = flat;
             }
+            const items = min === 0 ? new Array(count) : this._singleLaneMeasurements.items.slice();
             let runningStart;
             if (min === 0) {
               runningStart = paddingStart + scrollMargin;
@@ -77171,13 +77301,15 @@ focus outline in that case.
             }
             for (let i = min; i < count; i++) {
               const key = getItemKey(i);
+              items[i] = key;
               const measuredSize = itemSizeCache.get(key);
               const size = typeof measuredSize === "number" ? measuredSize : this.options.estimateSize(i);
               flat[i * 2] = runningStart;
               flat[i * 2 + 1] = size;
               runningStart += size + gap;
             }
-            const view = createLazyMeasurementsView(count, flat, getItemKey);
+            this._singleLaneMeasurements = { flat, items };
+            const view = createLazyMeasurementsView(items, flat);
             this.measurementsCache = view;
             return view;
           }
@@ -77272,7 +77404,7 @@ focus outline in that case.
             lanes,
             // Pass the typed array so binary search + forward-walk can read
             // start/end directly from Float64Array, skipping the Proxy traps.
-            lanes === 1 && this._flatMeasurements != null ? this._flatMeasurements : null
+            lanes === 1 && this._singleLaneMeasurements !== null ? this._singleLaneMeasurements.flat : null
           );
           return this.range;
         },
@@ -77369,13 +77501,13 @@ focus outline in that case.
         }
       };
       this.resizeItem = (index, size) => {
-        var _a, _b;
+        var _a, _b, _c;
         if (!this.isIndexInRange(index)) return;
         let cachedSize;
         let itemStart;
         let key;
-        const flat = this._flatMeasurements;
-        if (this.options.lanes === 1 && flat !== null) {
+        const flat = (_a = this._singleLaneMeasurements) == null ? void 0 : _a.flat;
+        if (this.options.lanes === 1 && flat != null) {
           key = this.options.getItemKey(index);
           itemStart = flat[index * 2];
           cachedSize = flat[index * 2 + 1];
@@ -77389,7 +77521,7 @@ focus outline in that case.
         const itemSize = this.itemSizeCache.get(key) ?? cachedSize;
         const delta = size - itemSize;
         if (delta !== 0) {
-          const wasAtEnd = this.options.anchorTo === "end" && ((_a = this.scrollState) == null ? void 0 : _a.behavior) !== "smooth" && this.getVirtualDistanceFromEnd() <= this.options.scrollEndThreshold;
+          const wasAtEnd = this.options.anchorTo === "end" && ((_b = this.scrollState) == null ? void 0 : _b.behavior) !== "smooth" && this.getVirtualDistanceFromEnd() <= this.options.scrollEndThreshold;
           const prevTotalSize = wasAtEnd ? this.getTotalSize() : 0;
           const scrollOffsetWithAdj = this.getScrollOffset() + this.scrollAdjustments;
           const isFirstMeasure = !this.itemSizeCache.has(key);
@@ -77408,7 +77540,7 @@ focus outline in that case.
             // scrolling up" cascade.
             itemStart + itemSize <= scrollOffsetWithAdj && this.scrollDirection !== "backward"
           );
-          const shouldAdjustScroll = ((_b = this.scrollState) == null ? void 0 : _b.behavior) !== "smooth" && (this.shouldAdjustScrollPositionOnItemSizeChange !== void 0 ? this.shouldAdjustScrollPositionOnItemSizeChange(
+          const shouldAdjustScroll = ((_c = this.scrollState) == null ? void 0 : _c.behavior) !== "smooth" && (this.shouldAdjustScrollPositionOnItemSizeChange !== void 0 ? this.shouldAdjustScrollPositionOnItemSizeChange(
             // The callback expects a VirtualItem; build one lazily only
             // when the consumer actually supplied a custom predicate.
             this.measurementsCache[index] ?? {
@@ -77436,6 +77568,7 @@ focus outline in that case.
             adjustedSync = this.applyScrollAdjustment(delta);
           }
           this.notify(adjustedSync);
+          this._retryClampedAdjustment();
         }
       };
       this.getVirtualItems = memo(
@@ -77455,11 +77588,12 @@ focus outline in that case.
         }
       );
       this.getVirtualItemForOffset = (offset) => {
+        var _a;
         const measurements = this.getMeasurements();
         if (measurements.length === 0) {
           return void 0;
         }
-        const flat = this._flatMeasurements;
+        const flat = (_a = this._singleLaneMeasurements) == null ? void 0 : _a.flat;
         const useFlat = this.options.lanes === 1 && flat != null;
         const idx = findNearestBinarySearch(
           0,
@@ -77594,18 +77728,18 @@ focus outline in that case.
         });
       };
       this.getTotalSize = () => {
-        var _a;
+        var _a, _b;
         const measurements = this.getMeasurements();
         let end;
         if (measurements.length === 0) {
           end = this.options.paddingStart;
         } else if (this.options.lanes === 1) {
           const lastIdx = measurements.length - 1;
-          const flat = this._flatMeasurements;
+          const flat = (_a = this._singleLaneMeasurements) == null ? void 0 : _a.flat;
           if (flat != null) {
             end = flat[lastIdx * 2] + flat[lastIdx * 2 + 1];
           } else {
-            end = ((_a = measurements[lastIdx]) == null ? void 0 : _a.end) ?? 0;
+            end = ((_b = measurements[lastIdx]) == null ? void 0 : _b.end) ?? 0;
           }
         } else {
           const endByLane = Array(this.options.lanes).fill(null);
@@ -77671,6 +77805,10 @@ focus outline in that case.
         this._iosDeferredAdjustment += delta;
         return false;
       } else {
+        const target = this.getScrollOffset() + this.scrollAdjustments + delta;
+        const el = this.scrollElement;
+        const maxAtWrite = el !== null && ("scrollHeight" in el || "document" in el) ? this.getMaxScrollOffset() : null;
+        this._clampedAdjustment = maxAtWrite !== null && target > maxAtWrite + 0.5 ? { target, maxAtWrite } : null;
         this._scrollToOffset(this.getScrollOffset(), {
           adjustments: this.scrollAdjustments += delta,
           behavior