unframer 2.7.7 → 2.7.9

package/src/framer.js

@@ -5481,9 +5481,9 @@ function velocityPerSecond(velocity, frameDuration,) {
   return frameDuration ? velocity * (1e3 / frameDuration) : 0;
 }
 var velocitySampleDuration = 5;
-function calcGeneratorVelocity(resolveValue2, t, current,) {
+function calcGeneratorVelocity(resolveValue, t, current,) {
   const prevT = Math.max(t - velocitySampleDuration, 0,);
-  return velocityPerSecond(current - resolveValue2(prevT,), t - prevT,);
+  return velocityPerSecond(current - resolveValue(prevT,), t - prevT,);
 }
 var durationKeys = ['duration', 'bounce',];
 var physicsKeys = ['stiffness', 'damping', 'mass',];
@@ -15349,7 +15349,7 @@ function steps(numSteps, direction = 'end',) {
   };
 }
 
-// https :https://app.framerstatic.com/framer.7SGKTLCE.mjs
+// https :https://app.framerstatic.com/framer.ZONHQAMM.mjs
 init_chunk_QLPHEVXG();
 import React4 from 'react';
 import { startTransition as startTransition2, } from 'react';
@@ -16807,39 +16807,6 @@ var require_hoist_non_react_statics_cjs = __commonJS({
     module.exports = hoistNonReactStatics;
   },
 },);
