unframer 2.7.6 → 2.7.8

package/dist/framer.js

@@ -102,7 +102,6 @@ exports.getFontsFromComponentPreset = getFontsFromComponentPreset;
 exports.getFontsFromSharedStyle = getFontsFromSharedStyle;
 exports.getLoadingLazyAtYPosition = getLoadingLazyAtYPosition;
 exports.getMeasurableCodeComponentChildren = getMeasurableCodeComponentChildren;
-exports.getMergedConstraintsProps = getMergedConstraintsProps;
 exports.getPropertyControls = getPropertyControls;
 exports.getWhereExpressionFromPathVariables = getWhereExpressionFromPathVariables;
 exports.gradientForShape = gradientForShape;
@@ -5709,9 +5708,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',];
@@ -14631,7 +14630,7 @@ function steps(numSteps, direction = 'end') {
         return clamp(0, 1, rounded / numSteps);
     };
 }
-// https :https://app.framerstatic.com/framer.7SGKTLCE.mjs
+// https :https://app.framerstatic.com/framer.NFOIY3CW.mjs
 init_chunk_QLPHEVXG();
 const react_11 = __importDefault(require("react"));
 const react_12 = require("react");
@@ -16107,41 +16106,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 () {
@@ -22628,7 +22592,9 @@ 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':
@@ -22644,6 +22610,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);
@@ -22689,16 +22667,6 @@ function pinnedOffset(start, end) {
         return null;
     return start + end;
 }
