@farm.js/react 0.1.0-beta.6 → 0.1.0-beta.8

package/dist/compiler-runtime.mjs

@@ -26,6 +26,8 @@ var COMPILER_KEYED_ARRAY_FILTERS = /* @__PURE__ */ new WeakMap();
 var COMPILER_KEYED_ARRAY_PREPENDS = /* @__PURE__ */ new WeakMap();
 var COMPILER_KEYED_ARRAY_ROLLING_WINDOWS = /* @__PURE__ */ new WeakMap();
 var COMPILER_KEYED_ARRAY_POSITIONS = /* @__PURE__ */ new WeakMap();
+var COMPILER_KEYED_ARRAY_BATCH_INSERTS = /* @__PURE__ */ new WeakMap();
+var COMPILER_KEYED_ARRAY_WINDOW_REPLACEMENTS = /* @__PURE__ */ new WeakMap();
 var COMPILER_KEYED_ARRAY_REORDERS = /* @__PURE__ */ new WeakMap();
 var COMPILER_KEYED_COLLECTION_DRAFTS = /* @__PURE__ */ new WeakMap();
 var COMPILER_KEYED_COLLECTION_UPDATES = /* @__PURE__ */ new WeakMap();
@@ -37,6 +39,7 @@ var NATIVE_ARRAY_SLICE = Array.prototype.slice;
 var NATIVE_ARRAY_TO_SPLICED = Array.prototype.toSpliced;
 var NATIVE_ARRAY_WITH = Array.prototype.with;
 var NATIVE_ARRAY_TO_REVERSED = Array.prototype.toReversed;