-var require_archy = __commonJS({
-  '../../../node_modules/archy/index.js'(exports, module,) {
-    module.exports = function archy2(obj, prefix2, opts,) {
-      if (prefix2 === void 0) prefix2 = '';
-      if (!opts) opts = {};
-      var chr = function (s,) {
-        var chars = {
-          '\u2502': '|',
-          '\u2514': '`',
-          '\u251C': '+',
-          '\u2500': '-',
-          '\u252C': '-',
-        };
-        return opts.unicode === false ? chars[s] : s;
-      };
-      if (typeof obj === 'string') {
-        obj = {
-          label: obj,
-        };
-      }
-      var nodes = obj.nodes || [];
-      var lines = (obj.label || '').split('\n',);
-      var splitter = '\n' + prefix2 + (nodes.length ? chr('\u2502',) : ' ') + ' ';
-      return prefix2 + lines.join(splitter,) + '\n' + nodes.map(function (node, ix,) {
-        var last = ix === nodes.length - 1;
-        var more = node.nodes && node.nodes.length;
-        var prefix_ = prefix2 + (last ? ' ' : chr('\u2502',)) + ' ';
-        return prefix2 + (last ? chr('\u2514',) : chr('\u251C',)) + chr('\u2500',) + (more ? chr('\u252C',) : chr('\u2500',)) + ' ' +
-          archy2(node, prefix_, opts,).slice(prefix2.length + 2,);
-      },).join('',);
-    };
-  },
-},);
 var require_fontfaceobserver_standalone = __commonJS({
   '../../../node_modules/fontfaceobserver/fontfaceobserver.standalone.js'(exports, module,) {
     (function () {
@@ -18247,6 +18214,7 @@ function useMarkRouterEffects() {
 var hydrationInsertionEffectStartHasRun = false;
 var hydrationLayoutEffectStartHasRun = false;
 var hydrationEffectStartHasRun = false;
+var wasInBackground = false;
 function useMarkSuspenseEffectsStart() {
   const hydrationMarkPrefix = 'framer-hydration-';
   const hydrationLayoutEffectsEnd = `${hydrationMarkPrefix}layout-effects-end`;
@@ -18264,6 +18232,10 @@ function useMarkSuspenseEffectsStart() {
     if (hydrationLayoutEffectStartHasRun || !shouldMark) return;
     hydrationLayoutEffectStartHasRun = true;
     performance.mark(`${hydrationMarkPrefix}layout-effects-start`,);
+    if (document.visibilityState !== 'visible') {
+      wasInBackground = true;
+      return;
+    }
     requestAnimationFrame(() => {
       var _a, _b, _c;
       performance.mark(hydrationBrowserRenderStart,);
@@ -18298,7 +18270,6 @@ function useMarkSuspenseEffectsStart() {
 var hydrationInsertionEffectHasRun = false;
 var hydrationLayoutEffectHasRun = false;
 var hydrationEffectHasRun = false;
-var hydrationPaintEffectHasRun = false;
 function useMarkSuspenseEffectEnd() {
   const hydrationMarkPrefix = 'framer-hydration-';
   const hydrationLayoutEffectsEnd = `${hydrationMarkPrefix}layout-effects-end`;
@@ -18319,9 +18290,15 @@ function useMarkSuspenseEffectEnd() {
     hydrationLayoutEffectHasRun = true;
     performance.mark(hydrationLayoutEffectsEnd,);
     measureSafe(`${hydrationMarkPrefix}layout-effects`, `${hydrationMarkPrefix}layout-effects-start`, hydrationLayoutEffectsEnd,);
+    if (wasInBackground || document.visibilityState !== 'visible') return;
     requestAnimationFrame(() => {
       performance.mark(hydrationAnimationFrameEnd,);
       measureSafe(`${hydrationMarkPrefix}raf`, hydrationBrowserRenderStart, hydrationAnimationFrameEnd,);
+      void yieldBefore(() => {
+        performance.mark(hydrationFP,);
+        measureSafe(`${hydrationMarkPrefix}time-to-first-paint`, hydrationStart, hydrationFP,);
+        measureSafe(`${hydrationMarkPrefix}browser-render`, hydrationAnimationFrameEnd, hydrationFP,);
+      },);
     },);
   }, [],);
   useEffect(() => {
@@ -18339,22 +18316,6 @@ function useMarkSuspenseEffectEnd() {
       hydrationEffectsEnd,
     );
   }, [],);
-  useAfterPaintEffect(
-    () => {
-      if (hydrationPaintEffectHasRun || !shouldMark) return;
-      hydrationPaintEffectHasRun = true;
-      performance.mark(hydrationFP,);
-      measureSafe(`${hydrationMarkPrefix}time-to-first-paint`, hydrationStart, hydrationFP,);
-      queueMicrotask(() => {
-        measureSafe(`${hydrationMarkPrefix}browser-render`, hydrationAnimationFrameEnd, hydrationFP,);
-      },);
-    },
-    [],
-    // user-blocking ensures we get the correct timings here. Other priorites might delay this effect a little bit.
-    {
-      priority: 'user-blocking',
-    },
-  );
   return null;
 }
 function MarkSuspenseEffectsStart() {
@@ -23651,7 +23612,8 @@ function getConstraintValue(constraint, value, parentSize, viewport,) {
           break;
       }
     }
-    if (value.endsWith('vh',) && viewport) {
+    if (value.endsWith('vh',)) {
+      if (!viewport) return constraintValueForUncalculatedViewport(constraint,);
       switch (constraint) {
         case 'maxWidth':
         case 'minWidth':
@@ -23667,6 +23629,18 @@ function getConstraintValue(constraint, value, parentSize, viewport,) {
   }
   return value;
 }
+function constraintValueForUncalculatedViewport(constraint,) {
+  switch (constraint) {
+    case 'minWidth':
+    case 'minHeight':
+      return Number.NEGATIVE_INFINITY;
+    case 'maxWidth':
+    case 'maxHeight':
+      return Number.POSITIVE_INFINITY;
+    default:
+      assertNever(constraint, 'unknown constraint key',);
+  }
+}
 function constrainHeight(height, values, parentSize, viewport,) {
   if (values.minHeight) {
     height = Math.max(getConstraintValue('minHeight', values.minHeight, parentSize, viewport,), height,);
@@ -23708,18 +23682,6 @@ function pinnedOffset(start, end,) {
   if (!isFiniteNumber(start,) || !isFiniteNumber(end,)) return null;
   return start + end;
 }
-function getMergedConstraintsProps(props, constraints,) {
-  const result = {};
-  if (props.constraints) {
-    result.constraints = {
-      ...props.constraints,
-      ...constraints,
-    };
-  } else {
-    Object.assign(result, constraints,);
-  }
-  return result;
-}
 function containsInvalidStringValues(props,) {
   if (typeof props.right === 'string') return true;
   if (typeof props.bottom === 'string') return true;
@@ -24101,8 +24063,8 @@ var richTextLinkHoverStylesRule = `
 }
 `;
 var richTextLinkCurrentStylesRule = `
-a[data-framer-page-link-current],
-a[data-framer-page-link-current] span:not([data-text-fill]):not([data-nested-link]) {
+[data-framer-component-type="DeprecatedRichText"] a[data-framer-page-link-current],
+[data-framer-component-type="DeprecatedRichText"] a[data-framer-page-link-current] span:not([data-text-fill]):not([data-nested-link]) {
     font-family: var(--framer-link-current-font-family, var(--framer-link-font-family, var(--framer-font-family, Inter, Inter Placeholder, sans-serif)));
     font-style: var(--framer-link-current-font-style, var(--framer-link-font-style, var(--framer-font-style, normal)));
     font-weight: var(--framer-link-current-font-weight, var(--framer-link-font-weight, var(--framer-font-weight, 400)));
@@ -24113,8 +24075,8 @@ a[data-framer-page-link-current] span:not([data-text-fill]):not([data-nested-lin
 }
 `;
 var richTextLinkCurrentHoverStylesRule = `
-a[data-framer-page-link-current]:hover,
-a[data-framer-page-link-current]:hover span:not([data-text-fill]):not([data-nested-link]) {
+[data-framer-component-type="DeprecatedRichText"] a[data-framer-page-link-current]:hover,
+[data-framer-component-type="DeprecatedRichText"] a[data-framer-page-link-current]:hover span:not([data-text-fill]):not([data-nested-link]) {
     font-family: var(--framer-link-hover-font-family, var(--framer-link-current-font-family, var(--framer-link-font-family, var(--framer-font-family, Inter, Inter Placeholder, sans-serif))));
     font-style: var(--framer-link-hover-font-style, var(--framer-link-current-font-style, var(--framer-link-font-style, var(--framer-font-style, normal))));
     font-weight: var(--framer-link-hover-font-weight, var(--framer-link-current-font-weight, var(--framer-link-font-weight, var(--framer-font-weight, 400))));
@@ -37543,20 +37505,17 @@ var NestedLinksCollector = class {
     this.links.clear();
   }
   getLinks() {
-    return [...this.links.values(),];
+    return this.links;
   }
-  addLink(parentLink, linkData,) {
-    if (typeof window !== 'undefined' && true || !parentLink || !linkData) {
+  addLink(parentLinkNodeId, linkNodeId,) {
+    if (typeof window !== 'undefined' && true || !parentLinkNodeId || !linkNodeId) {
       return;
     }
-    if (!this.links.has(parentLink.nodeId,)) {
-      this.links.set(parentLink.nodeId, {
-        parent: parentLink,
-        links: [],
-      },);
+    if (!this.links.has(parentLinkNodeId,)) {
+      this.links.set(parentLinkNodeId, /* @__PURE__ */ new Set(),);
     }
-    const entry = this.links.get(parentLink.nodeId,);
-    entry.links.push(linkData,);
+    const entry = this.links.get(parentLinkNodeId,);
+    entry.add(linkNodeId,);
   }
 };
 var nestedLinksCollector = /* @__PURE__ */ new NestedLinksCollector();
@@ -38054,20 +38013,18 @@ var Link = /* @__PURE__ */ withChildrenCanSuspend(/* @__PURE__ */ forwardRef(({
     if (node === null) return;
     return observerCallback(node,);
   }, [observerCallback,],);
-  const el = useMemo(() => {
-    const {
-      navigate: _,
-      ...linkProps
-    } = props;
-    return clone.cloneAsArray(children, {
-      ...restProps,
-      ...linkProps,
-      ref: observerRef,
-    },);
-  }, [props, clone, children, restProps, observerRef,],);
+  const {
+    navigate: _,
+    ...linkProps
+  } = props;
+  const el = clone.cloneAsArray(children, {
+    ...restProps,
+    ...linkProps,
+    ref: observerRef,
+  },);
   return getChildren(el,);
 },),);
-var ParentLinkContext = /* @__PURE__ */ createContext(null,);
+var ParentLinkContext = /* @__PURE__ */ createContext(void 0,);
 function useReplaceNestedLinks(nodeId, href, propsAddedByLink,) {
   const parentLink = useContext(ParentLinkContext,);
   const isOnFramerCanvas = useIsOnFramerCanvas();
@@ -38081,30 +38038,6 @@ function useReplaceNestedLinks(nodeId, href, propsAddedByLink,) {
     if (!pageLink) return;
     return getRouteFromPageLink(pageLink, router, currentRoute,);
   }, [currentRoute, href, router,],);
-  const linkData = useMemo(() => {
-    if (!nodeId || !href) return null;
-    if (isLinkToWebPage(href,)) {
-      return {
-        nodeId,
-        targetNodeId: href.webPageId,
-        href: propsAddedByLink.href,
-      };
-    }
-    if (route && href.startsWith('#',)) {
-      const routeNodeId = Object.keys(route.elements ?? {},)[0];
-      if (routeNodeId) {
-        return {
-          nodeId,
-          targetNodeId: routeNodeId,
-          href,
-        };
-      }
-    }
-    return {
-      nodeId,
-      href,
-    };
-  }, [href, nodeId, propsAddedByLink, route,],);
   const isValidLink = Object.keys(propsAddedByLink,).length > 0;
   const shouldReplaceLink = Boolean(replaceNestedLinks && !isOnFramerCanvas && (parentLink || !isValidLink),);
   const onClick = useCallback((event) => {
@@ -38153,7 +38086,7 @@ function useReplaceNestedLinks(nodeId, href, propsAddedByLink,) {
     };
     const replacedChildren = !shouldReplaceLink ? children : Children.map(children, (child) => {
       if (!isChildReplaceable(child,)) return child;
-      nestedLinksCollector.addLink(parentLink, linkData,);
+      nestedLinksCollector.addLink(parentLink, nodeId,);
       const tag = maybeReplaceAnchorWithSpan(child.type,);
       const {
         children: childChildren,
@@ -38174,10 +38107,10 @@ function useReplaceNestedLinks(nodeId, href, propsAddedByLink,) {
       }, childChildren,);
     },);
     return /* @__PURE__ */ jsx(ParentLinkContext.Provider, {
-      value: linkData,
+      value: nodeId,
       children: replacedChildren,
     },);
-  }, [isValidLink, linkData, onAuxClick, onClick, onKeyDown, shouldReplaceLink, parentLink,],);
+  }, [isValidLink, nodeId, onAuxClick, onClick, onKeyDown, shouldReplaceLink, parentLink,],);
   const refCallback = useCallback((node) => {
     if (isOnFramerCanvas || !shouldReplaceLink || !isValidLink) return;
     node.dataset.hydrated = 'true';
@@ -39346,7 +39279,6 @@ var Fetcher = /* @__PURE__ */ React2.forwardRef(function Fetcher2({
   return cloneWithPropsAndRef(childrenWithValues, rest,);
 },);
 var callEach = (...fns) => fns.forEach((fn) => fn && fn());
-var import_archy = __toESM(require_archy(), 1,);
 function getLogger(name,) {
   return {
     trace(...args) {
@@ -39532,10 +39464,6 @@ function castDate(value,) {
   }
   return null;
 }
-function toDate(value,) {
-  const cast = castDate(value,);
-  return (cast == null ? void 0 : cast.value) ?? null;
-}
 function castEnum(value,) {
   switch (value == null ? void 0 : value.type) {
     case 'enum': {
@@ -39992,1464 +39920,6 @@ function compare(left, right, collation10,) {
     }
   }
 }
-var INDEX_IDENTIFIER = 'index';
-var ScalarExpression = class {
-  static from(expression, schema,) {
-    return convertExpression(expression, schema, void 0,);
-  }
-};
-var ScalarIdentifier = class extends ScalarExpression {
-  constructor(schema, name, collection,) {
-    super();
-    this.schema = schema;
-    this.name = name;
-    this.collection = collection;
-    __publicField(this, 'definition',);
-    if (name === INDEX_IDENTIFIER) {
-      this.definition = {
-        type: 'number',
-        isNullable: false,
-      };
-    } else {
-      this.definition = schema[name] ?? null;
-    }
-  }
-  stringify() {
-    return this.name;
-  }
-  equals(other,) {
-    return other instanceof ScalarIdentifier && isEqual(this.definition, other.definition,) && isEqual(other.name, this.name,) &&
-      isEqual(other.collection, this.collection,);
-  }
-  evaluate(item,) {
-    const name = this.name;
-    if (isUndefined(item,) || name === INDEX_IDENTIFIER) {
-      throw new Error(`Can't evaluate identifier: ${name}`,);
-    }
-    if (this.collection) {
-      const scopedName = `${this.collection}_${name}`;
-      return item.data[scopedName] ?? item.data[name] ?? null;
-    }
-    return item.data[name] ?? null;
-  }
-  canEvaluate() {
-    return false;
-  }
-};
-var ScalarLiteralValue = class extends ScalarExpression {
-  constructor(definition, value,) {
-    super();
-    this.definition = definition;
-    this.value = value;
-  }
-  stringify() {
-    return DatabaseValue.stringify(this.value,);
-  }
-  static fromNull() {
-    return new ScalarLiteralValue(null, null,);
-  }
-  static fromBoolean(value,) {
-    return new ScalarLiteralValue(
-      {
-        type: 'boolean',
-        isNullable: isNull(value,),
-      },
-      isNull(value,) ? null : {
-        type: 'boolean',
-        value,
-      },
-    );
-  }
-  static fromDate(value,) {
-    return new ScalarLiteralValue(
-      {
-        type: 'date',
-        isNullable: isNull(value,),
-      },
-      isNull(value,) ? null : {
-        type: 'date',
-        value,
-      },
-    );
-  }
-  static fromEnum(value,) {
-    return new ScalarLiteralValue(
-      {
-        type: 'enum',
-        isNullable: isNull(value,),
-      },
-      isNull(value,) ? null : {
-        type: 'enum',
-        value,
-      },
-    );
-  }
-  static fromNumber(value,) {
-    return new ScalarLiteralValue(
-      {
-        type: 'number',
-        isNullable: isNull(value,),
-      },
-      isNull(value,) ? null : {
-        type: 'number',
-        value,
-      },
-    );
-  }
-  static fromString(value,) {
-    return new ScalarLiteralValue(
-      {
-        type: 'string',
-        isNullable: isNull(value,),
-      },
-      isNull(value,) ? null : {
-        type: 'string',
-        value,
-      },
-    );
-  }
-  equals(other,) {
-    return other instanceof ScalarLiteralValue && isEqual(this.definition, other.definition,) && isEqual(other.value, this.value,);
-  }
-  evaluate() {
-    return this.value;
-  }
-  canEvaluate() {
-    return true;
-  }
-};
-var ScalarFunctionCall = class extends ScalarExpression {
-  constructor(argumentExpressions,) {
-    super();
-    this.argumentExpressions = argumentExpressions;
-    __publicField(this, 'collation', {
-      type: 0,
-      /* CaseInsensitive */
-    },);
-  }
-  getArgumentExpression(index,) {
-    const argument = this.argumentExpressions[index];
-    if (isUndefined(argument,)) {
-      throw new Error('Missing argument in function call',);
-    }
-    return argument;
-  }
-  equals(other,) {
-    return other instanceof ScalarFunctionCall && isEqual(this.constructor, other.constructor,) &&
-      isEqual(this.argumentExpressions, other.argumentExpressions,);
-  }
-  canEvaluate() {
-    return this.argumentExpressions.every((expression) => {
-      return expression.canEvaluate();
-    },);
-  }
-};
-var ScalarFunctionCallContains = class extends ScalarFunctionCall {
-  constructor() {
-    super(...arguments,);
-    __publicField(this, 'definition', ScalarFunctionCallContains.getDefinition(),);
-    __publicField(this, 'sourceExpression', this.getArgumentExpression(0,),);
-    __publicField(this, 'targetExpression', this.getArgumentExpression(1,),);
-  }
-  static getDefinition() {
-    return {
-      type: 'boolean',
-      isNullable: false,
-    };
-  }
-  stringify() {
-    return `CONTAINS(${this.sourceExpression.stringify()}, ${this.targetExpression.stringify()})`;
-  }
-  getValue(source, target,) {
-    if (isNull(source,) || source.type !== 'string') return false;
-    if (isNull(target,) || target.type !== 'string') return false;
-    let sourceValue = source.value;
-    let targetValue = target.value;
-    if (this.collation.type === 0) {
-      sourceValue = sourceValue.toLowerCase();
-      targetValue = targetValue.toLowerCase();
-    }
-    return sourceValue.includes(targetValue,);
-  }
-  evaluate(item,) {
-    const source = this.sourceExpression.evaluate(item,);
-    const target = this.targetExpression.evaluate(item,);
-    return {
-      type: 'boolean',
-      value: this.getValue(source, target,),
-    };
-  }
-};
-var ScalarFunctionCallStartsWith = class extends ScalarFunctionCall {
-  constructor() {
-    super(...arguments,);
-    __publicField(this, 'definition', ScalarFunctionCallStartsWith.getDefinition(),);
-    __publicField(this, 'sourceExpression', this.getArgumentExpression(0,),);
-    __publicField(this, 'targetExpression', this.getArgumentExpression(1,),);
-  }
-  static getDefinition() {
-    return {
-      type: 'boolean',
-      isNullable: false,
-    };
-  }
-  stringify() {
-    return `STARTS_WITH(${this.sourceExpression.stringify()}, ${this.targetExpression.stringify()})`;
-  }
-  getValue(source, target,) {
-    if (isNull(source,) || source.type !== 'string') return false;
-    if (isNull(target,) || target.type !== 'string') return false;
-    let sourceValue = source.value;
-    let targetValue = target.value;
-    if (this.collation.type === 0) {
-      sourceValue = sourceValue.toLowerCase();
-      targetValue = targetValue.toLowerCase();
-    }
-    return sourceValue.startsWith(targetValue,);
-  }
-  evaluate(item,) {
-    const source = this.sourceExpression.evaluate(item,);
-    const target = this.targetExpression.evaluate(item,);
-    return {
-      type: 'boolean',
-      value: this.getValue(source, target,),
-    };
-  }
-};
-var ScalarFunctionCallEndsWith = class extends ScalarFunctionCall {
-  constructor() {
-    super(...arguments,);
-    __publicField(this, 'definition', ScalarFunctionCallEndsWith.getDefinition(),);
-    __publicField(this, 'sourceExpression', this.getArgumentExpression(0,),);
-    __publicField(this, 'targetExpression', this.getArgumentExpression(1,),);
-  }
-  static getDefinition() {
-    return {
-      type: 'boolean',
-      isNullable: false,
-    };
-  }
-  stringify() {
-    return `ENDS_WITH(${this.sourceExpression.stringify()}, ${this.targetExpression.stringify()})`;
-  }
-  getValue(source, target,) {
-    if (isNull(source,) || source.type !== 'string') return false;
-    if (isNull(target,) || target.type !== 'string') return false;
-    let sourceValue = source.value;
-    let targetValue = target.value;
-    if (this.collation.type === 0) {
-      sourceValue = sourceValue.toLowerCase();
-      targetValue = targetValue.toLowerCase();
-    }
-    return sourceValue.endsWith(targetValue,);
-  }
-  evaluate(item,) {
-    const source = this.sourceExpression.evaluate(item,);
-    const target = this.targetExpression.evaluate(item,);
-    return {
-      type: 'boolean',
-      value: this.getValue(source, target,),
-    };
-  }
-};
-var ScalarCase = class extends ScalarExpression {
-  constructor(valueExpression, conditions, elseExpression,) {
-    super();
-    this.valueExpression = valueExpression;
-    this.conditions = conditions;
-    this.elseExpression = elseExpression;
-    __publicField(this, 'definition',);
-    __publicField(this, 'collation', {
-      type: 0,
-      /* CaseInsensitive */
-    },);
-    const definitions = [];
-    for (
-      const {
-        thenExpression,
-      } of conditions
-    ) {
-      definitions.push(thenExpression.definition,);
-    }
-    if (elseExpression) {
-      definitions.push(elseExpression.definition,);
-    }
-    this.definition = ScalarCase.getDefinition(definitions,);
-  }
-  static getDefinition(definitions,) {
-    let result = null;
-    let isNullable = false;
-    for (const definition of definitions) {
-      result ?? (result = definition);
-      if (result && definition && result.type !== definition.type) {
-        throw new Error('Incompatible types in CASE expression',);
-      }
-      isNullable || (isNullable = (definition == null ? void 0 : definition.isNullable) ?? true);
-    }
-    return result
-      ? {
-        ...result,
-        isNullable,
-      }
-      : null;
-  }
-  stringify() {
-    let result = 'CASE';
-    if (this.valueExpression) {
-      result += ` ${this.valueExpression.stringify()}`;
-    }
-    for (
-      const {
-        whenExpression,
-        thenExpression,
-      } of this.conditions
-    ) {
-      result += ` WHEN ${whenExpression.stringify()} THEN ${thenExpression.stringify()}`;
-    }
-    if (this.elseExpression) {
-      result += ` ELSE ${this.elseExpression.stringify()}`;
-    }
-    result += ' END';
-    return result;
-  }
-  equals(other,) {
-    return other instanceof ScalarCase && isEqual(this.valueExpression, other.valueExpression,) &&
-      isEqual(this.conditions, other.conditions,) && isEqual(this.elseExpression, other.elseExpression,);
-  }
-  evaluate(item,) {
-    var _a, _b;
-    const value = ((_a = this.valueExpression) == null ? void 0 : _a.evaluate(item,)) ?? null;
-    for (
-      const {
-        whenExpression,
-        thenExpression,
-      } of this.conditions
-    ) {
-      const when = whenExpression.evaluate(item,);
-      const isMatching = this.valueExpression ? DatabaseValue.equal(when, value, this.collation,) : toBoolean(when,);
-      if (isMatching) return thenExpression.evaluate(item,);
-    }
-    return ((_b = this.elseExpression) == null ? void 0 : _b.evaluate(item,)) ?? null;
-  }
-  canEvaluate() {
-    const expressions = [];
-    if (this.valueExpression) {
-      expressions.push(this.valueExpression,);
-    }
-    for (const condition of this.conditions) {
-      expressions.push(condition.whenExpression,);
-      expressions.push(condition.thenExpression,);
-    }
-    if (this.elseExpression) {
-      expressions.push(this.elseExpression,);
-    }
-    return expressions.every((expression) => {
-      return expression.canEvaluate();
-    },);
-  }
-};
-var ScalarCaseCondition = class {
-  constructor(whenExpression, thenExpression,) {
-    this.whenExpression = whenExpression;
-    this.thenExpression = thenExpression;
-  }
-};
-var ScalarUnaryOperation = class extends ScalarExpression {
-  constructor(valueExpression,) {
-    super();
-    this.valueExpression = valueExpression;
-  }
-  equals(other,) {
-    return other instanceof ScalarUnaryOperation && isEqual(this.constructor, other.constructor,) &&
-      isEqual(this.valueExpression, other.valueExpression,);
-  }
-  canEvaluate() {
-    return this.valueExpression.canEvaluate();
-  }
-};
-var ScalarUnaryOperationNot = class extends ScalarUnaryOperation {
-  constructor() {
-    super(...arguments,);
-    __publicField(this, 'definition', ScalarUnaryOperationNot.getDefinition(),);
-  }
-  static getDefinition() {
-    return {
-      type: 'boolean',
-      isNullable: false,
-    };
-  }
-  stringify() {
-    return `NOT ${this.valueExpression.stringify()}`;
-  }
-  evaluate(item,) {
-    const value = this.valueExpression.evaluate(item,);
-    return {
-      type: 'boolean',
-      value: !toBoolean(value,),
-    };
-  }
-};
-var ScalarLogicalOperation = class extends ScalarExpression {
-  constructor(operandExpressions,) {
-    super();
-    this.operandExpressions = operandExpressions;
-    __publicField(this, 'definition', ScalarLogicalOperation.getDefinition(),);
-  }
-  static getDefinition() {
-    return {
-      type: 'boolean',
-      isNullable: false,
-    };
-  }
-  stringify() {
-    return this.operandExpressions.map((expression) => expression.stringify()).join(' AND ',);
-  }
-  equals(other,) {
-    return other instanceof ScalarLogicalOperation && isEqual(this.constructor, other.constructor,) &&
-      isEqual(this.operandExpressions, other.operandExpressions,);
-  }
-  canEvaluate() {
-    return this.operandExpressions.every((expression) => {
-      return expression.canEvaluate();
-    },);
-  }
-};
-var ScalarLogicalOperationAnd = class extends ScalarLogicalOperation {
-  constructor() {
-    super(...arguments,);
-    __publicField(this, 'operator', 'AND',);
-  }
-  evaluate(item,) {
-    const result = this.operandExpressions.every((expression) => {
-      const value = expression.evaluate(item,);
-      return toBoolean(value,);
-    },);
-    return {
-      type: 'boolean',
-      value: result,
-    };
-  }
-};
-var ScalarLogicalOperationOr = class extends ScalarLogicalOperation {
-  constructor() {
-    super(...arguments,);
-    __publicField(this, 'operator', 'OR',);
-  }
-  evaluate(item,) {
-    const result = this.operandExpressions.some((expression) => {
-      const value = expression.evaluate(item,);
-      return toBoolean(value,);
-    },);
-    return {
-      type: 'boolean',
-      value: result,
-    };
-  }
-};
-var ScalarComparison = class extends ScalarExpression {
-  constructor(leftExpression, rightExpression,) {
-    super();
-    this.leftExpression = leftExpression;
-    this.rightExpression = rightExpression;
-    __publicField(this, 'definition', ScalarComparison.getDefinition(),);
-    __publicField(this, 'collation', {
-      type: 0,
-      /* CaseInsensitive */
-    },);
-  }
-  static getDefinition() {
-    return {
-      type: 'boolean',
-      isNullable: false,
-    };
-  }
-  stringify() {
-    return `${this.leftExpression.stringify()} ${this.operator} ${this.rightExpression.stringify()}`;
-  }
-  equals(other,) {
-    return other instanceof ScalarComparison && isEqual(this.constructor, other.constructor,) &&
-      isEqual(this.leftExpression, other.leftExpression,) && isEqual(this.rightExpression, other.rightExpression,);
-  }
-  canEvaluate() {
-    return this.leftExpression.canEvaluate() && this.rightExpression.canEvaluate();
-  }
-};
-var ScalarComparisonEquals = class extends ScalarComparison {
-  constructor() {
-    super(...arguments,);
-    __publicField(this, 'operator', '=',);
-  }
-  evaluate(item,) {
-    const leftValue = this.leftExpression.evaluate(item,);
-    const rightValue = this.rightExpression.evaluate(item,);
-    return {
-      type: 'boolean',
-      value: DatabaseValue.equal(leftValue, rightValue, this.collation,),
-    };
-  }
-};
-var ScalarComparisonNotEquals = class extends ScalarComparison {
-  constructor() {
-    super(...arguments,);
-    __publicField(this, 'operator', '!=',);
-  }
-  evaluate(item,) {
-    const leftValue = this.leftExpression.evaluate(item,);
-    const rightValue = this.rightExpression.evaluate(item,);
-    return {
-      type: 'boolean',
-      value: !DatabaseValue.equal(leftValue, rightValue, this.collation,),
-    };
-  }
-};
-var ScalarComparisonLessThan = class extends ScalarComparison {
-  constructor() {
-    super(...arguments,);
-    __publicField(this, 'operator', '<',);
-  }
-  evaluate(item,) {
-    const leftValue = this.leftExpression.evaluate(item,);
-    const rightValue = this.rightExpression.evaluate(item,);
-    return {
-      type: 'boolean',
-      value: DatabaseValue.lessThan(leftValue, rightValue, this.collation,),
-    };
-  }
-};
-var ScalarComparisonLessThanOrEqual = class extends ScalarComparison {
-  constructor() {
-    super(...arguments,);
-    __publicField(this, 'operator', '<=',);
-  }
-  evaluate(item,) {
-    const leftValue = this.leftExpression.evaluate(item,);
-    const rightValue = this.rightExpression.evaluate(item,);
-    return {
-      type: 'boolean',
-      value: DatabaseValue.lessThanOrEqual(leftValue, rightValue, this.collation,),
-    };
-  }
-};
-var ScalarComparisonGreaterThan = class extends ScalarComparison {
-  constructor() {
-    super(...arguments,);
-    __publicField(this, 'operator', '>',);
-  }
-  evaluate(item,) {
-    const leftValue = this.leftExpression.evaluate(item,);
-    const rightValue = this.rightExpression.evaluate(item,);
-    return {
-      type: 'boolean',
-      value: DatabaseValue.greaterThan(leftValue, rightValue, this.collation,),
-    };
-  }
-};
-var ScalarComparisonGreaterThanOrEqual = class extends ScalarComparison {
-  constructor() {
-    super(...arguments,);
-    __publicField(this, 'operator', '>=',);
-  }
-  evaluate(item,) {
-    const leftValue = this.leftExpression.evaluate(item,);
-    const rightValue = this.rightExpression.evaluate(item,);
-    return {
-      type: 'boolean',
-      value: DatabaseValue.greaterThanOrEqual(leftValue, rightValue, this.collation,),
-    };
-  }
-};
-var ScalarTypeCast = class extends ScalarExpression {
-  constructor(valueExpression,) {
-    super();
-    this.valueExpression = valueExpression;
-  }
-  stringify() {
-    return `CAST(${this.valueExpression.stringify()} AS ${this.dataType})`;
-  }
-  equals(other,) {
-    return other instanceof ScalarTypeCast && isEqual(this.constructor, other.constructor,) &&
-      isEqual(this.valueExpression, other.valueExpression,);
-  }
-  canEvaluate() {
-    return this.valueExpression.canEvaluate();
-  }
-};
-var ScalarTypeCastBoolean = class extends ScalarTypeCast {
-  constructor() {
-    super(...arguments,);
-    __publicField(this, 'dataType', 'BOOLEAN',);
-    __publicField(this, 'definition', ScalarTypeCastBoolean.getDefinition(),);
-  }
-  static getDefinition() {
-    return {
-      type: 'boolean',
-      isNullable: true,
-    };
-  }
-  evaluate(item,) {
-    const value = this.valueExpression.evaluate(item,);
-    return DatabaseValue.cast(value, this.definition,);
-  }
-};
-var ScalarTypeCastDate = class extends ScalarTypeCast {
-  constructor() {
-    super(...arguments,);
-    __publicField(this, 'dataType', 'DATE',);
-    __publicField(this, 'definition', ScalarTypeCastDate.getDefinition(),);
-  }
-  static getDefinition() {
-    return {
-      type: 'date',
-      isNullable: true,
-    };
-  }
-  evaluate(item,) {
-    const value = this.valueExpression.evaluate(item,);
-    return DatabaseValue.cast(value, this.definition,);
-  }
-};
-var ScalarTypeCastNumber = class extends ScalarTypeCast {
-  constructor() {
-    super(...arguments,);
-    __publicField(this, 'dataType', 'NUMBER',);
-    __publicField(this, 'definition', ScalarTypeCastNumber.getDefinition(),);
-  }
-  static getDefinition() {
-    return {
-      type: 'number',
-      isNullable: true,
-    };
-  }
-  evaluate(item,) {
-    const value = this.valueExpression.evaluate(item,);
-    return DatabaseValue.cast(value, this.definition,);
-  }
-};
-var ScalarTypeCastString = class extends ScalarTypeCast {
-  constructor() {
-    super(...arguments,);
-    __publicField(this, 'dataType', 'STRING',);
-    __publicField(this, 'definition', ScalarTypeCastString.getDefinition(),);
-  }
-  static getDefinition() {
-    return {
-      type: 'string',
-      isNullable: true,
-    };
-  }
-  evaluate(item,) {
-    const value = this.valueExpression.evaluate(item,);
-    return DatabaseValue.cast(value, this.definition,);
-  }
-};
-function convertExpression(expression, schema, typeAffinity,) {
-  const scalarExpression = getScalarExpression(expression, schema, typeAffinity,);
-  const isLiteralValue = scalarExpression instanceof ScalarLiteralValue;
-  if (scalarExpression.canEvaluate() && !isLiteralValue) {
-    const value = scalarExpression.evaluate();
-    return new ScalarLiteralValue(scalarExpression.definition, value,);
-  }
-  return scalarExpression;
-}
-function getScalarExpression(expression, schema, typeAffinity,) {
-  switch (expression.type) {
-    case 'Identifier':
-      return convertIdentifier(expression, schema,);
-    case 'LiteralValue':
-      return convertLiteralValue(expression, typeAffinity,);
-    case 'FunctionCall':
-      return convertFunctionCall(expression, schema,);
-    case 'Case':
-      return convertCase(expression, schema, typeAffinity,);
-    case 'UnaryOperation':
-      return convertUnaryOperation(expression, schema,);
-    case 'BinaryOperation':
-      return convertBinaryOperation(expression, schema,);
-    case 'TypeCast':
-      return convertTypeCast(expression, schema,);
-    default:
-      throw new Error(`Unsupported expression: ${JSON.stringify(expression,)}`,);
-  }
-}
-function convertIdentifier(expression, schema,) {
-  return new ScalarIdentifier(schema, expression.name, expression.collection,);
-}
-function convertLiteralValue(expression, typeAffinity,) {
-  var _a;
-  const scalarExpression = getScalarLiteralValue(expression.value,);
-  switch (typeAffinity == null ? void 0 : typeAffinity.type) {
-    case 'boolean': {
-      const value = toBoolean(scalarExpression.value,);
-      return ScalarLiteralValue.fromBoolean(value,);
-    }
-    case 'date': {
-      const value = toDate(scalarExpression.value,);
-      return ScalarLiteralValue.fromDate(value,);
-    }
-    case 'enum': {
-      if (((_a = scalarExpression.value) == null ? void 0 : _a.type) === 'string') {
-        return ScalarLiteralValue.fromEnum(scalarExpression.value.value,);
-      }
-      return scalarExpression;
-    }
-    case 'number': {
-      const value = toNumber2(scalarExpression.value,);
-      return ScalarLiteralValue.fromNumber(value,);
-    }
-    case 'string': {
-      const value = toString(scalarExpression.value,);
-      return ScalarLiteralValue.fromString(value,);
-    }
-  }
-  return scalarExpression;
-}
-function getScalarLiteralValue(value,) {
-  if (isBoolean(value,)) {
-    return ScalarLiteralValue.fromBoolean(value,);
-  }
-  if (isValidDate(value,)) {
-    const string = value.toISOString();
-    return ScalarLiteralValue.fromDate(string,);
-  }
-  if (isNumber2(value,)) {
-    return ScalarLiteralValue.fromNumber(value,);
-  }
-  if (isString2(value,)) {
-    return ScalarLiteralValue.fromString(value,);
-  }
-  return ScalarLiteralValue.fromNull();
-}
-function convertFunctionCall(expression, schema,) {
-  const argumentExpressions = expression.arguments.map((argument) => {
-    return convertExpression(argument, schema, void 0,);
-  },);
-  switch (expression.functionName) {
-    case 'CONTAINS':
-      return new ScalarFunctionCallContains(argumentExpressions,);
-    case 'STARTS_WITH':
-      return new ScalarFunctionCallStartsWith(argumentExpressions,);
-    case 'ENDS_WITH':
-      return new ScalarFunctionCallEndsWith(argumentExpressions,);
-    default:
-      throw new Error(`Unsupported function name: ${expression.functionName}`,);
-  }
-}
-function convertCase(expression, schema, typeAffinity,) {
-  const valueExpression = expression.value && convertExpression(expression.value, schema, void 0,);
-  const valueTypeAffinity = expression.value && getExpressionType(expression.value, schema,);
-  const conditions = expression.conditions.map((condition) => {
-    const whenExpression = convertExpression(condition.when, schema, valueTypeAffinity,);
-    const thenExpression = convertExpression(condition.then, schema, typeAffinity,);
-    return new ScalarCaseCondition(whenExpression, thenExpression,);
-  },);
-  const elseExpression = expression.else && convertExpression(expression.else, schema, typeAffinity,);
-  return new ScalarCase(valueExpression, conditions, elseExpression,);
-}
-function convertUnaryOperation(expression, schema,) {
-  const valueExpression = convertExpression(expression.value, schema, void 0,);
-  switch (expression.operator) {
-    case 'not':
-      return getScalarUnaryOperationNot(valueExpression,);
-    default:
-      throw new Error(`Unsupported unary operator: ${expression.operator}`,);
-  }
-}
-function getScalarUnaryOperationNot(valueExpression,) {
-  var _a;
-  if (valueExpression instanceof ScalarUnaryOperationNot) {
-    const innerExpression = valueExpression.valueExpression;
-    if (((_a = innerExpression.definition) == null ? void 0 : _a.type) === 'boolean') {
-      return innerExpression;
-    }
-    return new ScalarTypeCastBoolean(innerExpression,);
-  }
-  if (valueExpression instanceof ScalarComparisonEquals) {
-    const {
-      leftExpression,
-      rightExpression,
-    } = valueExpression;
-    return new ScalarComparisonNotEquals(leftExpression, rightExpression,);
-  }
-  if (valueExpression instanceof ScalarComparisonNotEquals) {
-    const {
-      leftExpression,
-      rightExpression,
-    } = valueExpression;
-    return new ScalarComparisonEquals(leftExpression, rightExpression,);
-  }
-  if (valueExpression instanceof ScalarComparisonLessThan) {
-    const {
-      leftExpression,
-      rightExpression,
-    } = valueExpression;
-    return new ScalarComparisonGreaterThanOrEqual(leftExpression, rightExpression,);
-  }
-  if (valueExpression instanceof ScalarComparisonLessThanOrEqual) {
-    const {
-      leftExpression,
-      rightExpression,
-    } = valueExpression;
-    return new ScalarComparisonGreaterThan(leftExpression, rightExpression,);
-  }
-  if (valueExpression instanceof ScalarComparisonGreaterThan) {
-    const {
-      leftExpression,
-      rightExpression,
-    } = valueExpression;
-    return new ScalarComparisonLessThanOrEqual(leftExpression, rightExpression,);
-  }
-  if (valueExpression instanceof ScalarComparisonGreaterThanOrEqual) {
-    const {
-      leftExpression,
-      rightExpression,
-    } = valueExpression;
-    return new ScalarComparisonLessThan(leftExpression, rightExpression,);
-  }
-  if (valueExpression instanceof ScalarLogicalOperationAnd) {
-    const {
-      operandExpressions,
-    } = valueExpression;
-    const notExpressions = operandExpressions.map(getScalarUnaryOperationNot,);
-    return new ScalarLogicalOperationOr(notExpressions,);
-  }
-  if (valueExpression instanceof ScalarLogicalOperationAnd) {
-    const {
-      operandExpressions,
-    } = valueExpression;
-    const notExpressions = operandExpressions.map(getScalarUnaryOperationNot,);
-    return new ScalarLogicalOperationAnd(notExpressions,);
-  }
-  return new ScalarUnaryOperationNot(valueExpression,);
-}
-function getTypeAffinityForBinaryOperation(expression, schema,) {
-  if (expression.operator !== 'and' && expression.operator !== 'or') {
-    return getExpressionType(expression.left, schema,) || getExpressionType(expression.right, schema,);
-  }
-}
-function convertBinaryOperation(expression, schema,) {
-  const typeAffinity = getTypeAffinityForBinaryOperation(expression, schema,);
-  const leftExpression = convertExpression(expression.left, schema, typeAffinity,);
-  const rightExpression = convertExpression(expression.right, schema, typeAffinity,);
-  switch (expression.operator) {
-    case 'and':
-      return getScalarLogicalOperationAnd(leftExpression, rightExpression,);
-    case 'or':
-      return getScalarLogicalOperationOr(leftExpression, rightExpression,);
-    case '==':
-      return getScalarComparisonEquals(leftExpression, rightExpression,);
-    case '!=':
-      return getScalarComparisonNotEquals(leftExpression, rightExpression,);
-    case '<':
-      return getScalarComparisonLessThan(leftExpression, rightExpression,);
-    case '<=':
-      return getScalarComparisonLessThanOrEqual(leftExpression, rightExpression,);
-    case '>':
-      return getScalarComparisonGreaterThan(leftExpression, rightExpression,);
-    case '>=':
-      return getScalarComparisonGreaterThanOrEqual(leftExpression, rightExpression,);
-    default:
-      throw new Error(`Unsupported binary operator: ${expression.operator}`,);
-  }
-}
-function getScalarLogicalOperationAnd(leftExpression, rightExpression,) {
-  const operandExpressions = [];
-  if (leftExpression instanceof ScalarLogicalOperationAnd) {
-    operandExpressions.push(...leftExpression.operandExpressions,);
-  } else {
-    operandExpressions.push(leftExpression,);
-  }
-  if (rightExpression instanceof ScalarLogicalOperationAnd) {
-    operandExpressions.push(...rightExpression.operandExpressions,);
-  } else {
-    operandExpressions.push(rightExpression,);
-  }
-  return new ScalarLogicalOperationAnd(operandExpressions,);
-}
-function getScalarLogicalOperationOr(leftExpression, rightExpression,) {
-  const operandExpressions = [];
-  if (leftExpression instanceof ScalarLogicalOperationOr) {
-    operandExpressions.push(...leftExpression.operandExpressions,);
-  } else {
-    operandExpressions.push(leftExpression,);
-  }
-  if (rightExpression instanceof ScalarLogicalOperationOr) {
-    operandExpressions.push(...rightExpression.operandExpressions,);
-  } else {
-    operandExpressions.push(rightExpression,);
-  }
-  return new ScalarLogicalOperationOr(operandExpressions,);
-}
-function getScalarComparisonEquals(leftExpression, rightExpression,) {
-  const isLeftIdentifier = leftExpression instanceof ScalarIdentifier;
-  const isRightIdentifier = rightExpression instanceof ScalarIdentifier;
-  if (isRightIdentifier && !isLeftIdentifier) {
-    return new ScalarComparisonEquals(rightExpression, leftExpression,);
-  }
-  return new ScalarComparisonEquals(leftExpression, rightExpression,);
-}
-function getScalarComparisonNotEquals(leftExpression, rightExpression,) {
-  const isLeftIdentifier = leftExpression instanceof ScalarIdentifier;
-  const isRightIdentifier = rightExpression instanceof ScalarIdentifier;
-  if (isRightIdentifier && !isLeftIdentifier) {
-    return new ScalarComparisonNotEquals(rightExpression, leftExpression,);
-  }
-  return new ScalarComparisonNotEquals(leftExpression, rightExpression,);
-}
-function getScalarComparisonLessThan(leftExpression, rightExpression,) {
-  const isLeftIdentifier = leftExpression instanceof ScalarIdentifier;
-  const isRightIdentifier = rightExpression instanceof ScalarIdentifier;
-  if (isRightIdentifier && !isLeftIdentifier) {
-    return new ScalarComparisonGreaterThan(rightExpression, leftExpression,);
-  }
-  return new ScalarComparisonLessThan(leftExpression, rightExpression,);
-}
-function getScalarComparisonLessThanOrEqual(leftExpression, rightExpression,) {
-  const isLeftIdentifier = leftExpression instanceof ScalarIdentifier;
-  const isRightIdentifier = rightExpression instanceof ScalarIdentifier;
-  if (isRightIdentifier && !isLeftIdentifier) {
-    return new ScalarComparisonGreaterThanOrEqual(rightExpression, leftExpression,);
-  }
-  return new ScalarComparisonLessThanOrEqual(leftExpression, rightExpression,);
-}
-function getScalarComparisonGreaterThan(leftExpression, rightExpression,) {
-  const isLeftIdentifier = leftExpression instanceof ScalarIdentifier;
-  const isRightIdentifier = rightExpression instanceof ScalarIdentifier;
-  if (isRightIdentifier && !isLeftIdentifier) {
-    return new ScalarComparisonLessThan(rightExpression, leftExpression,);
-  }
-  return new ScalarComparisonGreaterThan(leftExpression, rightExpression,);
-}
-function getScalarComparisonGreaterThanOrEqual(leftExpression, rightExpression,) {
-  const isLeftIdentifier = leftExpression instanceof ScalarIdentifier;
-  const isRightIdentifier = rightExpression instanceof ScalarIdentifier;
-  if (isRightIdentifier && !isLeftIdentifier) {
-    return new ScalarComparisonLessThanOrEqual(rightExpression, leftExpression,);
-  }
-  return new ScalarComparisonGreaterThanOrEqual(leftExpression, rightExpression,);
-}
-function convertTypeCast(expression, schema,) {
-  const valueExpression = convertExpression(expression.value, schema, void 0,);
-  switch (expression.dataType) {
-    case 'BOOLEAN':
-      return getScalarTypeCastBoolean(valueExpression,);
-    case 'DATE':
-      return getScalarTypeCastDate(valueExpression,);
-    case 'NUMBER':
-      return getScalarTypeCastNumber(valueExpression,);
-    case 'STRING':
-      return getScalarTypeCastString(valueExpression,);
-    default:
-      throw new Error(`Unsupported data type: ${expression.dataType}`,);
-  }
-}
-function getScalarTypeCastBoolean(valueExpression,) {
-  var _a;
-  if (((_a = valueExpression.definition) == null ? void 0 : _a.type) === 'boolean') {
-    return valueExpression;
-  }
-  return new ScalarTypeCastBoolean(valueExpression,);
-}
-function getScalarTypeCastDate(valueExpression,) {
-  var _a;
-  if (((_a = valueExpression.definition) == null ? void 0 : _a.type) === 'date') {
-    return valueExpression;
-  }
-  return new ScalarTypeCastDate(valueExpression,);
-}
-function getScalarTypeCastNumber(valueExpression,) {
-  var _a;
-  if (((_a = valueExpression.definition) == null ? void 0 : _a.type) === 'number') {
-    return valueExpression;
-  }
-  return new ScalarTypeCastNumber(valueExpression,);
-}
-function getScalarTypeCastString(valueExpression,) {
-  var _a;
-  if (((_a = valueExpression.definition) == null ? void 0 : _a.type) === 'string') {
-    return valueExpression;
-  }
-  return new ScalarTypeCastString(valueExpression,);
-}
-function getExpressionType(expression, schema,) {
-  switch (expression.type) {
-    case 'Identifier':
-      return getIdentifierType(expression, schema,);
-    case 'LiteralValue':
-      return void 0;
-    case 'FunctionCall':
-      return getFunctionCallType(expression,);
-    case 'Case':
-      return getCaseType(expression, schema,);
-    case 'UnaryOperation':
-      return getUnaryOperationType(expression,);
-    case 'BinaryOperation':
-      return getBinaryOperationType(expression,);
-    case 'TypeCast':
-      return getTypeCastType(expression,);
-    default:
-      throw new Error(`Unsupported expression: ${JSON.stringify(expression,)}`,);
-  }
-}
-function getIdentifierType(expression, schema,) {
-  return schema[expression.name];
-}
-function getFunctionCallType(expression,) {
-  switch (expression.functionName) {
-    case 'CONTAINS':
-      return ScalarFunctionCallContains.getDefinition();
-    case 'STARTS_WITH':
-      return ScalarFunctionCallStartsWith.getDefinition();
-    case 'ENDS_WITH':
-      return ScalarFunctionCallEndsWith.getDefinition();
-    default:
-      throw new Error(`Unsupported function name: ${expression.functionName}`,);
-  }
-}
-function getCaseType(expression, schema,) {
-  const definitions = [];
-  for (const condition of expression.conditions) {
-    const type = getExpressionType(condition.then, schema,);
-    if (!isUndefined(type,)) definitions.push(type,);
-  }
-  if (expression.else) {
-    const type = getExpressionType(expression.else, schema,);
-    if (!isUndefined(type,)) definitions.push(type,);
-  }
-  return ScalarCase.getDefinition(definitions,) ?? void 0;
-}
-function getUnaryOperationType(expression,) {
-  switch (expression.operator) {
-    case 'not':
-      return ScalarUnaryOperationNot.getDefinition();
-    default:
-      throw new Error(`Unsupported unary operator: ${expression.operator}`,);
-  }
-}
-function getBinaryOperationType(expression,) {
-  switch (expression.operator) {
-    case 'and':
-    case 'or':
-      return ScalarLogicalOperation.getDefinition();
-    case '==':
-    case '!=':
-    case '<':
-    case '<=':
-    case '>':
-    case '>=':
-      return ScalarComparison.getDefinition();
-    default:
-      throw new Error(`Unsupported binary operator: ${expression.operator}`,);
-  }
-}
-function getTypeCastType(expression,) {
-  switch (expression.dataType) {
-    case 'BOOLEAN':
-      return ScalarTypeCastBoolean.getDefinition();
-    case 'DATE':
-      return ScalarTypeCastDate.getDefinition();
-    case 'NUMBER':
-      return ScalarTypeCastNumber.getDefinition();
-    case 'STRING':
-      return ScalarTypeCastString.getDefinition();
-    default:
-      throw new Error(`Unsupported data type: ${expression.dataType}`,);
-  }
-}
-function stringifyExecutionTime(self2, total,) {
-  return `(self: ${self2}ms${total ? `, total: ${total}ms` : ''})`;
-}
-function stringifyItems(items,) {
-  return `(items: ${items})`;
-}
-var QueryPlan = class {
-  constructor() {
-    __publicField(this, 'executionTime', 0,);
-    __publicField(this, 'itemCount', 0,);
-  }
-  async execute() {
-    const start = performance.now();
-    const result = await this._execute();
-    this.executionTime = performance.now() - start;
-    this.itemCount = result.length;
-    return result;
-  }
-};
-var ScanCollectionPlan = class extends QueryPlan {
-  constructor(collection, alias,) {
-    super();
-    this.collection = collection;
-    this.alias = alias;
-  }
-  inspect() {
-    return {
-      label: `ScanCollectionPlan ${stringifyExecutionTime(this.executionTime,)} ${stringifyItems(this.itemCount,)}`,
-    };
-  }
-  async _execute() {
-    const items = await this.collection.scanItems();
-    if (isUndefined(this.alias,)) return items;
-    return items.map((item) => {
-      const data2 = {
-        ...item.data,
-      };
-      const dataEntries = Object.entries(data2,);
-      for (const [key7, value,] of dataEntries) {
-        data2[`${this.alias}_${key7}`] = value;
-      }
-      return {
-        pointer: item.pointer,
-        data: data2,
-      };
-    },);
-  }
-};
-var LeftJoinPlan = class extends QueryPlan {
-  constructor(leftPlan, rightPlan, constraint,) {
-    super();
-    this.leftPlan = leftPlan;
-    this.rightPlan = rightPlan;
-    this.constraint = constraint;
-  }
-  inspect() {
-    const childPlansTime = Math.max(this.leftPlan.executionTime ?? 0, this.rightPlan.executionTime ?? 0,);
-    return {
-      label: `LeftJoinPlan ${stringifyExecutionTime(this.executionTime - childPlansTime, this.executionTime,)} ${
-        stringifyItems(this.itemCount,)
-      }`,
-      nodes: [this.leftPlan.inspect(), this.rightPlan.inspect(),],
-    };
-  }
-  async _execute() {
-    var _a;
-    const leftItems = await this.leftPlan.execute();
-    const rightItems = await this.rightPlan.execute();
-    const result = [];
-    for (const leftItem of leftItems) {
-      let hasMatch = false;
-      for (const rightItem of rightItems) {
-        const combinedItem = {
-          pointer: leftItem.pointer,
-          data: {
-            ...leftItem.data,
-            ...rightItem.data,
-          },
-        };
-        if ((_a = this.constraint.evaluate(combinedItem,)) == null ? void 0 : _a.value) {
-          result.push(combinedItem,);
-          hasMatch = true;
-        }
-      }
-      if (!hasMatch) {
-        result.push(leftItem,);
-      }
-    }
-    return result;
-  }
-};
-var LookupIndexPlan = class extends QueryPlan {
-  constructor(index, query,) {
-    super();
-    this.index = index;
-    this.query = query;
-  }
-  inspect() {
-    const queries = [];
-    const stringifyDatabaseLookupType = (indexLookup) => {
-      switch (indexLookup.type) {
-        case 'All':
-          return indexLookup.type;
-        case 'Equals':
-        case 'NotEquals':
-        case 'LessThan':
-        case 'GreaterThan':
-        case 'Contains':
-        case 'StartsWith':
-        case 'EndsWith':
-          return `${indexLookup.type} ${DatabaseValue.stringify(indexLookup.value,)}`;
-        default: {
-          assertNever(indexLookup,);
-        }
-      }
-    };
-    for (let i = 0; i < this.index.fields.length; i++) {
-      const field = this.index.fields[i];
-      const query = this.query[i];
-      if (!field || field.type !== 'Identifier') continue;
-      if (!query || query.type === 'All') continue;
-      queries.push(`${field.name} ${stringifyDatabaseLookupType(query,)}`,);
-    }
-    return {
-      label: `LookupIndexPlan(${queries.join(', ',)}) ${stringifyExecutionTime(this.executionTime,)} ${stringifyItems(this.itemCount,)}`,
-    };
-  }
-  async _execute() {
-    return this.index.lookupItems(this.query,);
-  }
-};
-var UnionPlan = class extends QueryPlan {
-  constructor(childPlans,) {
-    super();
-    this.childPlans = childPlans;
-  }
-  inspect() {
-    const childPlansTime = Math.max(...this.childPlans.map((childPlan) => childPlan.executionTime ?? 0),);
-    return {
-      label: `UnionPlan ${stringifyExecutionTime(this.executionTime - childPlansTime, this.executionTime,)} ${
-        stringifyItems(this.itemCount,)
-      }`,
-      nodes: this.childPlans.map((childPlan) => childPlan.inspect()),
-    };
-  }
-  async _execute() {
-    const childItemMaps = await Promise.all(this.childPlans.map(async (childPlan) => {
-      const items = await childPlan.execute();
-      return new DatabaseItemMap(items,);
-    },),);
-    let result;
-    for (const itemMap of childItemMaps) {
-      if (result) {
-        result = result.union(itemMap,);
-      } else {
-        result = itemMap;
-      }
-    }
-    return (result == null ? void 0 : result.items()) ?? [];
-  }
-};
-var IntersectionPlan = class extends QueryPlan {
-  constructor(childPlans,) {
-    super();
-    this.childPlans = childPlans;
-  }
-  inspect() {
-    const childPlansTime = Math.max(...this.childPlans.map((childPlan) => childPlan.executionTime ?? 0),);
-    return {
-      label: `IntersectionPlan ${stringifyExecutionTime(this.executionTime - childPlansTime, this.executionTime,)} ${
-        stringifyItems(this.itemCount,)
-      } ${stringifyItems(this.itemCount,)}`,
-      nodes: this.childPlans.map((childPlan) => childPlan.inspect()),
-    };
-  }
-  async _execute() {
-    const childItemMaps = await Promise.all(this.childPlans.map(async (childPlan) => {
-      const items = await childPlan.execute();
-      return new DatabaseItemMap(items,);
-    },),);
-    let result;
-    for (const itemMap of childItemMaps) {
-      if (result) {
-        result = result.intersection(itemMap,);
-      } else {
-        result = itemMap;
-      }
-    }
-    return (result == null ? void 0 : result.items()) ?? [];
-  }
-};
-var ResolveItemsPlan = class extends QueryPlan {
-  constructor(childPlan, collection, richTextResolver, select,) {
-    super();
-    this.childPlan = childPlan;
-    this.collection = collection;
-    this.richTextResolver = richTextResolver;
-    this.select = select;
-  }
-  inspect() {
-    return {
-      label: `ResolveItemsPlan ${stringifyExecutionTime(this.executionTime - this.childPlan.executionTime, this.executionTime,)} ${
-        stringifyItems(this.itemCount,)
-      }`,
-      nodes: [this.childPlan.inspect(),],
-    };
-  }
-  async _execute() {
-    const childItems = await this.childPlan.execute();
-    const childPointers = childItems.map((item) => item.pointer);
-    for (const item of childItems) {
-      for (const expression of this.select) {
-        if (expression.type !== 'Identifier') continue;
-        const value = item.data[expression.name];
-        if ((value == null ? void 0 : value.type) !== 'richtext') continue;
-        void this.richTextResolver.resolve(expression.name, value.value,);
-      }
-    }
-    return this.collection.resolveItems(childPointers,);
-  }
-};
-var FilterItemsPlan = class extends QueryPlan {
-  constructor(childPlan, filterExpression,) {
-    super();
-    this.childPlan = childPlan;
-    this.filterExpression = filterExpression;
-  }
-  inspect() {
-    return {
-      label: `FilterItemsPlan(${this.filterExpression.stringify()}) ${
-        stringifyExecutionTime(this.executionTime - this.childPlan.executionTime, this.executionTime,)
-      } ${stringifyItems(this.itemCount,)} ${stringifyItems(this.itemCount,)}`,
-      nodes: [this.childPlan.inspect(),],
-    };
-  }
-  async _execute() {
-    const childItems = await this.childPlan.execute();
-    return childItems.filter((item) => {
-      const result = this.filterExpression.evaluate(item,);
-      return toBoolean(result,);
-    },);
-  }
-};
-var SortItemsPlan = class extends QueryPlan {
-  constructor(childPlan, orderExpressions, collection,) {
-    super();
-    this.childPlan = childPlan;
-    this.orderExpressions = orderExpressions;
-    this.collection = collection;
-  }
-  inspect() {
-    const order = this.orderExpressions.map((expression) => `${expression.expression.stringify()} ${expression.direction.toUpperCase()}`)
-      .join(', ',);
-    return {
-      label: `SortItemsPlan(${order}) ${stringifyExecutionTime(this.executionTime - this.childPlan.executionTime, this.executionTime,)} ${
-        stringifyItems(this.itemCount,)
-      }`,
-      nodes: [this.childPlan.inspect(),],
-    };
-  }
-  async _execute() {
-    const childItems = await this.childPlan.execute();
-    return childItems.sort((leftItem, rightItem,) => {
-      const leftSortItem = {
-        ...leftItem,
-        data: {},
-      };
-      const rightSortItem = {
-        ...rightItem,
-        data: {},
-      };
-      for (
-        const {
-          expression,
-          direction,
-          collation: collation10,
-        } of this.orderExpressions
-      ) {
-        const isAscending = direction === 'asc';
-        if (expression instanceof ScalarIdentifier && expression.name === INDEX_IDENTIFIER) {
-          const order = this.collection.compareItems(leftSortItem, rightSortItem,);
-          return isAscending ? order : -order;
-        }
-        const left = expression.evaluate(leftItem,);
-        const right = expression.evaluate(rightItem,);
-        if (DatabaseValue.equal(left, right, collation10,)) {
-          continue;
-        }
-        if (DatabaseValue.lessThan(left, right, collation10,) || isNullish2(left,)) {
-          return isAscending ? -1 : 1;
-        }
-        if (DatabaseValue.greaterThan(left, right, collation10,) || isNullish2(right,)) {
-          return isAscending ? 1 : -1;
-        }
-        throw new Error('Invalid comparison result.',);
-      }
-      return this.collection.compareItems(leftSortItem, rightSortItem,);
-    },);
-  }
-};
-var ScalarOrderExpression = class {
-  constructor(expression, direction, collation10,) {
-    this.expression = expression;
-    this.direction = direction;
-    this.collation = collation10;
-  }
-};
-var SliceItemsPlan = class extends QueryPlan {
-  constructor(childPlan, offsetExpression, limitExpression,) {
-    super();
-    this.childPlan = childPlan;
-    this.offsetExpression = offsetExpression;
-    this.limitExpression = limitExpression;
-  }
-  inspect() {
-    var _a, _b;
-    return {
-      label: `SliceItemsPlan(LIMIT ${((_a = this.limitExpression) == null ? void 0 : _a.stringify()) ?? 'Infinity'}, OFFSET ${
-        ((_b = this.offsetExpression) == null ? void 0 : _b.stringify()) ?? '0'
-      }) ${stringifyExecutionTime(this.executionTime - this.childPlan.executionTime, this.executionTime,)} ${
-        stringifyItems(this.itemCount,)
-      }`,
-      nodes: [this.childPlan.inspect(),],
-    };
-  }
-  getOffset() {
-    var _a;
-    const value = (_a = this.offsetExpression) == null ? void 0 : _a.evaluate();
-    if (isNullish2(value,) || value.type !== 'number') return;
-    return value.value;
-  }
-  getLimit() {
-    var _a;
-    const value = (_a = this.limitExpression) == null ? void 0 : _a.evaluate();
-    if (isNullish2(value,) || value.type !== 'number') return;
-    return value.value;
-  }
-  async _execute() {
-    const childItems = await this.childPlan.execute();
-    const offset = this.getOffset() ?? 0;
-    const limit = this.getLimit() ?? Infinity;
-    return childItems.slice(offset, offset + limit,);
-  }
-};
-var DatabaseItemMap = class extends Map {
-  constructor(items = [],) {
-    super();
-    for (const item of items) {
-      this.set(item.pointer, item,);
-    }
-  }
-  union(other,) {
-    const result = new DatabaseItemMap();
-    for (const [pointer, item,] of this) {
-      result.set(pointer, item,);
-    }
-    for (const [pointer, item,] of other) {
-      result.set(pointer, item,);
-    }
-    return result;
-  }
-  intersection(other,) {
-    const result = new DatabaseItemMap();
-    for (const [pointer, item,] of this) {
-      if (other.has(pointer,)) {
-        result.set(pointer, item,);
-      }
-    }
-    return result;
-  }
-  items() {
-    const values = this.values();
-    return [...values,];
-  }
-};
-var RichTextResolver = class {
-  constructor(collections,) {
-    this.collections = collections;
-    __publicField(this, 'cache', /* @__PURE__ */ new Map(),);
-  }
-  resolve(key7, pointer,) {
-    const scopedCache = this.cache.get(key7,) ?? /* @__PURE__ */ new Map();
-    this.cache.set(key7, scopedCache,);
-    const cachedPromise = scopedCache.get(pointer,);
-    if (cachedPromise) return cachedPromise;
-    for (const collection of this.collections) {
-      if (key7 in collection.schema) {
-        const promise = collection.resolveRichText(pointer,);
-        scopedCache.set(pointer, promise,);
-        return promise;
-      }
-    }
-    throw new Error(`Rich text field not found: ${key7}`,);
-  }
-};
 var unknownDefinition = {
   type: 'unknown',
   isNullable: true,
@@ -42006,7 +40476,7 @@ var CaseCondition = class {
     return calculateHash('CaseCondition', this.when, this.then,);
   }
 };
-var ScalarCase2 = class extends ScalarNode {
+var ScalarCase = class extends ScalarNode {
   constructor(input, conditions, otherwise,) {
     const referencedFields = new Fields();
     const referencedOuterFields = new Fields();
@@ -42083,7 +40553,7 @@ var ScalarCase2 = class extends ScalarNode {
       return new CaseCondition(when, then,);
     },);
     const otherwise = (_b = this.otherwise) == null ? void 0 : _b.getOptimized();
-    return new ScalarCase2(input, conditions, otherwise,);
+    return new ScalarCase(input, conditions, otherwise,);
   }
   *evaluate(context, tuple,) {
     var _a, _b;
@@ -42349,6 +40819,7 @@ var Builder = class {
       fromScope.setNode(node,);
     }
     const orderProjections = [];
+    const orderFields = new Fields();
     let ordering;
     if (select.orderBy) {
       ordering = new Ordering();
@@ -42356,6 +40827,7 @@ var Builder = class {
         if (order.type === 'Identifier') {
           const scopeField = fromScope.resolveField(order.name, order.collection,);
           if (isUndefined(scopeField,)) continue;
+          orderFields.add(scopeField.field,);
           const orderingField = new OrderingField(scopeField.field, order.direction,);
           ordering.push(orderingField,);
         } else {
@@ -42372,7 +40844,7 @@ var Builder = class {
     } else {
       ordering = defaultOrdering;
     }
-    const projectionScope = this.buildSelectList(fromScope, select.select, orderProjections,);
+    const projectionScope = this.buildSelectList(fromScope, select.select, orderFields, orderProjections,);
     projectionScope.setOrdering(ordering,);
     if (select.offset) {
       const input = projectionScope.takeNode();
@@ -42388,9 +40860,9 @@ var Builder = class {
     }
     return projectionScope;
   }
-  buildSelectList(inScope, selects, orderProjections,) {
+  buildSelectList(inScope, selects, orderFields, orderProjections,) {
     const outScope = inScope.push();
-    const passthrough = new Fields();
+    const passthrough = new Fields(orderFields,);
     const projections = [...orderProjections,];
     for (const select of selects) {
       if (select.type === 'Identifier') {
@@ -45023,7 +43495,7 @@ var Normalizer = class {
       }
       conditions = castConditions;
     }
-    const node = new ScalarCase2(input, conditions, otherwise,);
+    const node = new ScalarCase(input, conditions, otherwise,);
     return this.finishScalar(node,);
   }
   newScalarContains(source, target,) {
@@ -45251,36 +43723,8 @@ function stringifyQuery(query,) {
   return autoIndentSql(queryString,);
 }
 var log = /* @__PURE__ */ getLogger('query-engine',);
-function getDatabaseCollection({
-  data: data2,
-}, locale,) {
-  if (isAnyLegacyCollection(data2,)) {
-    return new CompatibilityDatabaseCollection(data2, locale,);
-  }
-  if (isDatabaseCollection(data2,)) {
-    return data2;
-  }
-  if (isLocalizedDatabaseCollection(data2,)) {
-    while (locale) {
-      const collection = data2.collectionByLocaleId[locale.id];
-      if (collection) return collection;
-      locale = locale.fallback;
-    }
-    return data2.collectionByLocaleId.default;
-  }
-  assertNever(data2, 'Unsupported collection type',);
-}
 var QueryEngine = class {
-  constructor() {
-    __publicField(this, 'useNewOptimizer', false,);
-  }
   async query(query, locale,) {
-    if (this.useNewOptimizer || needsNewQueryOptimizer(query,)) {
-      return this.queryNew(query, locale,);
-    }
-    return this.queryOld(query, locale,);
-  }
-  async queryNew(query, locale,) {
     log.debug(`Query:
 ${stringifyQuery(query,)}`,);
     const optimizer = new Optimizer(query, locale,);
@@ -45317,285 +43761,7 @@ ${stringifyQuery(query,)}`,);
     }
     return (value == null ? void 0 : value.value) ?? null;
   }
-  async queryOld(query, locale,) {
-    const [plan, schema, richTextResolver,] = this.createQueryPlan(query, locale,);
-    const items = await this.executeQueryPlan(schema, richTextResolver, query, plan,);
-    log.debug(`Query:
-${stringifyQuery(query,)}
-
-${(0, import_archy.default)(plan.inspect(),)}`,);
-    return items;
-  }
-  buildFrom(from, schema, collections, locale,) {
-    switch (from.type) {
-      case 'Collection': {
-        const collection = getDatabaseCollection(from, locale,);
-        collections.push(collection,);
-        Object.assign(schema, collection.schema,);
-        return new ScanCollectionPlan(collection, from.alias,);
-      }
-      case 'LeftJoin': {
-        const left = this.buildFrom(from.left, schema, collections, locale,);
-        const right = this.buildFrom(from.right, schema, collections, locale,);
-        const constraint = ScalarExpression.from(from.constraint, schema,);
-        return new LeftJoinPlan(left, right, constraint,);
-      }
-      default:
-        assertNever(from, 'Unsupported data source',);
-    }
-  }
-  createQueryPlan(query, locale,) {
-    var _a;
-    const schema = {};
-    const collections = [];
-    let plan = this.buildFrom(query.from, schema, collections, locale,);
-    const [firstCollection,] = collections;
-    assert(firstCollection, 'At least one collection must exist',);
-    const richTextResolver = new RichTextResolver(collections,);
-    if (query.where) {
-      const filterExpression = ScalarExpression.from(query.where, schema,);
-      if (collections.length === 1) {
-        plan = createPlanForWhereClause(firstCollection, filterExpression,);
-      } else {
-        plan = new FilterItemsPlan(plan, filterExpression,);
-      }
-    }
-    const sortExpressions = (_a = query.orderBy) == null
-      ? void 0
-      : _a.map((expression) =>
-        new ScalarOrderExpression(ScalarExpression.from(expression, schema,), expression.direction ?? 'asc', {
-          type: 0,
-          /* CaseInsensitive */
-        },)
-      );
-    plan = new SortItemsPlan(plan, sortExpressions ?? [], firstCollection,);
-    let offsetExpression;
-    if (query.offset) {
-      offsetExpression = ScalarExpression.from(query.offset, schema,);
-    }
-    let limitExpression;
-    if (query.limit) {
-      limitExpression = ScalarExpression.from(query.limit, schema,);
-    }
-    if (offsetExpression || limitExpression) {
-      plan = new SliceItemsPlan(plan, offsetExpression, limitExpression,);
-    }
-    if (query.select.length > 0 && collections.length === 1) {
-      plan = new ResolveItemsPlan(plan, firstCollection, richTextResolver, query.select,);
-    }
-    return [plan, schema, richTextResolver,];
-  }
-  async executeQueryPlan(schema, richTextResolver, query, plan,) {
-    const items = await plan.execute();
-    return Promise.all(items.map(async (item) => {
-      const data2 = {};
-      for (const expression of query.select) {
-        const scalarExpression = ScalarExpression.from(expression, schema,);
-        const key7 = getSelectKey(expression,);
-        const value = scalarExpression.evaluate(item,);
-        data2[key7] = await resolveValue(richTextResolver, expression.type === 'Identifier' ? expression.name : void 0, value,);
-      }
-      return data2;
-    },),);
-  }
 };
-function getSelectKey(expression,) {
-  if (expression.alias) {
-    return expression.alias;
-  }
-  if (expression.type === 'Identifier') {
-    return expression.name;
-  }
-  throw new Error('Can\'t serialize expression',);
-}
-async function resolveValue(richTextResolver, key7, value,) {
-  if (isNullish2(value,)) {
-    return null;
-  }
-  if (value.type === 'richtext') {
-    assert(isString2(key7,), 'Rich text field must be a string',);
-    return richTextResolver.resolve(key7, value.value,);
-  }
-  return value.value;
-}
-function createPlanForWhereClause(collection, expression,) {
-  if (expression instanceof ScalarLogicalOperationAnd) {
-    const childPlans = expression.operandExpressions.map((expression2) => createPlanForWhereClause(collection, expression2,));
-    return new IntersectionPlan(childPlans,);
-  }
-  if (expression instanceof ScalarLogicalOperationOr) {
-    const childPlans = expression.operandExpressions.map((expression2) => createPlanForWhereClause(collection, expression2,));
-    return new UnionPlan(childPlans,);
-  }
-  return findLookupIndexPlan(collection, expression,) ?? createScanCollectionPlan(collection, expression,);
-}
-function findLookupIndexPlan(collection, expression,) {
-  var _a, _b;
-  if (expression instanceof ScalarComparison) {
-    return findLookupIndexPlanForComparison(collection, expression,);
-  }
-  if (expression instanceof ScalarFunctionCall) {
-    return findLookupIndexPlanForFunctionCall(collection, expression,);
-  }
-  if (expression instanceof ScalarIdentifier && ((_a = expression.definition) == null ? void 0 : _a.type) === 'boolean') {
-    const value = ScalarLiteralValue.fromBoolean(true,);
-    const comparison = new ScalarComparisonEquals(expression, value,);
-    return findLookupIndexPlanForComparison(collection, comparison,);
-  }
-  if (
-    expression instanceof ScalarUnaryOperationNot && expression.valueExpression instanceof ScalarIdentifier &&
-    ((_b = expression.valueExpression.definition) == null ? void 0 : _b.type) === 'boolean'
-  ) {
-    const value = ScalarLiteralValue.fromBoolean(true,);
-    const comparison = new ScalarComparisonNotEquals(expression.valueExpression, value,);
-    return findLookupIndexPlanForComparison(collection, comparison,);
-  }
-}
-function findLookupIndexPlanForComparison(collection, expression,) {
-  const leftExpression = expression.leftExpression;
-  const rightExpression = expression.rightExpression;
-  if (!(rightExpression instanceof ScalarLiteralValue)) return;
-  for (const index of collection.indexes) {
-    const field = index.fields[0];
-    if (isUndefined(field,)) continue;
-    const fieldExpression = ScalarExpression.from(field, collection.schema,);
-    if (!leftExpression.equals(fieldExpression,)) continue;
-    const fillerAllQueries = new Array(index.fields.length - 1,).fill({
-      type: 'All',
-      /* All */
-    },);
-    if (
-      expression instanceof ScalarComparisonEquals && index.supportedLookupTypes.includes('Equals',/* Equals */
-      )
-    ) {
-      return new LookupIndexPlan(index, [{
-        type: 'Equals',
-        value: rightExpression.evaluate(),
-      }, ...fillerAllQueries,],);
-    }
-    if (
-      expression instanceof ScalarComparisonNotEquals && index.supportedLookupTypes.includes('NotEquals',/* NotEquals */
-      )
-    ) {
-      return new LookupIndexPlan(index, [{
-        type: 'NotEquals',
-        value: rightExpression.evaluate(),
-      }, ...fillerAllQueries,],);
-    }
-    if (
-      expression instanceof ScalarComparisonLessThan && index.supportedLookupTypes.includes('LessThan',/* LessThan */
-      )
-    ) {
-      return new LookupIndexPlan(index, [{
-        type: 'LessThan',
-        value: rightExpression.evaluate(),
-        inclusive: false,
-      }, ...fillerAllQueries,],);
-    }
-    if (
-      expression instanceof ScalarComparisonLessThanOrEqual && index.supportedLookupTypes.includes('LessThan',/* LessThan */
-      )
-    ) {
-      return new LookupIndexPlan(index, [{
-        type: 'LessThan',
-        value: rightExpression.evaluate(),
-        inclusive: true,
-      }, ...fillerAllQueries,],);
-    }
-    if (
-      expression instanceof ScalarComparisonGreaterThan && index.supportedLookupTypes.includes('GreaterThan',/* GreaterThan */
-      )
-    ) {
-      return new LookupIndexPlan(index, [{
-        type: 'GreaterThan',
-        value: rightExpression.evaluate(),
-        inclusive: false,
-      }, ...fillerAllQueries,],);
-    }
-    if (
-      expression instanceof ScalarComparisonGreaterThanOrEqual && index.supportedLookupTypes.includes('GreaterThan',/* GreaterThan */
-      )
-    ) {
-      return new LookupIndexPlan(index, [{
-        type: 'GreaterThan',
-        value: rightExpression.evaluate(),
-        inclusive: true,
-      }, ...fillerAllQueries,],);
-    }
-  }
-}
-function findLookupIndexPlanForFunctionCall(collection, expression,) {
-  if (expression.argumentExpressions.length !== 2) return;
-  const sourceExpression = expression.argumentExpressions[0];
-  const targetExpression = expression.argumentExpressions[1];
-  if (isUndefined(sourceExpression,)) return;
-  if (isUndefined(targetExpression,)) return;
-  if (!(targetExpression instanceof ScalarLiteralValue)) return;
-  for (const index of collection.indexes) {
-    const field = index.fields[0];
-    if (isUndefined(field,)) continue;
-    const fieldExpression = ScalarExpression.from(field, collection.schema,);
-    if (!sourceExpression.equals(fieldExpression,)) continue;
-    const fillerAllQueries = new Array(index.fields.length - 1,).fill({
-      type: 'All',
-      /* All */
-    },);
-    if (
-      expression instanceof ScalarFunctionCallContains && index.supportedLookupTypes.includes('Contains',/* Contains */
-      )
-    ) {
-      return new LookupIndexPlan(index, [{
-        type: 'Contains',
-        value: targetExpression.evaluate(),
-      }, ...fillerAllQueries,],);
-    }
-    if (
-      expression instanceof ScalarFunctionCallStartsWith && index.supportedLookupTypes.includes('StartsWith',/* StartsWith */
-      )
-    ) {
-      return new LookupIndexPlan(index, [{
-        type: 'StartsWith',
-        value: targetExpression.evaluate(),
-      }, ...fillerAllQueries,],);
-    }
-    if (
-      expression instanceof ScalarFunctionCallEndsWith && index.supportedLookupTypes.includes('EndsWith',/* EndsWith */
-      )
-    ) {
-      return new LookupIndexPlan(index, [{
-        type: 'EndsWith',
-        value: targetExpression.evaluate(),
-      }, ...fillerAllQueries,],);
-    }
-  }
-}
-function createScanCollectionPlan(collection, expression,) {
-  const plan = new ScanCollectionPlan(collection, void 0,);
-  return new FilterItemsPlan(plan, expression,);
-}
-function needsNewQueryOptimizer(query,) {
-  if (query.from.type !== 'Collection') return true;
-  for (const expression of query.select) {
-    if (expression.type === 'Identifier') return true;
-  }
-  if (query.where) return hasScalarIn(query.where,);
-  return false;
-}
-function hasScalarIn(expression,) {
-  switch (expression.type) {
-    case 'UnaryOperation': {
-      return hasScalarIn(expression.value,);
-    }
-    case 'BinaryOperation': {
-      if (expression.operator === 'in') {
-        return true;
-      }
-      return hasScalarIn(expression.left,) || hasScalarIn(expression.right,);
-    }
-    default:
-      return false;
-  }
-}
 var defaultVariantKey = 'default';
 var defaultVariants = /* @__PURE__ */ new Set([defaultVariantKey,],);
 var _variantHashes;
@@ -53162,7 +51328,7 @@ MotionValue.prototype.addChild = function ({
   return child;
 };
 if (false) {
-  MainLoop.start();
+  MainLoop2.start();
 }
 export {
   _injectRuntime,
@@ -53307,7 +51473,6 @@ export {
   getFontsFromSharedStyle,
   getLoadingLazyAtYPosition,
   getMeasurableCodeComponentChildren,
-  getMergedConstraintsProps,
   getPropertyControls,
   getWhereExpressionFromPathVariables,
   gradientForShape,