rea-agents 6.5.0 → 6.7.0

package/dist/domain/javascript/javascriptSemanticMutationInitializers.js

@@ -1,4 +1,5 @@
 import * as t from "@babel/types";
+import { delayedInstanceFieldValue, semanticBranchMayBeSkipped, semanticIterationCardinality, } from "./javascriptSemanticEvaluationOrder.js";
 import { semanticStaticPropertyKey, unwrapJavaScriptExpression, } from "./javascriptAstValues.js";
 const initializerPositionCaches = new WeakMap();
 const initializerPositionCache = (parents) => {
@@ -9,6 +10,9 @@ const initializerPositionCache = (parents) => {
         direct: new WeakMap(),
         mutation: new WeakMap(),
         reference: new WeakMap(),
+        read: new WeakMap(),
+        evaluationChildren: new WeakMap(),
+        expressionAncestry: undefined,
     };
     initializerPositionCaches.set(parents, created);
     return created;
@@ -42,16 +46,15 @@ export const semanticTopLevelEffectFollowsCapture = (capture, effect, parents) =
         while (node !== undefined) {
             if (t.isFunction(node) || t.isLoop(node))
                 return null;
-            if ((t.isClassProperty(node) ||
-                t.isClassPrivateProperty(node) ||
-                t.isClassAccessorProperty(node)) &&
-                !node.static &&
-                node.value === child)
+            if (delayedInstanceFieldValue(node, child))
                 return null;
             if (t.isVariableDeclarator(node))
                 declarator = node;
-            if (selected === null && t.isStatement(node))
-                selected = statementPosition(node, parents, declarator);
+            if (t.isStatement(node)) {
+                const enclosing = statementPosition(node, parents, declarator);
+                if (enclosing !== null)
+                    selected = enclosing;
+            }
             if (t.isProgram(node))
                 return selected;
             child = node;
@@ -69,57 +72,200 @@ export const semanticTopLevelEffectFollowsCapture = (capture, effect, parents) =
         before.index !== after.index ||
         before.declaratorIndex !== after.declaratorIndex)
         return false;
-    return expressionEvaluationPrecedes(capture, effect, parents);
+    return expressionEvaluationOrder(capture, effect, parents) === "before";
 };