-function getMergedConstraintsProps(props, constraints) {
-    const result = {};
-    if (props.constraints) {
-        result.constraints = Object.assign(Object.assign({}, props.constraints), constraints);
-    }
-    else {
-        Object.assign(result, constraints);
-    }
-    return result;
-}
 function containsInvalidStringValues(props) {
     if (typeof props.right === 'string')
         return true;
@@ -23063,8 +23031,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)));
@@ -23075,8 +23043,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))));
@@ -37429,7 +37397,6 @@ var Fetcher = /* @__PURE__ */ React2.forwardRef(function Fetcher2(_j, ref) {
 exports.Fetcher = Fetcher;
 var callEach = (...fns) => fns.forEach((fn) => fn && fn());
 exports.callEach = callEach;
-var import_archy = __toESM(require_archy(), 1);
 function getLogger(name) {
     return {
         trace(...args) {
@@ -37628,11 +37595,6 @@ function castDate(value) {
     }
     return null;
 }
-function toDate(value) {
-    var _j;
-    const cast = castDate(value);
-    return (_j = (cast == null ? void 0 : cast.value)) !== null && _j !== void 0 ? _j : null;
-}
 function castEnum(value) {
     switch (value == null ? void 0 : value.type) {
         case 'enum': {
@@ -38127,1431 +38089,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) {
-        var _j;
-        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 = (_j = schema[name]) !== null && _j !== void 0 ? _j : 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) {
-        var _j, _k, _l;
-        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 (_k = (_j = item.data[scopedName]) !== null && _j !== void 0 ? _j : item.data[name]) !== null && _k !== void 0 ? _k : null;
-        }
-        return (_l = item.data[name]) !== null && _l !== void 0 ? _l : 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) {
-        var _j;
-        let result = null;
-        let isNullable = false;
-        for (const definition of definitions) {
-            result !== null && result !== void 0 ? result : (result = definition);
-            if (result && definition && result.type !== definition.type) {
-                throw new Error('Incompatible types in CASE expression');
-            }
-            isNullable || (isNullable = (_j = (definition == null ? void 0 : definition.isNullable)) !== null && _j !== void 0 ? _j : true);
-        }
-        return result
-            ? Object.assign(Object.assign({}, 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 _j, _k;
-        var _a, _b;
-        const value = (_j = ((_a = this.valueExpression) == null ? void 0 : _a.evaluate(item))) !== null && _j !== void 0 ? _j : 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 (_k = ((_b = this.elseExpression) == null ? void 0 : _b.evaluate(item))) !== null && _k !== void 0 ? _k : 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) {
-    var _j;
-    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 (_j = ScalarCase.getDefinition(definitions)) !== null && _j !== void 0 ? _j : 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);
-    }
-    execute() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const start = performance.now();
-            const result = yield 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)}`,
-        };
-    }
-    _execute() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const items = yield this.collection.scanItems();
-            if (isUndefined(this.alias))
-                return items;
-            return items.map((item) => {
-                const data2 = Object.assign({}, 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() {
-        var _j, _k;
-        const childPlansTime = Math.max((_j = this.leftPlan.executionTime) !== null && _j !== void 0 ? _j : 0, (_k = this.rightPlan.executionTime) !== null && _k !== void 0 ? _k : 0);
-        return {
-            label: `LeftJoinPlan ${stringifyExecutionTime(this.executionTime - childPlansTime, this.executionTime)} ${stringifyItems(this.itemCount)}`,
-            nodes: [this.leftPlan.inspect(), this.rightPlan.inspect(),],
-        };
-    }
-    _execute() {
-        return __awaiter(this, void 0, void 0, function* () {
-            var _a;
-            const leftItems = yield this.leftPlan.execute();
-            const rightItems = yield this.rightPlan.execute();
-            const result = [];
-            for (const leftItem of leftItems) {
-                let hasMatch = false;
-                for (const rightItem of rightItems) {
-                    const combinedItem = {
-                        pointer: leftItem.pointer,
-                        data: Object.assign(Object.assign({}, 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)}`,
-        };
-    }
-    _execute() {
-        return __awaiter(this, void 0, void 0, function* () {
-            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) => { var _j; return (_j = childPlan.executionTime) !== null && _j !== void 0 ? _j : 0; }));
-        return {
-            label: `UnionPlan ${stringifyExecutionTime(this.executionTime - childPlansTime, this.executionTime)} ${stringifyItems(this.itemCount)}`,
-            nodes: this.childPlans.map((childPlan) => childPlan.inspect()),
-        };
-    }
-    _execute() {
-        return __awaiter(this, void 0, void 0, function* () {
-            var _j;
-            const childItemMaps = yield Promise.all(this.childPlans.map((childPlan) => __awaiter(this, void 0, void 0, function* () {
-                const items = yield childPlan.execute();
-                return new DatabaseItemMap(items);
-            })));
-            let result;
-            for (const itemMap of childItemMaps) {
-                if (result) {
-                    result = result.union(itemMap);
-                }
-                else {
-                    result = itemMap;
-                }
-            }
-            return (_j = (result == null ? void 0 : result.items())) !== null && _j !== void 0 ? _j : [];
-        });
-    }
-};
-var IntersectionPlan = class extends QueryPlan {
-    constructor(childPlans) {
-        super();
-        this.childPlans = childPlans;
-    }
-    inspect() {
-        const childPlansTime = Math.max(...this.childPlans.map((childPlan) => { var _j; return (_j = childPlan.executionTime) !== null && _j !== void 0 ? _j : 0; }));
-        return {
-            label: `IntersectionPlan ${stringifyExecutionTime(this.executionTime - childPlansTime, this.executionTime)} ${stringifyItems(this.itemCount)} ${stringifyItems(this.itemCount)}`,
-            nodes: this.childPlans.map((childPlan) => childPlan.inspect()),
-        };
-    }
-    _execute() {
-        return __awaiter(this, void 0, void 0, function* () {
-            var _j;
-            const childItemMaps = yield Promise.all(this.childPlans.map((childPlan) => __awaiter(this, void 0, void 0, function* () {
-                const items = yield childPlan.execute();
-                return new DatabaseItemMap(items);
-            })));
-            let result;
-            for (const itemMap of childItemMaps) {
-                if (result) {
-                    result = result.intersection(itemMap);
-                }
-                else {
-                    result = itemMap;
-                }
-            }
-            return (_j = (result == null ? void 0 : result.items())) !== null && _j !== void 0 ? _j : [];
-        });
-    }
-};
-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(),],
-        };
-    }
-    _execute() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const childItems = yield 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(),],
-        };
-    }
-    _execute() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const childItems = yield 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(),],
-        };
-    }
-    _execute() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const childItems = yield this.childPlan.execute();
-            return childItems.sort((leftItem, rightItem) => {
-                const leftSortItem = Object.assign(Object.assign({}, leftItem), { data: {} });
-                const rightSortItem = Object.assign(Object.assign({}, 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 _j, _k;
-        var _a, _b;
-        return {
-            label: `SliceItemsPlan(LIMIT ${(_j = ((_a = this.limitExpression) == null ? void 0 : _a.stringify())) !== null && _j !== void 0 ? _j : 'Infinity'}, OFFSET ${(_k = ((_b = this.offsetExpression) == null ? void 0 : _b.stringify())) !== null && _k !== void 0 ? _k : '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;
-    }
-    _execute() {
-        return __awaiter(this, void 0, void 0, function* () {
-            var _j, _k;
-            const childItems = yield this.childPlan.execute();
-            const offset = (_j = this.getOffset()) !== null && _j !== void 0 ? _j : 0;
-            const limit = (_k = this.getLimit()) !== null && _k !== void 0 ? _k : 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) {
-        var _j;
-        const scopedCache = (_j = this.cache.get(key7)) !== null && _j !== void 0 ? _j : 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,
@@ -40113,7 +38650,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();
@@ -40180,7 +38717,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 _j, _k;
@@ -42996,7 +41533,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) {
@@ -43225,37 +41762,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);
-    }
     query(query, locale) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (this.useNewOptimizer || needsNewQueryOptimizer(query)) {
-                return this.queryNew(query, locale);
-            }
-            return this.queryOld(query, locale);
-        });
-    }
-    queryNew(query, locale) {
         return __awaiter(this, void 0, void 0, function* () {
             log.debug(`Query:
 ${stringifyQuery(query)}`);
@@ -43297,278 +41805,8 @@ ${stringifyQuery(query)}`);
             return (_j = (value == null ? void 0 : value.value)) !== null && _j !== void 0 ? _j : null;
         });
     }
-    queryOld(query, locale) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const [plan, schema, richTextResolver,] = this.createQueryPlan(query, locale);
-            const items = yield 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) => {
-                var _j;
-                return new ScalarOrderExpression(ScalarExpression.from(expression, schema), (_j = expression.direction) !== null && _j !== void 0 ? _j : 'asc', {
-                    type: 0,
-                    /* CaseInsensitive */
-                });
-            });
-        plan = new SortItemsPlan(plan, sortExpressions !== null && sortExpressions !== void 0 ? 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,];
-    }
-    executeQueryPlan(schema, richTextResolver, query, plan) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const items = yield plan.execute();
-            return Promise.all(items.map((item) => __awaiter(this, void 0, void 0, function* () {
-                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] = yield resolveValue(richTextResolver, expression.type === 'Identifier' ? expression.name : void 0, value);
-                }
-                return data2;
-            })));
-        });
-    }
 };
 exports.QueryEngine = QueryEngine;