+var NATIVE_ARRAY_TO_SORTED = Array.prototype.toSorted;
 var NATIVE_REFLECT_APPLY = Reflect.apply;
 function compilerObject(value) {
   return typeof value === "object" && value !== null || typeof value === "function" ? value : void 0;
@@ -157,11 +160,40 @@ function compilerKeyedArrayPosition(value, sourceToken, expectedLength) {
   const target = compilerObject(value);
   if (!target || !sourceToken || !Array.isArray(value)) return void 0;
   const update = COMPILER_KEYED_ARRAY_POSITIONS.get(target);
-  if (!update || update.sourceToken !== sourceToken || update.sourceLength !== expectedLength || update.resultLength !== value.length || update.position < 0 || update.position > expectedLength || update.kind === "insert" && update.resultLength !== expectedLength + 1 || update.kind === "replace" && (update.position >= expectedLength || update.resultLength !== expectedLength)) {
+  if (!update || update.sourceToken !== sourceToken || update.sourceLength !== expectedLength || update.resultLength !== value.length || update.position < 0 || update.position > expectedLength || update.kind === "insert" && update.resultLength !== expectedLength + 1 || update.kind === "remove" && (update.resultLength >= expectedLength || update.position > update.resultLength) || update.kind === "replace" && (update.position >= expectedLength || update.resultLength !== expectedLength)) {
     return void 0;
   }
   return update;
 }
+function compilerKeyedArrayBatchInsert(value, sourceToken, expectedLength) {
+  const target = compilerObject(value);
+  if (!target || !sourceToken || !Array.isArray(value)) return void 0;
+  const update = COMPILER_KEYED_ARRAY_BATCH_INSERTS.get(target);
+  if (!update || update.sourceToken !== sourceToken || update.sourceLength !== expectedLength || update.resultLength !== value.length || update.resultLength < expectedLength + 2 || update.position < 0 || update.position > expectedLength) {
+    return void 0;
+  }
+  return update;
+}
+function compilerKeyedArrayWindowReplacements(value, sourceToken, expectedLength) {
+  const target = compilerObject(value);
+  if (!target || !sourceToken || !Array.isArray(value)) return void 0;
+  const update = COMPILER_KEYED_ARRAY_WINDOW_REPLACEMENTS.get(target);
+  if (!update || update.sourceToken !== sourceToken) return void 0;
+  const updates = [];
+  for (let current = update; current; current = current.previous) {
+    if (current.sourceToken !== sourceToken) return void 0;
+    updates.push(current);
+  }
+  updates.reverse();
+  let length = expectedLength;
+  for (const current of updates) {
+    if (current.sourceLength !== length || current.position < 0 || current.position >= current.sourceLength || current.removedCount < 1 || current.position + current.removedCount > current.sourceLength || current.insertedCount < 0 || current.resultLength !== current.sourceLength - current.removedCount + current.insertedCount) {
+      return void 0;
+    }
+    length = current.resultLength;
+  }
+  return length === value.length ? updates : void 0;
+}
 function compilerKeyedArrayReorder(value, sourceToken, expectedLength) {
   const target = compilerObject(value);
   if (!target || !sourceToken || !Array.isArray(value)) return void 0;
@@ -373,9 +405,12 @@ function createCompilerKeyedArrayPositionUpdate(previous, method, kind, position
     }
     const sourceLength = previous.length;
     const normalizedPosition = position < 0 ? Math.max(sourceLength + position, 0) : Math.min(position, sourceLength);
+    const deleteCount = args[0];
+    const removedCount = sourceLength - value.length;
     const validInsert = kind === "insert" && method === NATIVE_ARRAY_TO_SPLICED && args.length === 2 && Object.is(args[0], 0) && value.length === sourceLength + 1;
-    const validReplace = kind === "replace" && method === NATIVE_ARRAY_WITH && args.length === 1 && position >= -sourceLength && position < sourceLength && value.length === sourceLength;
-    if (!validInsert && !validReplace) return value;
+    const validRemove = kind === "remove" && method === NATIVE_ARRAY_TO_SPLICED && args.length === 1 && Number.isSafeInteger(deleteCount) && deleteCount > 0 && normalizedPosition < sourceLength && removedCount === Math.min(deleteCount, sourceLength - normalizedPosition);
+    const validReplace = kind === "replace" && value.length === sourceLength && (method === NATIVE_ARRAY_WITH && args.length === 1 && position >= -sourceLength && position < sourceLength || method === NATIVE_ARRAY_TO_SPLICED && args.length === 2 && Object.is(args[0], 1) && normalizedPosition < sourceLength);
+    if (!validInsert && !validRemove && !validReplace) return value;
     const sourceToken = compilerKeyedCollectionToken(previousTarget);
     if (!sourceToken) return value;
     COMPILER_KEYED_ARRAY_POSITIONS.set(valueTarget, {
@@ -389,6 +424,71 @@ function createCompilerKeyedArrayPositionUpdate(previous, method, kind, position
   }
   return value;
 }
+function createCompilerKeyedArrayBatchInsert(previous, method, position, ...items) {
+  const value = NATIVE_REFLECT_APPLY(
+    method,
+    previous,
+    [position, 0, ...items]
+  );
+  try {
+    const previousTarget = compilerObject(previous);
+    const valueTarget = compilerObject(value);
+    if (!previousTarget || !valueTarget || !COMPILER_KEYED_COMMITTED_COLLECTIONS.has(previousTarget) || !Array.isArray(previous) || !Array.isArray(value) || Object.getPrototypeOf(previous) !== NATIVE_ARRAY_PROTOTYPE || Object.getPrototypeOf(value) !== NATIVE_ARRAY_PROTOTYPE || method !== NATIVE_ARRAY_TO_SPLICED || !Number.isSafeInteger(position) || items.length < 2 || value.length !== previous.length + items.length) {
+      return value;
+    }
+    for (let index = 0; index < previous.length; index += 1) {
+      if (!Object.prototype.hasOwnProperty.call(previous, index)) return value;
+    }
+    const sourceToken = compilerKeyedCollectionToken(previousTarget);
+    if (!sourceToken) return value;
+    COMPILER_KEYED_ARRAY_BATCH_INSERTS.set(valueTarget, {
+      sourceToken,
+      sourceLength: previous.length,
+      resultLength: value.length,
+      position: position < 0 ? Math.max(previous.length + position, 0) : Math.min(position, previous.length)
+    });
+  } catch {
+  }
+  return value;
+}
+function createCompilerKeyedArrayWindowReplace(previous, method, position, deleteCount, ...items) {
+  const value = NATIVE_REFLECT_APPLY(
+    method,
+    previous,
+    [position, deleteCount, ...items]
+  );
+  try {
+    const previousTarget = compilerObject(previous);
+    const valueTarget = compilerObject(value);
+    if (!previousTarget || !valueTarget || !Array.isArray(previous) || !Array.isArray(value) || Object.getPrototypeOf(previous) !== NATIVE_ARRAY_PROTOTYPE || Object.getPrototypeOf(value) !== NATIVE_ARRAY_PROTOTYPE || method !== NATIVE_ARRAY_TO_SPLICED || !Number.isSafeInteger(position) || !Number.isSafeInteger(deleteCount) || deleteCount <= 0) {
+      return value;
+    }
+    for (let index = 0; index < previous.length; index += 1) {
+      if (!Object.prototype.hasOwnProperty.call(previous, index)) return value;
+    }
+    const normalizedPosition = position < 0 ? Math.max(previous.length + position, 0) : Math.min(position, previous.length);
+    const removedCount = Math.min(deleteCount, previous.length - normalizedPosition);
+    if (removedCount < 1 || value.length !== previous.length - removedCount + items.length) {
+      return value;
+    }
+    const committedSource = COMPILER_KEYED_COMMITTED_COLLECTIONS.has(previousTarget);
+    const previousUpdate = committedSource ? void 0 : COMPILER_KEYED_ARRAY_WINDOW_REPLACEMENTS.get(previousTarget);
+    if (!committedSource && !previousUpdate) return value;
+    const sourceToken = previousUpdate?.sourceToken || compilerKeyedCollectionToken(previousTarget);
+    if (!sourceToken) return value;
+    COMPILER_KEYED_ARRAY_WINDOW_REPLACEMENTS.set(valueTarget, {
+      sourceToken,
+      sourceLength: previous.length,
+      resultLength: value.length,
+      position: normalizedPosition,
+      removedCount,
+      insertedCount: items.length,
+      ...previousUpdate ? { previous: previousUpdate } : {}
+    });
+  } catch {
+  }
+  return value;
+}
 function createCompilerKeyedArrayReorder(previous, method) {
   const value = NATIVE_REFLECT_APPLY(
     method,
@@ -413,6 +513,33 @@ function createCompilerKeyedArrayReorder(previous, method) {
   }
   return value;
 }
+function createCompilerKeyedArraySort(previous, method, ...args) {
+  const value = NATIVE_REFLECT_APPLY(
+    method,
+    previous,
+    args
+  );
+  try {
+    const previousTarget = compilerObject(previous);
+    const valueTarget = compilerObject(value);
+    if (!previousTarget || !valueTarget || !COMPILER_KEYED_COMMITTED_COLLECTIONS.has(previousTarget) || !Array.isArray(previous) || !Array.isArray(value) || Object.getPrototypeOf(previous) !== NATIVE_ARRAY_PROTOTYPE || Object.getPrototypeOf(value) !== NATIVE_ARRAY_PROTOTYPE || method !== NATIVE_ARRAY_TO_SORTED || args.length > 1 || args.length === 1 && args[0] !== void 0 && typeof args[0] !== "function" || value.length !== previous.length) {
+      return value;
+    }
+    for (let index = 0; index < previous.length; index += 1) {
+      if (!(index in previous)) return value;
+    }
+    const sourceToken = compilerKeyedCollectionToken(previousTarget);
+    if (!sourceToken) return value;
+    COMPILER_KEYED_ARRAY_REORDERS.set(valueTarget, {
+      kind: "sort",
+      sourceToken,
+      sourceLength: previous.length,
+      resultLength: value.length
+    });
+  } catch {
+  }
+  return value;
+}
 function applyCompilerKeyedCollectionMutation(collection, method, operation, key, value) {
   const args = operation === "map-set" ? [key, value] : [key];
   const result = NATIVE_REFLECT_APPLY(method, collection, args);
@@ -1097,6 +1224,32 @@ function applyKeyedRowBinding(props, instance, item, index, bindingIndex) {
     updateAttribute(target, binding.name, rawValue);
   }
 }
+function prepareKeyedRowBindingUpdates(props, instance, item, index) {
+  const updates = [];
+  for (let bindingIndex = 0; bindingIndex < props.bindings.length; bindingIndex += 1) {
+    const binding = props.bindings[bindingIndex];
+    const rawValue = binding.read(item, index);
+    const value = normalizedKeyedRowBindingValue(binding, rawValue);
+    if (Object.is(instance.values[bindingIndex], value)) continue;
+    const target = findCompilerHostTarget(instance.element, binding.path);
+    if (!target || binding.kind !== "text" && !binding.name) return void 0;
+    updates.push([bindingIndex, rawValue, target, value]);
+  }
+  return updates;
+}
+function applyPreparedKeyedRowBindingUpdates(props, instance, updates) {
+  for (const [bindingIndex, rawValue, target, value] of updates) {
+    const binding = props.bindings[bindingIndex];
+    instance.values[bindingIndex] = value;
+    if (binding.kind === "text") {
+      target.textContent = value;
+    } else if (binding.kind === "style") {
+      updateStyle(target, binding.name, rawValue);
+    } else {
+      updateAttribute(target, binding.name, rawValue);
+    }
+  }
+}
 function keyedRowConditionalSnapshot(conditional, item, index) {
   const test = conditional.test(item, index);
   if (conditional.logical && !test) {
@@ -2539,6 +2692,33 @@ function longestIncreasingSubsequencePositions(sequence) {
   }
   return positions;
 }
+function reorderCompilerKeyedRows(root, instances, sequence, anchor) {
+  const activeElement = root.ownerDocument.activeElement;
+  const restoreFocus = Boolean(activeElement && root.contains(activeElement));
+  const stablePositions = longestIncreasingSubsequencePositions(sequence);
+  for (let index = instances.length - 1; index >= 0; index -= 1) {
+    const instance = instances[index];
+    if (sequence[index] < 0) {
+      let start = index;
+      while (start > 0 && sequence[start - 1] < 0) start -= 1;
+      const fragment = root.ownerDocument.createDocumentFragment();
+      for (let itemIndex = start; itemIndex <= index; itemIndex += 1) {
+        fragment.append(instances[itemIndex].element);
+      }
+      root.insertBefore(fragment, anchor);
+      anchor = instances[start].element;
+      index = start;
+    } else {
+      if (!stablePositions.has(index) && instance.element.nextSibling !== anchor) {
+        root.insertBefore(instance.element, anchor);
+      }
+      anchor = instance.element;
+    }
+  }
+  if (restoreFocus && activeElement?.isConnected && activeElement.ownerDocument.activeElement !== activeElement && "focus" in activeElement) {
+    activeElement.focus({ preventScroll: true });
+  }
+}
 var keyedUpdateRuntime = {
   append: reconcileCompilerKeyedArrayAppend,
   commit: commitCompilerKeyedCollection,
@@ -2560,6 +2740,14 @@ var keyedPositionUpdateRuntime = {
   ...keyedUpdateRuntime,
   position: reconcileCompilerKeyedArrayPosition
 };
+var keyedBatchPositionUpdateRuntime = {
+  ...keyedUpdateRuntime,
+  position: reconcileCompilerKeyedArrayPositionWithBatch
+};
+var keyedWindowPositionUpdateRuntime = {
+  ...keyedUpdateRuntime,
+  position: reconcileCompilerKeyedArrayPositionWithWindow
+};
 var keyedReorderUpdateRuntime = {
   ...keyedUpdateRuntime,
   reorder: reconcileCompilerKeyedArrayReorder
@@ -2573,6 +2761,14 @@ var keyedEveryUpdateRuntime = {
   position: reconcileCompilerKeyedArrayPosition,
   reorder: reconcileCompilerKeyedArrayReorder
 };
+var keyedBatchEveryUpdateRuntime = {
+  ...keyedEveryUpdateRuntime,
+  position: reconcileCompilerKeyedArrayPositionWithBatch
+};
+var keyedWindowEveryUpdateRuntime = {
+  ...keyedEveryUpdateRuntime,
+  position: reconcileCompilerKeyedArrayPositionWithWindow
+};
 function reconcileCompilerKeyedMapUpdate(props, dirtyState, collectionToken, instances, conditionals) {
   const dependency = props.collectionDependency;
   if (dependency === void 0) return void 0;
@@ -2752,6 +2948,22 @@ function reconcileCompilerKeyedArrayPosition(props, dirtyState, collectionToken,
   if (!update || !Array.isArray(finalValue)) return void 0;
   const previousInstances = [...instances.values()];
   const previous = previousInstances[update.position];
+  if (update.kind === "remove") {
+    const count = update.sourceLength - update.resultLength;
+    const removed = previousInstances.slice(update.position, update.position + count);
+    if (removed.some((instance, index) => instance.index !== update.position + index)) {
+      return void 0;
+    }
+    for (const instance of removed) {
+      instance.scope?.cleanup();
+      instance.element.remove();
+    }
+    previousInstances.splice(update.position, count);
+    for (let index = update.position; index < previousInstances.length; index += 1) {
+      previousInstances[index].index = index;
+    }
+    return new Map(previousInstances.map((instance) => [instance.key, instance]));
+  }
   let item;
   let key;
   try {
@@ -2813,6 +3025,299 @@ function reconcileCompilerKeyedArrayPosition(props, dirtyState, collectionToken,
   previousInstances[update.position] = replacement;
   return new Map(previousInstances.map((instance) => [instance.key, instance]));
 }
+function reconcileCompilerKeyedArrayBatchInsert(props, dirtyState, collectionToken, instances, root, reactOwnedRows) {
+  if (reactOwnedRows || props.hostBlocks || (props.conditionals?.length || 0) > 0 || !props.positionIndexIndependent || props.collectionDependency === void 0) {
+    return void 0;
+  }
+  const collectionDependency = props.collectionDependency;
+  if (props.bindings.some((binding) => binding.dependencies?.includes(collectionDependency))) {
+    return void 0;
+  }
+  const dependencies = props.dependencies || props.structureDependencies;
+  const relevantDirty = (dependencies || []).filter((index) => dirtyState.has(index));
+  if (relevantDirty.length !== 1 || relevantDirty[0] !== collectionDependency) {
+    return void 0;
+  }
+  const finalValue = props.items();
+  const update = compilerKeyedArrayBatchInsert(finalValue, collectionToken, instances.size);
+  if (!update || !Array.isArray(finalValue)) return void 0;
+  const previousInstances = [...instances.values()];
+  const insertCount = update.resultLength - update.sourceLength;
+  for (let sourceIndex = 0; sourceIndex < update.sourceLength; sourceIndex += 1) {
+    const instance = previousInstances[sourceIndex];
+    const resultIndex = sourceIndex < update.position ? sourceIndex : sourceIndex + insertCount;
+    if (!instance || instance.index !== sourceIndex || !Object.is(instance.item, finalValue[resultIndex])) {
+      return void 0;
+    }
+  }
+  const knownKeys = new Set(instances.keys());
+  const incoming = [];
+  try {
+    for (let offset = 0; offset < insertCount; offset += 1) {
+      const index = update.position + offset;
+      const item = finalValue[index];
+      const key = keyedRowIdentity(props.rowKey(item, index));
+      if (knownKeys.has(key)) return void 0;
+      knownKeys.add(key);
+      const descriptor = props.create(item, index);
+      incoming.push({
+        key,
+        element: createCompilerHostElement(root.ownerDocument, descriptor),
+        values: readKeyedRowBindingValues(props, item, index),
+        item,
+        index,
+        conditionalValues: EMPTY_KEYED_ROW_CONDITIONAL_VALUES
+      });
+    }
+  } catch {
+    return void 0;
+  }
+  const fragment = root.ownerDocument.createDocumentFragment();
+  for (const instance of incoming) fragment.append(instance.element);
+  root.insertBefore(fragment, previousInstances[update.position]?.element || null);
+  previousInstances.splice(update.position, 0, ...incoming);
+  for (let index = update.position + insertCount; index < previousInstances.length; index += 1) {
+    previousInstances[index].index = index;
+  }
+  return new Map(previousInstances.map((instance) => [instance.key, instance]));
+}
+function reconcileCompilerKeyedArrayWindowReplace(props, dirtyState, collectionToken, instances, root, reactOwnedRows) {
+  if (reactOwnedRows || props.hostBlocks || (props.conditionals?.length || 0) > 0 || !props.positionIndexIndependent || props.collectionDependency === void 0) {
+    return void 0;
+  }
+  const collectionDependency = props.collectionDependency;
+  if (props.bindings.some((binding) => binding.dependencies?.includes(collectionDependency))) {
+    return void 0;
+  }
+  const dependencies = props.dependencies || props.structureDependencies;
+  const relevantDirty = (dependencies || []).filter((index) => dirtyState.has(index));
+  if (relevantDirty.length !== 1 || relevantDirty[0] !== collectionDependency) {
+    return void 0;
+  }
+  const finalValue = props.items();
+  const updates = compilerKeyedArrayWindowReplacements(finalValue, collectionToken, instances.size);
+  if (!updates || !Array.isArray(finalValue)) return void 0;
+  const previousInstances = [...instances.values()];
+  if (updates.length > 1) {
+    const touchedIndices = /* @__PURE__ */ new Set();
+    for (const update2 of updates) {
+      if (update2.insertedCount !== update2.removedCount) return void 0;
+      for (let index = update2.position; index < update2.position + update2.removedCount; index += 1) {
+        touchedIndices.add(index);
+      }
+    }
+    for (let index = 0; index < previousInstances.length; index += 1) {
+      const instance = previousInstances[index];
+      const touched = touchedIndices.has(index);
+      if (!instance || instance.index !== index || (touched ? instance.element.parentNode !== root : !Object.is(instance.item, finalValue[index]))) {
+        return void 0;
+      }
+    }
+    const knownKeys2 = new Set(instances.keys());
+    const incomingKeys2 = /* @__PURE__ */ new Set();
+    let replacesRows = false;
+    const prepared = [];
+    try {
+      for (const index of [...touchedIndices].sort((left, right) => left - right)) {
+        const instance = previousInstances[index];
+        const item = finalValue[index];
+        const key = keyedRowIdentity(props.rowKey(item, index));
+        if (key !== instance.key) {
+          if (knownKeys2.has(key) || incomingKeys2.has(key)) return void 0;
+          incomingKeys2.add(key);
+          replacesRows = true;
+          const descriptor = props.create(item, index);
+          prepared.push([
+            index,
+            instance,
+            item,
+            void 0,
+            {
+              key,
+              element: createCompilerHostElement(root.ownerDocument, descriptor),
+              values: readKeyedRowBindingValues(props, item, index),
+              item,
+              index,
+              conditionalValues: EMPTY_KEYED_ROW_CONDITIONAL_VALUES
+            }
+          ]);
+          continue;
+        }
+        const bindingUpdates = prepareKeyedRowBindingUpdates(props, instance, item, index);
+        if (!bindingUpdates) return void 0;
+        prepared.push([index, instance, item, bindingUpdates, void 0]);
+      }
+    } catch {
+      return void 0;
+    }
+    for (const [index, instance, item, bindingUpdates, replacement] of prepared) {
+      if (replacement) {
+        instance.scope?.cleanup();
+        instance.element.replaceWith(replacement.element);
+        previousInstances[index] = replacement;
+      } else {
+        applyPreparedKeyedRowBindingUpdates(props, instance, bindingUpdates);
+        instance.item = item;
+      }
+    }
+    return replacesRows ? new Map(previousInstances.map((instance) => [instance.key, instance])) : instances;
+  }
+  const update = updates[0];
+  const removedEnd = update.position + update.removedCount;
+  for (let sourceIndex = 0; sourceIndex < update.sourceLength; sourceIndex += 1) {
+    const instance = previousInstances[sourceIndex];
+    if (!instance || instance.index !== sourceIndex) return void 0;
+    if (sourceIndex >= update.position && sourceIndex < removedEnd) continue;
+    const resultIndex = sourceIndex < update.position ? sourceIndex : sourceIndex - update.removedCount + update.insertedCount;
+    if (!Object.is(instance.item, finalValue[resultIndex])) return void 0;
+  }
+  const removed = previousInstances.slice(update.position, removedEnd);
+  const anchor = previousInstances[removedEnd]?.element;
+  if (removed.length !== update.removedCount || removed.some((instance) => instance.element.parentNode !== root) || anchor && anchor.parentNode !== root) {
+    return void 0;
+  }
+  const incomingItems = [];
+  const incomingKeys = [];
+  try {
+    for (let offset = 0; offset < update.insertedCount; offset += 1) {
+      const index = update.position + offset;
+      const item = finalValue[index];
+      const key = keyedRowIdentity(props.rowKey(item, index));
+      incomingItems.push(item);
+      incomingKeys.push(key);
+    }
+  } catch {
+    return void 0;
+  }
+  if (update.insertedCount === update.removedCount && incomingKeys.every((key, offset) => key === removed[offset].key)) {
+    const prepared = [];
+    try {
+      for (let offset = 0; offset < update.insertedCount; offset += 1) {
+        const updates2 = prepareKeyedRowBindingUpdates(
+          props,
+          removed[offset],
+          incomingItems[offset],
+          update.position + offset
+        );
+        if (!updates2) return void 0;
+        prepared.push(updates2);
+      }
+    } catch {
+      return void 0;
+    }
+    for (let offset = 0; offset < update.insertedCount; offset += 1) {
+      applyPreparedKeyedRowBindingUpdates(props, removed[offset], prepared[offset]);
+      removed[offset].item = incomingItems[offset];
+    }
+    return instances;
+  }
+  if (update.insertedCount === update.removedCount) {
+    const incomingKeySet = new Set(incomingKeys);
+    if (incomingKeySet.size !== incomingKeys.length) return void 0;
+    const removedByKey = new Map(
+      removed.map((instance, offset) => [instance.key, { instance, offset }])
+    );
+    if (incomingKeys.some((key) => removedByKey.has(key))) {
+      const nextWindow = [];
+      const sequence = [];
+      const preparedBindings = [];
+      try {
+        for (let offset = 0; offset < update.insertedCount; offset += 1) {
+          const index = update.position + offset;
+          const item = incomingItems[offset];
+          const key = incomingKeys[offset];
+          const retained = removedByKey.get(key);
+          if (retained) {
+            const bindingUpdates = prepareKeyedRowBindingUpdates(
+              props,
+              retained.instance,
+              item,
+              index
+            );
+            if (!bindingUpdates) return void 0;
+            nextWindow.push(retained.instance);
+            sequence.push(retained.offset);
+            preparedBindings.push(bindingUpdates);
+            continue;
+          }
+          if (instances.has(key)) return void 0;
+          const descriptor = props.create(item, index);
+          nextWindow.push({
+            key,
+            element: createCompilerHostElement(root.ownerDocument, descriptor),
+            values: readKeyedRowBindingValues(props, item, index),
+            item,
+            index,
+            conditionalValues: EMPTY_KEYED_ROW_CONDITIONAL_VALUES
+          });
+          sequence.push(-1);
+          preparedBindings.push(void 0);
+        }
+      } catch {
+        return void 0;
+      }
+      for (const instance of removed) {
+        if (incomingKeySet.has(instance.key)) continue;
+        instance.scope?.cleanup();
+        instance.element.remove();
+      }
+      for (let offset = 0; offset < nextWindow.length; offset += 1) {
+        const bindingUpdates = preparedBindings[offset];
+        if (bindingUpdates) {
+          const instance = nextWindow[offset];
+          applyPreparedKeyedRowBindingUpdates(props, instance, bindingUpdates);
+          instance.item = incomingItems[offset];
+          instance.index = update.position + offset;
+        }
+      }
+      reorderCompilerKeyedRows(root, nextWindow, sequence, anchor || null);
+      previousInstances.splice(update.position, update.removedCount, ...nextWindow);
+      return new Map(previousInstances.map((instance) => [instance.key, instance]));
+    }
+  }
+  const knownKeys = new Set(instances.keys());
+  const incoming = [];
+  try {
+    for (let offset = 0; offset < update.insertedCount; offset += 1) {
+      const index = update.position + offset;
+      const item = incomingItems[offset];
+      const key = incomingKeys[offset];
+      if (knownKeys.has(key)) return void 0;
+      knownKeys.add(key);
+      const descriptor = props.create(item, index);
+      incoming.push({
+        key,
+        element: createCompilerHostElement(root.ownerDocument, descriptor),
+        values: readKeyedRowBindingValues(props, item, index),
+        item,
+        index,
+        conditionalValues: EMPTY_KEYED_ROW_CONDITIONAL_VALUES
+      });
+    }
+  } catch {
+    return void 0;
+  }
+  for (const instance of removed) {
+    instance.scope?.cleanup();
+    instance.element.remove();
+  }
+  if (incoming.length > 0) {
+    const fragment = root.ownerDocument.createDocumentFragment();
+    for (const instance of incoming) fragment.append(instance.element);
+    root.insertBefore(fragment, anchor || null);
+  }
+  previousInstances.splice(update.position, update.removedCount, ...incoming);
+  for (let index = update.position + update.insertedCount; index < previousInstances.length; index += 1) {
+    previousInstances[index].index = index;
+  }
+  return new Map(previousInstances.map((instance) => [instance.key, instance]));
+}
+function reconcileCompilerKeyedArrayPositionWithBatch(...args) {
+  return reconcileCompilerKeyedArrayBatchInsert(...args) || reconcileCompilerKeyedArrayPosition(...args);
+}
+function reconcileCompilerKeyedArrayPositionWithWindow(...args) {
+  return reconcileCompilerKeyedArrayWindowReplace(...args) || reconcileCompilerKeyedArrayBatchInsert(...args) || reconcileCompilerKeyedArrayPosition(...args);
+}
 function reconcileCompilerKeyedArrayReorder(props, dirtyState, collectionToken, instances, root, reactOwnedRows) {
   if (reactOwnedRows || props.hostBlocks || (props.conditionals?.length || 0) > 0 || !props.reorderIndexIndependent || props.collectionDependency === void 0) {
     return void 0;
@@ -2828,8 +3333,47 @@ function reconcileCompilerKeyedArrayReorder(props, dirtyState, collectionToken,
   }
   const finalValue = props.items();
   const update = compilerKeyedArrayReorder(finalValue, collectionToken, instances.size);
-  if (!update || update.kind !== "reverse" || !Array.isArray(finalValue)) return void 0;
+  if (!update || !Array.isArray(finalValue)) return void 0;
   const previousInstances = [...instances.values()];
+  if (update.kind === "sort") {
+    const instancesByItem = /* @__PURE__ */ new Map();
+    try {
+      for (let sourceIndex = 0; sourceIndex < previousInstances.length; sourceIndex += 1) {
+        const instance = previousInstances[sourceIndex];
+        if (instance.index !== sourceIndex || instancesByItem.has(instance.item)) return void 0;
+        instancesByItem.set(instance.item, instance);
+      }
+      const nextInstances = [];
+      const sequence = [];
+      for (let targetIndex = 0; targetIndex < finalValue.length; targetIndex += 1) {
+        const item = finalValue[targetIndex];
+        const instance = instancesByItem.get(item);
+        if (!instance || !Object.is(instance.item, item)) return void 0;
+        instancesByItem.delete(item);
+        nextInstances.push(instance);
+        sequence.push(instance.index);
+      }
+      if (instancesByItem.size > 0) return void 0;
+      const activeElement2 = root.ownerDocument.activeElement;
+      const restoreFocus2 = Boolean(activeElement2 && root.contains(activeElement2));
+      const stablePositions = longestIncreasingSubsequencePositions(sequence);
+      let anchor2 = null;
+      for (let index = nextInstances.length - 1; index >= 0; index -= 1) {
+        const instance = nextInstances[index];
+        if (!stablePositions.has(index) && instance.element.nextSibling !== anchor2) {
+          root.insertBefore(instance.element, anchor2);
+        }
+        anchor2 = instance.element;
+        instance.index = index;
+      }
+      if (restoreFocus2 && activeElement2?.isConnected && activeElement2.ownerDocument.activeElement !== activeElement2 && "focus" in activeElement2) {
+        activeElement2.focus({ preventScroll: true });
+      }
+      return new Map(nextInstances.map((instance) => [instance.key, instance]));
+    } catch {
+      return void 0;
+    }
+  }
   try {
     for (let sourceIndex = 0; sourceIndex < previousInstances.length; sourceIndex += 1) {
       const instance = previousInstances[sourceIndex];
@@ -3753,8 +4297,6 @@ function createKeyedRowsBlockComponent(owner, options = {}) {
       }
       if (this.reconcileStableRows(rows, afterCommit, dirtyState)) return;
       if (this.reconcileSingleRemoval(rows, afterCommit, dirtyState)) return;
-      const activeElement = this.root.ownerDocument.activeElement;
-      const restoreFocus = Boolean(activeElement && this.root.contains(activeElement));
       const nextKeys = new Set(rows.keys);
       const hasSurvivingRows = rows.keys.some((key) => this.instances.has(key));
       const oldIndices = /* @__PURE__ */ new Map();
@@ -3768,7 +4310,6 @@ function createKeyedRowsBlockComponent(owner, options = {}) {
         }
       }
       const sequence = hasSurvivingRows ? rows.keys.map((key) => oldIndices.get(key) ?? -1) : rows.keys.map(() => -1);
-      const stablePositions = hasSurvivingRows ? longestIncreasingSubsequencePositions(sequence) : /* @__PURE__ */ new Set();
       const nextInstances = [];
       const conditionalChanges = [];
       for (let index = 0; index < rows.items.length; index += 1) {
@@ -3833,34 +4374,12 @@ function createKeyedRowsBlockComponent(owner, options = {}) {
         for (const instance of nextInstances) fragment.append(instance.element);
         this.root.replaceChildren(fragment);
       } else {
-        let anchor = null;
-        for (let index = nextInstances.length - 1; index >= 0; index -= 1) {
-          const instance = nextInstances[index];
-          if (sequence[index] < 0) {
-            let start = index;
-            while (start > 0 && sequence[start - 1] < 0) start -= 1;
-            const fragment = this.root.ownerDocument.createDocumentFragment();
-            for (let itemIndex = start; itemIndex <= index; itemIndex += 1) {
-              fragment.append(nextInstances[itemIndex].element);
-            }
-            this.root.insertBefore(fragment, anchor);
-            anchor = nextInstances[start].element;
-            index = start;
-          } else {
-            if (!stablePositions.has(index) && instance.element.nextSibling !== anchor) {
-              this.root.insertBefore(instance.element, anchor);
-            }
-            anchor = instance.element;
-          }
-        }
+        reorderCompilerKeyedRows(this.root, nextInstances, sequence, null);
       }
       this.instances = new Map(nextInstances.map((instance) => [instance.key, instance]));
       this.rebuildElementIndex(this.instances);
       this.pruneEventHandlers(rows.keys);
       this.pruneConditionalListeners(rows.keys);
-      if (restoreFocus && activeElement?.isConnected && activeElement.ownerDocument.activeElement !== activeElement && "focus" in activeElement) {
-        activeElement.focus({ preventScroll: true });
-      }
       this.commitCurrentCollection(dirtyState);
       this.notifyConditionalChanges(conditionalChanges, afterCommit);
     }
@@ -4350,6 +4869,22 @@ var keyedRowsPositionHintedRuntimeFeature = {
     })
   })
 };
+var keyedRowsBatchPositionHintedRuntimeFeature = {
+  name: "keyed-rows:batch-position-hinted",
+  create: (owner) => ({
+    KeyedRows: createKeyedRowsBlockComponent(owner, {
+      keyedUpdates: keyedBatchPositionUpdateRuntime
+    })
+  })
+};
+var keyedRowsWindowPositionHintedRuntimeFeature = {
+  name: "keyed-rows:window-position-hinted",
+  create: (owner) => ({
+    KeyedRows: createKeyedRowsBlockComponent(owner, {
+      keyedUpdates: keyedWindowPositionUpdateRuntime
+    })
+  })
+};
 var keyedRowsReorderHintedRuntimeFeature = {
   name: "keyed-rows:reorder-hinted",
   create: (owner) => ({
@@ -4374,6 +4909,22 @@ var keyedRowsEveryHintedRuntimeFeature = {
     })
   })
 };
+var keyedRowsBatchEveryHintedRuntimeFeature = {
+  name: "keyed-rows:batch-every-hinted",
+  create: (owner) => ({
+    KeyedRows: createKeyedRowsBlockComponent(owner, {
+      keyedUpdates: keyedBatchEveryUpdateRuntime
+    })
+  })
+};
+var keyedRowsWindowEveryHintedRuntimeFeature = {
+  name: "keyed-rows:window-every-hinted",
+  create: (owner) => ({
+    KeyedRows: createKeyedRowsBlockComponent(owner, {
+      keyedUpdates: keyedWindowEveryUpdateRuntime
+    })
+  })
+};
 var keyedRowsFilterHintedRuntimeFeature = {
   name: "keyed-rows:filter-hinted",
   create: (owner) => ({
@@ -4424,6 +4975,24 @@ var keyedRowsConditionalPositionHintedRuntimeFeature = {
     })
   })
 };
+var keyedRowsConditionalBatchPositionHintedRuntimeFeature = {
+  name: "keyed-rows:conditional:batch-position-hinted",
+  create: (owner) => ({
+    KeyedRows: createKeyedRowsBlockComponent(owner, {
+      conditionals: createKeyedRowConditionalRuntime(),
+      keyedUpdates: keyedBatchPositionUpdateRuntime
+    })
+  })
+};
+var keyedRowsConditionalWindowPositionHintedRuntimeFeature = {
+  name: "keyed-rows:conditional:window-position-hinted",
+  create: (owner) => ({
+    KeyedRows: createKeyedRowsBlockComponent(owner, {
+      conditionals: createKeyedRowConditionalRuntime(),
+      keyedUpdates: keyedWindowPositionUpdateRuntime
+    })
+  })
+};
 var keyedRowsConditionalReorderHintedRuntimeFeature = {
   name: "keyed-rows:conditional:reorder-hinted",
   create: (owner) => ({
@@ -4451,6 +5020,24 @@ var keyedRowsConditionalEveryHintedRuntimeFeature = {
     })
   })
 };
+var keyedRowsConditionalBatchEveryHintedRuntimeFeature = {
+  name: "keyed-rows:conditional:batch-every-hinted",
+  create: (owner) => ({
+    KeyedRows: createKeyedRowsBlockComponent(owner, {
+      conditionals: createKeyedRowConditionalRuntime(),
+      keyedUpdates: keyedBatchEveryUpdateRuntime
+    })
+  })
+};
+var keyedRowsConditionalWindowEveryHintedRuntimeFeature = {
+  name: "keyed-rows:conditional:window-every-hinted",
+  create: (owner) => ({
+    KeyedRows: createKeyedRowsBlockComponent(owner, {
+      conditionals: createKeyedRowConditionalRuntime(),
+      keyedUpdates: keyedWindowEveryUpdateRuntime
+    })
+  })
+};
 var keyedRowsConditionalFilterHintedRuntimeFeature = {
   name: "keyed-rows:conditional:filter-hinted",
   create: (owner) => ({
@@ -4504,6 +5091,24 @@ var keyedRowsHostPositionHintedRuntimeFeature = {
     })
   })
 };
+var keyedRowsHostBatchPositionHintedRuntimeFeature = {
+  name: "keyed-rows:host:batch-position-hinted",
+  create: (owner) => ({
+    KeyedRows: createKeyedRowsBlockComponent(owner, {
+      hostBlocks: createKeyedRowHostRuntime(),
+      keyedUpdates: keyedBatchPositionUpdateRuntime
+    })
+  })
+};
+var keyedRowsHostWindowPositionHintedRuntimeFeature = {
+  name: "keyed-rows:host:window-position-hinted",
+  create: (owner) => ({
+    KeyedRows: createKeyedRowsBlockComponent(owner, {
+      hostBlocks: createKeyedRowHostRuntime(),
+      keyedUpdates: keyedWindowPositionUpdateRuntime
+    })
+  })
+};
 var keyedRowsHostReorderHintedRuntimeFeature = {
   name: "keyed-rows:host:reorder-hinted",
   create: (owner) => ({
@@ -4531,6 +5136,24 @@ var keyedRowsHostEveryHintedRuntimeFeature = {
     })
   })
 };
+var keyedRowsHostBatchEveryHintedRuntimeFeature = {
+  name: "keyed-rows:host:batch-every-hinted",
+  create: (owner) => ({
+    KeyedRows: createKeyedRowsBlockComponent(owner, {
+      hostBlocks: createKeyedRowHostRuntime(),
+      keyedUpdates: keyedBatchEveryUpdateRuntime
+    })
+  })
+};
+var keyedRowsHostWindowEveryHintedRuntimeFeature = {
+  name: "keyed-rows:host:window-every-hinted",
+  create: (owner) => ({
+    KeyedRows: createKeyedRowsBlockComponent(owner, {
+      hostBlocks: createKeyedRowHostRuntime(),
+      keyedUpdates: keyedWindowEveryUpdateRuntime
+    })
+  })
+};
 var keyedRowsHostFilterHintedRuntimeFeature = {
   name: "keyed-rows:host:filter-hinted",
   create: (owner) => ({
@@ -4587,6 +5210,26 @@ var keyedRowsCompletePositionHintedRuntimeFeature = {
     })
   })
 };
+var keyedRowsCompleteBatchPositionHintedRuntimeFeature = {
+  name: "keyed-rows:complete:batch-position-hinted",
+  create: (owner) => ({
+    KeyedRows: createKeyedRowsBlockComponent(owner, {
+      conditionals: createKeyedRowConditionalRuntime(),
+      hostBlocks: createKeyedRowHostRuntime(),
+      keyedUpdates: keyedBatchPositionUpdateRuntime
+    })
+  })
+};
+var keyedRowsCompleteWindowPositionHintedRuntimeFeature = {
+  name: "keyed-rows:complete:window-position-hinted",
+  create: (owner) => ({
+    KeyedRows: createKeyedRowsBlockComponent(owner, {
+      conditionals: createKeyedRowConditionalRuntime(),
+      hostBlocks: createKeyedRowHostRuntime(),
+      keyedUpdates: keyedWindowPositionUpdateRuntime
+    })
+  })
+};
 var keyedRowsCompleteReorderHintedRuntimeFeature = {
   name: "keyed-rows:complete:reorder-hinted",
   create: (owner) => ({
@@ -4617,6 +5260,26 @@ var keyedRowsCompleteEveryHintedRuntimeFeature = {
     })
   })
 };
+var keyedRowsCompleteBatchEveryHintedRuntimeFeature = {
+  name: "keyed-rows:complete:batch-every-hinted",
+  create: (owner) => ({
+    KeyedRows: createKeyedRowsBlockComponent(owner, {
+      conditionals: createKeyedRowConditionalRuntime(),
+      hostBlocks: createKeyedRowHostRuntime(),
+      keyedUpdates: keyedBatchEveryUpdateRuntime
+    })
+  })
+};
+var keyedRowsCompleteWindowEveryHintedRuntimeFeature = {
+  name: "keyed-rows:complete:window-every-hinted",
+  create: (owner) => ({
+    KeyedRows: createKeyedRowsBlockComponent(owner, {
+      conditionals: createKeyedRowConditionalRuntime(),
+      hostBlocks: createKeyedRowHostRuntime(),
+      keyedUpdates: keyedWindowEveryUpdateRuntime
+    })
+  })
+};
 var keyedRowsCompleteFilterHintedRuntimeFeature = {
   name: "keyed-rows:complete:filter-hinted",
   create: (owner) => ({
@@ -5119,7 +5782,7 @@ var COMPLETE_RUNTIME_FEATURES = [
   hostConditionalRuntimeFeature,
   conditionalRangesRuntimeFeature,
   keyedListRuntimeFeature,
-  keyedRowsCompleteEveryHintedRuntimeFeature,
+  keyedRowsCompleteWindowEveryHintedRuntimeFeature,
   keyedRangesRuntimeFeature,
   mixedRangesRuntimeFeature,
   componentRuntimeFeature
@@ -5128,6 +5791,6 @@ function createCompiledComponent(definition) {
   return createCompiledComponentWithFeatures(definition, COMPLETE_RUNTIME_FEATURES);
 }
 
-export { applyCompilerKeyedCollectionMutation, componentRuntimeFeature, conditionalRangesRuntimeFeature, conditionalRuntimeFeature, createCompiledComponent, createCompiledComponentWithFeatures, createCompilerKeyedArrayAppend, createCompilerKeyedArrayFilter, createCompilerKeyedArrayPositionUpdate, createCompilerKeyedArrayPrepend, createCompilerKeyedArrayReorder, createCompilerKeyedArrayRollingWindow, createCompilerKeyedArraySlice, createCompilerKeyedCollectionUpdate, createCompilerKeyedMapUpdate, hostConditionalRuntimeFeature, keyedListRuntimeFeature, keyedRangesRuntimeFeature, keyedRowsAllHintedRuntimeFeature, keyedRowsCompleteAllHintedRuntimeFeature, keyedRowsCompleteEveryHintedRuntimeFeature, keyedRowsCompleteFilterHintedRuntimeFeature, keyedRowsCompleteFilterPrependHintedRuntimeFeature, keyedRowsCompleteHintedRuntimeFeature, keyedRowsCompletePositionHintedRuntimeFeature, keyedRowsCompletePrependHintedRuntimeFeature, keyedRowsCompleteReorderHintedRuntimeFeature, keyedRowsCompleteRuntimeFeature, keyedRowsConditionalAllHintedRuntimeFeature, keyedRowsConditionalEveryHintedRuntimeFeature, keyedRowsConditionalFilterHintedRuntimeFeature, keyedRowsConditionalFilterPrependHintedRuntimeFeature, keyedRowsConditionalHintedRuntimeFeature, keyedRowsConditionalPositionHintedRuntimeFeature, keyedRowsConditionalPrependHintedRuntimeFeature, keyedRowsConditionalReorderHintedRuntimeFeature, keyedRowsConditionalRuntimeFeature, keyedRowsEveryHintedRuntimeFeature, keyedRowsFilterHintedRuntimeFeature, keyedRowsFilterPrependHintedRuntimeFeature, keyedRowsHintedRuntimeFeature, keyedRowsHostAllHintedRuntimeFeature, keyedRowsHostEveryHintedRuntimeFeature, keyedRowsHostFilterHintedRuntimeFeature, keyedRowsHostFilterPrependHintedRuntimeFeature, keyedRowsHostHintedRuntimeFeature, keyedRowsHostPositionHintedRuntimeFeature, keyedRowsHostPrependHintedRuntimeFeature, keyedRowsHostReorderHintedRuntimeFeature, keyedRowsHostRuntimeFeature, keyedRowsPositionHintedRuntimeFeature, keyedRowsPrependHintedRuntimeFeature, keyedRowsReorderHintedRuntimeFeature, keyedRowsRuntimeFeature, mixedRangesRuntimeFeature };
+export { applyCompilerKeyedCollectionMutation, componentRuntimeFeature, conditionalRangesRuntimeFeature, conditionalRuntimeFeature, createCompiledComponent, createCompiledComponentWithFeatures, createCompilerKeyedArrayAppend, createCompilerKeyedArrayBatchInsert, createCompilerKeyedArrayFilter, createCompilerKeyedArrayPositionUpdate, createCompilerKeyedArrayPrepend, createCompilerKeyedArrayReorder, createCompilerKeyedArrayRollingWindow, createCompilerKeyedArraySlice, createCompilerKeyedArraySort, createCompilerKeyedArrayWindowReplace, createCompilerKeyedCollectionUpdate, createCompilerKeyedMapUpdate, hostConditionalRuntimeFeature, keyedListRuntimeFeature, keyedRangesRuntimeFeature, keyedRowsAllHintedRuntimeFeature, keyedRowsBatchEveryHintedRuntimeFeature, keyedRowsBatchPositionHintedRuntimeFeature, keyedRowsCompleteAllHintedRuntimeFeature, keyedRowsCompleteBatchEveryHintedRuntimeFeature, keyedRowsCompleteBatchPositionHintedRuntimeFeature, keyedRowsCompleteEveryHintedRuntimeFeature, keyedRowsCompleteFilterHintedRuntimeFeature, keyedRowsCompleteFilterPrependHintedRuntimeFeature, keyedRowsCompleteHintedRuntimeFeature, keyedRowsCompletePositionHintedRuntimeFeature, keyedRowsCompletePrependHintedRuntimeFeature, keyedRowsCompleteReorderHintedRuntimeFeature, keyedRowsCompleteRuntimeFeature, keyedRowsCompleteWindowEveryHintedRuntimeFeature, keyedRowsCompleteWindowPositionHintedRuntimeFeature, keyedRowsConditionalAllHintedRuntimeFeature, keyedRowsConditionalBatchEveryHintedRuntimeFeature, keyedRowsConditionalBatchPositionHintedRuntimeFeature, keyedRowsConditionalEveryHintedRuntimeFeature, keyedRowsConditionalFilterHintedRuntimeFeature, keyedRowsConditionalFilterPrependHintedRuntimeFeature, keyedRowsConditionalHintedRuntimeFeature, keyedRowsConditionalPositionHintedRuntimeFeature, keyedRowsConditionalPrependHintedRuntimeFeature, keyedRowsConditionalReorderHintedRuntimeFeature, keyedRowsConditionalRuntimeFeature, keyedRowsConditionalWindowEveryHintedRuntimeFeature, keyedRowsConditionalWindowPositionHintedRuntimeFeature, keyedRowsEveryHintedRuntimeFeature, keyedRowsFilterHintedRuntimeFeature, keyedRowsFilterPrependHintedRuntimeFeature, keyedRowsHintedRuntimeFeature, keyedRowsHostAllHintedRuntimeFeature, keyedRowsHostBatchEveryHintedRuntimeFeature, keyedRowsHostBatchPositionHintedRuntimeFeature, keyedRowsHostEveryHintedRuntimeFeature, keyedRowsHostFilterHintedRuntimeFeature, keyedRowsHostFilterPrependHintedRuntimeFeature, keyedRowsHostHintedRuntimeFeature, keyedRowsHostPositionHintedRuntimeFeature, keyedRowsHostPrependHintedRuntimeFeature, keyedRowsHostReorderHintedRuntimeFeature, keyedRowsHostRuntimeFeature, keyedRowsHostWindowEveryHintedRuntimeFeature, keyedRowsHostWindowPositionHintedRuntimeFeature, keyedRowsPositionHintedRuntimeFeature, keyedRowsPrependHintedRuntimeFeature, keyedRowsReorderHintedRuntimeFeature, keyedRowsRuntimeFeature, keyedRowsWindowEveryHintedRuntimeFeature, keyedRowsWindowPositionHintedRuntimeFeature, mixedRangesRuntimeFeature };
 //# sourceMappingURL=compiler-runtime.mjs.map
 //# sourceMappingURL=compiler-runtime.mjs.map