-/** Prove ordering only where JavaScript evaluates sibling expressions left-to-right. */
-const expressionEvaluationPrecedes = (earlier, later, parents) => {
-    if (later === undefined)
+/** Include expression order when a write operation contains the read site. */
+export const semanticEffectFollowsReference = (reference, effect, parents) => {
+    if (reference === effect)
         return false;
-    const earlierAncestors = new Set();
-    let current = earlier;
-    while (current !== undefined) {
-        earlierAncestors.add(current);
+    let current = reference;
+    let child;
+    while (current !== undefined && current !== effect) {
+        if (t.isFunction(current))
+            break;
+        child = current;
         current = parents.get(current);
     }
-    const laterPath = [];
-    current = later;
-    while (current !== undefined && !earlierAncestors.has(current)) {
-        laterPath.push(current);
-        current = parents.get(current);
+    const loopInput = (t.isForInStatement(effect) || t.isForOfStatement(effect)) &&
+        child === effect.right;
+    let once = current;
+    child = undefined;
+    while (once !== undefined) {
+        const initialLoopInput = (t.isForStatement(once) && child === once.init) ||
+            ((t.isForInStatement(once) || t.isForOfStatement(once)) &&
+                child === once.right) ||
+            (once === effect && loopInput);
+        if (t.isFunction(once) ||
+            (t.isLoop(once) && !initialLoopInput) ||
+            delayedInstanceFieldValue(once, child))
+            break;
+        child = once;
+        once = parents.get(once);
     }
-    const common = current;
-    if (common === undefined || common === earlier || common === later)
-        return false;
-    let earlierChild = earlier;
-    while (parents.get(earlierChild) !== common) {
-        const parent = parents.get(earlierChild);
-        if (parent === undefined)
-            return false;
-        earlierChild = parent;
+    return ((current === effect &&
+        once === undefined &&
+        (t.isAssignmentExpression(effect) ||
+            t.isUpdateExpression(effect) ||
+            t.isVariableDeclarator(effect) ||
+            t.isCallExpression(effect) ||
+            t.isOptionalCallExpression(effect) ||
+            t.isNewExpression(effect))) ||
+        (current === effect && once === undefined && loopInput) ||
+        semanticTopLevelEffectFollowsCapture(reference, effect, parents));
+};
+export const semanticEffectTiming = (site, effect, state) => {
+    if (effect === undefined)
+        return "unknown";
+    // Invocation receives arguments after their values have been selected.
+    if (site === effect &&
+        (t.isCallExpression(site) ||
+            t.isOptionalCallExpression(site) ||
+            t.isNewExpression(site)))
+        return "after";
+    const loop = semanticEnclosingIteration(effect, state);
+    if (loop !== undefined) {
+        const cardinality = semanticIterationCardinality(loop, state.prototypeEnumerationMayAffect);
+        if (cardinality === "empty")
+            return "after";
+        if (cardinality === "nonempty") {
+            const loopParent = state.parentsByNode.get(loop);
+            const crossesFunction = (node) => {
+                let current = node;
+                while (current !== undefined) {
+                    if (t.isFunction(current))
+                        return true;
+                    current = state.parentsByNode.get(current);
+                }
+                return false;
+            };
+            if (loopParent === state.program &&
+                !crossesFunction(site) &&
+                typeof loop.start === "number" &&
+                typeof loop.end === "number" &&
+                typeof site.start === "number") {
+                if (site.start > loop.end)
+                    return "before";
+                if (site.start < loop.start)
+                    return "after";
+            }
+        }
     }
-    const laterChild = laterPath.at(-1);
-    if (laterChild === undefined)
-        return false;
-    const orderedChildren = (() => {
-        if (t.isSequenceExpression(common))
-            return common.expressions;
-        if (t.isCallExpression(common) || t.isOptionalCallExpression(common))
-            return [common.callee, ...common.arguments];
-        if (t.isNewExpression(common))
-            return [common.callee, ...common.arguments];
-        if (t.isBinaryExpression(common) || t.isLogicalExpression(common))
-            return [common.left, common.right];
-        if (t.isConditionalExpression(common))
-            return [common.test];
+    if (semanticEffectFollowsReference(site, effect, state.parentsByNode))
+        return "after";
+    if (semanticEffectFollowsReference(effect, site, state.parentsByNode))
+        return "before";
+    return "unknown";
+};
+const semanticEnclosingIteration = (node, state) => {
+    let current = node;
+    while (current !== undefined) {
+        if (t.isForInStatement(current) || t.isForOfStatement(current))
+            return current;
+        if (t.isFunction(current))
+            return undefined;
+        current = state.parentsByNode.get(current);
+    }
+    return undefined;
+};
+/** Memoize descendant paths toward the currently compared source expression. */
+const expressionSiblings = (earlier, later, parents) => {
+    const cache = initializerPositionCache(parents);
+    let context = cache.expressionAncestry;
+    if (context?.source !== earlier) {
+        const ancestors = new Map();
+        let child;
+        for (let node = earlier; node !== undefined; node = parents.get(node)) {
+            ancestors.set(node, child);
+            child = node;
+        }
+        context = { source: earlier, ancestors, siblings: new WeakMap() };
+        cache.expressionAncestry = context;
+    }
+    const path = [];
+    let result = null;
+    for (let node = later; node !== undefined; node = parents.get(node)) {
+        if (context.ancestors.has(node)) {
+            const sourceChild = context.ancestors.get(node);
+            const readChild = path.at(-1);
+            if (sourceChild !== undefined && readChild !== undefined)
+                result = { common: node, earlier: sourceChild, later: readChild };
+            break;
+        }
+        const cached = context.siblings.get(node);
+        if (cached !== undefined) {
+            result = cached;
+            break;
+        }
+        path.push(node);
+    }
+    for (const node of path)
+        context.siblings.set(node, result);
+    return result;
+};
+/** Index existing child arrays once; wide literals/calls need no repeated copies. */
+const expressionChildIndices = (node, parents) => {
+    const cache = initializerPositionCache(parents).evaluationChildren;
+    const cached = cache.get(node);
+    if (cached !== undefined)
+        return cached;
+    const children = (() => {
+        if (t.isSequenceExpression(node))
+            return node.expressions;
+        if (t.isArrayExpression(node))
+            return node.elements;
+        if (t.isObjectExpression(node))
+            return node.properties;
+        if (t.isObjectProperty(node))
+            return node.computed ? [node.key, node.value] : [node.value];
+        if (t.isCallExpression(node) ||
+            t.isOptionalCallExpression(node) ||
+            t.isNewExpression(node))
+            return node.arguments;
+        if (t.isBinaryExpression(node) || t.isLogicalExpression(node))
+            return [node.left, node.right];
+        if (t.isConditionalExpression(node))
+            return [node.test];
         return null;
     })();
-    if (orderedChildren === null)
-        return false;
-    const earlierIndex = orderedChildren.indexOf(earlierChild);
-    const laterIndex = orderedChildren.indexOf(laterChild);
-    return earlierIndex >= 0 && laterIndex > earlierIndex;
+    if (children === null) {
+        cache.set(node, null);
+        return null;
+    }
+    const indices = new Map();
+    let index = 0;
+    if (t.isCallExpression(node) ||
+        t.isOptionalCallExpression(node) ||
+        t.isNewExpression(node))
+        indices.set(node.callee, index++);
+    for (const child of children) {
+        if (child !== null)
+            indices.set(child, index);
+        index++;
+    }
+    cache.set(node, indices);
+    return indices;
+};
+/** Unproved ordering stays distinct from proof that a write follows the read. */
+const expressionEvaluationOrder = (earlier, later, parents) => {
+    if (later === undefined)
+        return "unresolved";
+    const siblings = expressionSiblings(earlier, later, parents);
+    if (siblings === null)
+        return "unresolved";
+    const children = expressionChildIndices(siblings.common, parents);
+    const earlierIndex = children?.get(siblings.earlier);
+    const laterIndex = children?.get(siblings.later);
+    if (earlierIndex === undefined ||
+        laterIndex === undefined ||
+        earlierIndex === laterIndex)
+        return "unresolved";
+    return earlierIndex < laterIndex ? "before" : "after";
 };
 const computeDirectInitializerPosition = (node, parents) => {
+    if ((t.isAssignmentExpression(node) &&
+        t.isIdentifier(unwrapJavaScriptExpression(node.left).node)) ||
+        t.isUpdateExpression(node))
+        return directMutationPosition(node, parents);
     const parent = parents.get(node);
     if (t.isVariableDeclarator(parent) && parent.init === node) {
         const declaration = parents.get(parent);
@@ -128,13 +274,9 @@ const computeDirectInitializerPosition = (node, parents) => {
             : null;
     }
     if (t.isAssignmentExpression(parent) &&
-        parent.operator === "=" &&
         parent.right === node &&
         t.isIdentifier(parent.left)) {
-        const statement = parents.get(parent);
-        return t.isExpressionStatement(statement) && statement.expression === parent
-            ? statementPosition(statement, parents)
-            : null;
+        return directMutationPosition(parent, parents);
     }
     return null;
 };
@@ -175,8 +317,7 @@ const computeDirectMutationPosition = (node, parents) => {
         const parent = parents.get(current);
         if (parent === undefined ||
             t.isFunction(parent) ||
-            (t.isLogicalExpression(parent) && parent.right === current) ||
-            (t.isConditionalExpression(parent) && parent.test !== current))
+            semanticBranchMayBeSkipped(parent, current))
             return null;
         if (t.isStatement(parent))
             return statementPosition(parent, parents);
@@ -206,7 +347,13 @@ const computeReferenceInitializerPosition = (node, parents) => {
         if (direct !== null)
             return direct;
         const parent = parents.get(current);
-        if (parent === undefined || t.isStatement(parent) || t.isFunction(parent))
+        if (t.isFunction(parent))
+            return t.isBlockStatement(parent.body)
+                ? { body: parent.body.body, index: -1, declaratorIndex: -1 }
+                : null;
+        if (parent === undefined ||
+            t.isStatement(parent) ||
+            delayedInstanceFieldValue(parent, current))
             return null;
         if (t.isVariableDeclarator(parent)) {
             const declaration = parents.get(parent);
@@ -226,6 +373,14 @@ const referenceInitializerPosition = (node, parents) => {
     cache.reference.set(node, computed);
     return computed;
 };
+/** Parameter-to-body copies and ordinary expressions share one position owner. */
+const initializerPosition = (initializer, parents, reference = false) => {
+    if (initializer.entryBody !== undefined)
+        return { body: initializer.entryBody.body, index: -1, declaratorIndex: -1 };
+    return reference
+        ? referenceInitializerPosition(initializer.node, parents)
+        : directInitializerPosition(initializer.node, parents);
+};
 /** Resolve origins at their use or capture, never at a later transitive effect. */
 export const semanticMutationInitializers = (binding, mutation, parents) => {
     const mutationPosition = directMutationPosition(mutation, parents) ??
@@ -235,102 +390,216 @@ export const semanticMutationInitializers = (binding, mutation, parents) => {
     const origins = [
         ...binding.initializers.map((initializer) => ({
             initializer,
-            position: initializer.entryBody === undefined
-                ? directInitializerPosition(initializer.node, parents)
-                : {
-                    body: initializer.entryBody.body,
-                    index: -1,
-                    declaratorIndex: -1,
-                },
+            position: initializerPosition(initializer, parents),
         })),
         ...binding.referenceInitializers.map((initializer) => ({
             initializer,
-            position: referenceInitializerPosition(initializer.node, parents),
+            position: initializerPosition(initializer, parents, true),
         })),
     ];
     if (origins.some(({ position }) => position === null || !positionPrecedes(position, mutationPosition)))
         return binding;
-    const latest = origins.reduce((latest, { position }) => position !== null &&
-        (latest === null || positionPrecedes(latest, position))
-        ? position
-        : latest, null);
-    const retained = new Set(origins
-        .filter(({ position }) => position?.index === latest?.index &&
-        position?.declaratorIndex === latest?.declaratorIndex)
-        .map(({ initializer }) => initializer));
+    const { retained, replacesEntry } = retainedInitializerOrigins(origins, binding, parents);
     return {
         // A proven earlier assignment replaces even an import-equals value. A
         // capture before or inside an uncertain assignment retains the full binding.
-        directOrigins: origins.length === 0 ? binding.directOrigins : [],
+        directOrigins: replacesEntry ? [] : binding.directOrigins,
         initializers: binding.initializers.filter((initializer) => retained.has(initializer)),
         referenceInitializers: binding.referenceInitializers.filter((initializer) => retained.has(initializer)),
     };
 };
-/** Select a local alias at its read, before any later straight-line reassignment. */
-export const semanticReadInitializers = (binding, read, parents) => {
-    let position = null;
+/** Reuse immutable ancestry facts across reads nested in the same expression. */
+const bindingReadPosition = (read, parents) => {
+    const cache = initializerPositionCache(parents).read;
+    const path = [];
     let current = read;
-    for (let parent = parents.get(current); parent; parent = parents.get(current)) {
-        if (t.isLoop(parent))
-            return binding;
-        if (t.isFunction(parent))
+    let result;
+    while (true) {
+        const cached = cache.get(current);
+        if (cached !== undefined) {
+            result = cached;
+            break;
+        }
+        path.push(current);
+        const parent = parents.get(current);
+        if (t.isLoop(parent)) {
+            result = { position: null, repeating: true };
+            break;
+        }
+        if (parent === undefined ||
+            t.isFunction(parent) ||
+            delayedInstanceFieldValue(parent, current)) {
+            result = { position: null, repeating: false };
             break;
-        if (position === null) {
-            if (t.isVariableDeclarator(parent)) {
-                const declaration = parents.get(parent);
-                if (t.isVariableDeclaration(declaration))
-                    position = statementPosition(declaration, parents, parent);
-            }
-            else if (t.isStatement(parent))
-                position = statementPosition(parent, parents);
         }
         current = parent;
     }
-    return selectInitializers(binding, position, parents, true);
+    for (let index = path.length - 1; index >= 0; index--) {
+        const node = path[index];
+        if (node === undefined)
+            continue;
+        const parent = parents.get(node);
+        let position = null;
+        if (t.isVariableDeclarator(parent)) {
+            const declaration = parents.get(parent);
+            if (t.isVariableDeclaration(declaration))
+                position = statementPosition(declaration, parents, parent);
+        }
+        else if (t.isStatement(parent) &&
+            !t.isLoop(parent) &&
+            !t.isFunction(parent))
+            position = statementPosition(parent, parents);
+        if (position !== null && position !== result.position)
+            result = { ...result, position };
+        cache.set(node, result);
+    }
+    return result;
+};
+export const semanticBindingAtRead = (binding, read, parents) => {
+    if (binding.initializers.length === 0 &&
+        binding.referenceInitializers.length === 0)
+        return { status: "ordered", binding, hasDefiniteInitializer: false };
+    const initializer = binding.initializers[0];
+    const reference = binding.referenceInitializers[0];
+    const origin = initializer ?? reference;
+    const sourcePosition = initializer === undefined
+        ? reference === undefined
+            ? null
+            : initializerPosition(reference, parents, true)
+        : initializerPosition(initializer, parents);
+    const { position, repeating } = bindingReadPosition(read, parents);
+    // Coverage and latest-value selection are independent. A preceding write
+    // can cover entry even when another write's order remains unknown.
+    const hasDefiniteInitializer = position !== null &&
+        binding.initializers.some((initializer) => {
+            const source = initializerPosition(initializer, parents);
+            return (source !== null &&
+                positionPrecedes(source, position) &&
+                !initializerMayRetainEntry(initializer, binding, parents));
+        });
+    if (!repeating &&
+        origin !== undefined &&
+        binding.initializers.length + binding.referenceInitializers.length === 1 &&
+        sourcePosition !== null &&
+        position !== null &&
+        positionPrecedes(sourcePosition, position))
+        return {
+            status: "ordered",
+            binding,
+            hasDefiniteInitializer,
+        };
+    const uncertainOrder = repeating ||
+        sourcePosition === null ||
+        position === null ||
+        sourcePosition.body !== position.body;
+    if (uncertainOrder)
+        return { status: "unresolved", binding, hasDefiniteInitializer };
+    const selected = selectInitializers(binding, position, read, parents);
+    if (selected === undefined)
+        return { status: "unresolved", binding, hasDefiniteInitializer };
+    if (selected.binding === binding)
+        return {
+            status: "ordered",
+            binding,
+            hasDefiniteInitializer: hasDefiniteInitializer || selected.hasDefiniteInitializer,
+        };
+    return {
+        status: "ordered",
+        hasDefiniteInitializer: hasDefiniteInitializer || selected.hasDefiniteInitializer,
+        binding: {
+            ...binding,
+            ...selected.binding,
+            // Later assignment definitions do not describe the value captured here.
+            definitions: binding.definitions.filter(({ kind }) => kind !== "assignment"),
+        },
+    };
 };
-const selectInitializers = (binding, position, parents, atRead = false) => {
+const selectInitializers = (binding, position, read, parents) => {
     if (position === null)
-        return binding;
+        return undefined;
     const origins = [
         ...binding.initializers.map((initializer) => ({
             initializer,
-            position: initializer.entryBody === undefined
-                ? directInitializerPosition(initializer.node, parents)
-                : {
-                    body: initializer.entryBody.body,
-                    index: -1,
-                    declaratorIndex: -1,
-                },
+            position: initializerPosition(initializer, parents),
         })),
         ...binding.referenceInitializers.map((initializer) => ({
             initializer,
-            position: referenceInitializerPosition(initializer.node, parents),
+            position: initializerPosition(initializer, parents, true),
         })),
     ];
-    if (origins.some(({ position: origin }) => origin === null ||
-        origin.body !== position.body ||
-        (!atRead && !positionPrecedes(origin, position))))
-        return binding;
-    const preceding = atRead
-        ? origins.filter(({ position: origin }) => origin !== null && positionPrecedes(origin, position))
-        : origins;
-    const latest = preceding.reduce((latest, { position }) => position !== null &&
-        (latest === null || positionPrecedes(latest, position))
-        ? position
-        : latest, null);
-    const retained = new Set(preceding
-        .filter(({ position }) => position?.index === latest?.index &&
-        position?.declaratorIndex === latest?.declaratorIndex)
-        .map(({ initializer }) => initializer));
+    const preceding = [];
+    for (const origin of origins) {
+        const source = origin.position;
+        if (source === null || source.body !== position.body)
+            return undefined;
+        if (positionPrecedes(source, position))
+            preceding.push(origin);
+        else if (!positionPrecedes(position, source)) {
+            if (source.index !== position.index ||
+                source.declaratorIndex !== position.declaratorIndex)
+                return undefined;
+            const order = expressionEvaluationOrder(origin.initializer.node, read, parents);
+            // Failure to prove precedence is not proof that the write happens later.
+            if (order === "unresolved")
+                return undefined;
+            if (order === "before")
+                preceding.push(origin);
+        }
+    }
+    const { retained, replacesEntry } = retainedInitializerOrigins(preceding, binding, parents);
     // Preserve the owner's identity when selection removes no facts. Consumers
     // can then reuse the binding's dependency-aware provenance memo rather than
     // treating every equivalent read as a new temporal snapshot.
     if (binding.initializers.every((initializer) => retained.has(initializer)) &&
         binding.referenceInitializers.every((initializer) => retained.has(initializer)))
-        return binding;
+        return { binding, hasDefiniteInitializer: replacesEntry };
     return {
-        initializers: binding.initializers.filter((initializer) => retained.has(initializer)),
-        referenceInitializers: binding.referenceInitializers.filter((initializer) => retained.has(initializer)),
+        hasDefiniteInitializer: replacesEntry,
+        binding: {
+            initializers: binding.initializers.filter((initializer) => retained.has(initializer)),
+            referenceInitializers: binding.referenceInitializers.filter((initializer) => retained.has(initializer)),
+        },
+    };
+};
+/** Logical writes may keep prior aliases. An RHS fact alone does not prove an
+ * empty local: the complete binding must exclude incoming/default/other writes.
+ */
+const initializerMayRetainEntry = (initializer, binding, parents) => {
+    const node = initializer.node, parent = parents.get(node);
+    const assignment = t.isAssignmentExpression(node)
+        ? node
+        : t.isAssignmentExpression(parent) && parent.right === node
+            ? parent
+            : undefined;
+    if (assignment === undefined ||
+        !["&&=", "||=", "??="].includes(assignment.operator))
+        return false;
+    const emptyLocal = node === assignment.right &&
+        binding.kind === "variable" &&
+        !binding.runtimeImport &&
+        binding.initializers.length === 1 &&
+        binding.initializers[0] === initializer &&
+        binding.referenceInitializers.length === 0 &&
+        binding.directOrigins.length === 0 &&
+        binding.definitions.some(({ kind }) => kind === "variable") &&
+        binding.definitions.every(({ kind }) => kind === "variable" || kind === "assignment");
+    return !emptyLocal;
+};
+/** Certain writes replace prior origins; short-circuit writes retain both. */
+const retainedInitializerOrigins = (origins, binding, parents) => {
+    const latest = origins.reduce((latest, { initializer, position }) => position !== null &&
+        !initializerMayRetainEntry(initializer, binding, parents) &&
+        (latest === null || positionPrecedes(latest, position))
+        ? position
+        : latest, null);
+    return {
+        replacesEntry: latest !== null,
+        retained: new Set(origins
+            .filter(({ position }) => latest === null ||
+            (position?.index === latest.index &&
+                position?.declaratorIndex === latest.declaratorIndex) ||
+            (position !== null && positionPrecedes(latest, position)))
+            .map(({ initializer }) => initializer)),
     };
 };
 /** Locate a capture only in an unconditional declaration or literal initializer. */
@@ -356,12 +625,20 @@ export const semanticBindingPrecedesCapture = (binding, capture, parents) => {
     const initializer = binding.initializers[0];
     if (binding.initializers.length !== 1 || initializer === undefined)
         return false;
-    const sourcePosition = directInitializerPosition(initializer.node, parents);
+    const sourcePosition = initializerPosition(initializer, parents);
     const capturePosition = semanticCapturePosition(capture, parents);
     return (sourcePosition !== null &&
         capturePosition !== null &&
         positionPrecedes(sourcePosition, capturePosition));
 };
+/** A preceding initializer and capture in one body precede its later effect. */
+export const semanticBindingEffectFollowsCapture = (binding, capture, effect, parents) => {
+    if (!semanticBindingPrecedesCapture(binding, capture, parents))
+        return false;
+    const captured = semanticCapturePosition(capture, parents);
+    const written = directMutationPosition(effect, parents);
+    return (captured !== null && written !== null && positionPrecedes(captured, written));
+};
 /** Ignore later escapes only while reading earlier references in one activation. */
 export const semanticEscapeFollowsCapture = (binding, capture, escape, parents) => {
     const initializer = binding.initializers[0];