-function getSelectKey(expression) {
-    if (expression.alias) {
-        return expression.alias;
-    }
-    if (expression.type === 'Identifier') {
-        return expression.name;
-    }
-    throw new Error('Can\'t serialize expression');
-}
-function resolveValue(richTextResolver, key7, value) {
-    return __awaiter(this, void 0, void 0, function* () {
-        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) {
-    var _j;
-    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 (_j = findLookupIndexPlan(collection, expression)) !== null && _j !== void 0 ? _j : 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')) {
-            return new LookupIndexPlan(index, [{
-                    type: 'Equals',
-                    value: rightExpression.evaluate(),
-                }, ...fillerAllQueries,]);
-        }
-        if (expression instanceof ScalarComparisonNotEquals && index.supportedLookupTypes.includes('NotEquals')) {
-            return new LookupIndexPlan(index, [{
-                    type: 'NotEquals',
-                    value: rightExpression.evaluate(),
-                }, ...fillerAllQueries,]);
-        }
-        if (expression instanceof ScalarComparisonLessThan && index.supportedLookupTypes.includes('LessThan')) {
-            return new LookupIndexPlan(index, [{
-                    type: 'LessThan',
-                    value: rightExpression.evaluate(),
-                    inclusive: false,
-                }, ...fillerAllQueries,]);
-        }
-        if (expression instanceof ScalarComparisonLessThanOrEqual && index.supportedLookupTypes.includes('LessThan')) {
-            return new LookupIndexPlan(index, [{
-                    type: 'LessThan',
-                    value: rightExpression.evaluate(),
-                    inclusive: true,
-                }, ...fillerAllQueries,]);
-        }
-        if (expression instanceof ScalarComparisonGreaterThan && index.supportedLookupTypes.includes('GreaterThan')) {
-            return new LookupIndexPlan(index, [{
-                    type: 'GreaterThan',
-                    value: rightExpression.evaluate(),
-                    inclusive: false,
-                }, ...fillerAllQueries,]);
-        }
-        if (expression instanceof ScalarComparisonGreaterThanOrEqual && index.supportedLookupTypes.includes('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')) {
-            return new LookupIndexPlan(index, [{
-                    type: 'Contains',
-                    value: targetExpression.evaluate(),
-                }, ...fillerAllQueries,]);
-        }
-        if (expression instanceof ScalarFunctionCallStartsWith && index.supportedLookupTypes.includes('StartsWith')) {
-            return new LookupIndexPlan(index, [{
-                    type: 'StartsWith',
-                    value: targetExpression.evaluate(),
-                }, ...fillerAllQueries,]);
-        }
-        if (expression instanceof ScalarFunctionCallEndsWith && index.supportedLookupTypes.includes('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;
@@ -50458,7 +48696,7 @@ MotionValue.prototype.addChild = function ({ transformer = (v) => v, }) {
     return child;
 };
 if (false) {
-    MainLoop.start();
+    MainLoop2.start();
 }
 /**
  * @license Emotion v11.0.0