@fluidframework/tree 2.118.1 → 3.0.1

package/dist/feature-libraries/object-forest/objectForest.js

@@ -4,7 +4,8 @@
  * Licensed under the MIT License.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.buildForest = exports.ObjectForest = void 0;
+exports.ObjectForest = void 0;
+exports.buildForest = buildForest;
 const tslib_1 = require("tslib");
 const client_utils_1 = require("@fluid-internal/client-utils");
 const internal_1 = require("@fluidframework/core-utils/internal");
@@ -32,305 +33,312 @@ function getOrCreateField(mapTree, key) {
  * It does not use compressed chunks: instead nodes are implemented using objects.
  */
 let ObjectForest = (() => {
-    var _a, _ObjectForest_events, _ObjectForest_roots;
     let _instanceExtraInitializers = [];
     let _checkSchema_decorators;
-    return _a = class ObjectForest {
-            get roots() {
-                this.breaker.use();
-                return tslib_1.__classPrivateFieldGet(this, _ObjectForest_roots, "f");
-            }
-            constructor(breaker, 
-            /**
-             * If provided, may be used for validation, but otherwise unused.
-             */
-            schema, anchors = new index_js_1.AnchorSet(), additionalAsserts = false, roots) {
-                this.breaker = (tslib_1.__runInitializers(this, _instanceExtraInitializers), breaker);
-                this.schema = schema;
-                this.anchors = anchors;
-                this.additionalAsserts = additionalAsserts;
-                // All cursors that are in the "Current" state. Must be empty when editing.
-                this.currentCursors = new Set();
-                this.deltaVisitors = new Set();
-                _ObjectForest_events.set(this, (0, client_utils_1.createEmitter)());
-                this.events = tslib_1.__classPrivateFieldGet(this, _ObjectForest_events, "f");
-                _ObjectForest_roots.set(this, void 0);
-                this.nextRange = 0;
-                tslib_1.__classPrivateFieldSet(this, _ObjectForest_roots, roots === undefined
+    return class ObjectForest {
+        static {
+            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(null) : void 0;
+            _checkSchema_decorators = [index_js_2.breakingMethod];
+            tslib_1.__esDecorate(this, null, _checkSchema_decorators, { kind: "method", name: "checkSchema", static: false, private: false, access: { has: obj => "checkSchema" in obj, get: obj => obj.checkSchema }, metadata: _metadata }, null, _instanceExtraInitializers);
+            if (_metadata) Object.defineProperty(this, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+        }
+        breaker = tslib_1.__runInitializers(this, _instanceExtraInitializers);
+        schema;
+        anchors;
+        additionalAsserts;
+        activeVisitor;
+        // All cursors that are in the "Current" state. Must be empty when editing.
+        currentCursors = new Set();
+        deltaVisitors = new Set();
+        #events = (0, client_utils_1.createEmitter)();
+        events = this.#events;
+        #roots;
+        get roots() {
+            this.breaker.use();
+            return this.#roots;
+        }
+        constructor(breaker, 
+        /**
+         * If provided, may be used for validation, but otherwise unused.
+         */
+        schema, anchors = new index_js_1.AnchorSet(), additionalAsserts = false, roots) {
+            this.breaker = breaker;
+            this.schema = schema;
+            this.anchors = anchors;
+            this.additionalAsserts = additionalAsserts;
+            this.#roots =
+                roots === undefined
                     ? {
                         type: index_js_1.aboveRootPlaceholder,
                         fields: new Map(),
                     }
-                    : (0, index_js_1.deepCopyMapTree)(roots), "f");
-                if (additionalAsserts) {
-                    this.checkSchema();
-                }
+                    : (0, index_js_1.deepCopyMapTree)(roots);
+            if (additionalAsserts) {
+                this.checkSchema();
             }
-            get isEmpty() {
-                this.breaker.use();
-                return this.roots.fields.size === 0;
-            }
-            clone(schema, breaker) {
-                this.breaker.use();
-                return new _a(breaker ?? this.breaker, schema, undefined, this.additionalAsserts, this.roots);
-            }
-            chunkField(cursor) {
-                this.breaker.use();
-                return (0, index_js_3.chunkField)(cursor, { idCompressor: undefined, policy: index_js_3.defaultChunkPolicy });
-            }
-            forgetAnchor(anchor) {
-                this.anchors.forget(anchor);
+        }
+        get isEmpty() {
+            this.breaker.use();
+            return this.roots.fields.size === 0;
+        }
+        clone(schema, breaker) {
+            this.breaker.use();
+            return new ObjectForest(breaker ?? this.breaker, schema, undefined, this.additionalAsserts, this.roots);
+        }
+        chunkField(cursor) {
+            this.breaker.use();
+            return (0, index_js_3.chunkField)(cursor, { idCompressor: undefined, policy: index_js_3.defaultChunkPolicy });
+        }
+        forgetAnchor(anchor) {
+            this.anchors.forget(anchor);
+        }
+        /**
+         * Throw (and break) if content does not match schema.
+         */
+        checkSchema() {
+            const schema = this.schema;
+            if (schema !== undefined) {
+                const roots = new Set([...this.roots.fields.keys(), index_js_1.rootFieldKey]);
+                for (const key of roots) {
+                    const documentRoot = this.roots.fields.get(key) ?? [];
+                    const fieldSchema = key === index_js_1.rootFieldKey
+                        ? schema.rootFieldSchema
+                        : // TODO: someday we should have schema for detached fields, and use that instead of generating one here.
+                            {
+                                // Some detached fields may have multiple nodes, so we must treat them as sequences:
+                                kind: index_js_4.FieldKinds.sequence.identifier,
+                                types: new Set(documentRoot.map((node) => node.type)),
+                                // Metadata is not used for schema checks
+                                persistedMetadata: undefined,
+                            };
+                    (0, schemaChecker_js_1.isFieldInSchema)(documentRoot, fieldSchema, {
+                        schema,
+                        policy: index_js_4.defaultSchemaPolicy,
+                    }, schemaChecker_js_1.throwOutOfSchema);
+                }
             }
+        }
+        acquireVisitor() {
+            this.breaker.use();
+            (0, internal_1.assert)(this.activeVisitor === undefined, 0x76c /* Must release existing visitor before acquiring another */);
+            // Note: This code uses cursors, however it also modifies the tree.
+            // In general this is not safe, but this code happens to only modify the tree below the current cursor location,
+            // which happens to work.
+            // This pattern could be generalized/formalized with a concept of an exclusive cursor,
+            // which can edit, but is the only cursor allowed at the time.
+            const cursor = this.allocateCursor("acquireVisitor");
+            cursor.setToAboveDetachedSequences();
             /**
-             * Throw (and break) if content does not match schema.
+             * Called before each edit to allow cursor cleanup to happen and ensure that there are no unexpected cursors.
+             * This is required for each change since there may be app facing change event handlers which create cursors.
              */
-            checkSchema() {
-                const schema = this.schema;
-                if (schema !== undefined) {
-                    const roots = new Set([...this.roots.fields.keys(), index_js_1.rootFieldKey]);
-                    for (const key of roots) {
-                        const documentRoot = this.roots.fields.get(key) ?? [];
-                        const fieldSchema = key === index_js_1.rootFieldKey
-                            ? schema.rootFieldSchema
-                            : // TODO: someday we should have schema for detached fields, and use that instead of generating one here.
-                                {
-                                    // Some detached fields may have multiple nodes, so we must treat them as sequences:
-                                    kind: index_js_4.FieldKinds.sequence.identifier,
-                                    types: new Set(documentRoot.map((node) => node.type)),
-                                    // Metadata is not used for schema checks
-                                    persistedMetadata: undefined,
-                                };
-                        (0, schemaChecker_js_1.isFieldInSchema)(documentRoot, fieldSchema, {
-                            schema,
-                            policy: index_js_4.defaultSchemaPolicy,
-                        }, schemaChecker_js_1.throwOutOfSchema);
+            const preEdit = () => {
+                this.#events.emit("beforeChange");
+                (0, internal_1.assert)(this.currentCursors.has(cursor), 0x995 /* missing visitor cursor while editing */);
+                if (this.currentCursors.size > 1) {
+                    const unexpectedSources = [...this.currentCursors].flatMap((c) => c === cursor ? [] : (c.source ?? null));
+                    throw new Error(`Found unexpected cursors when editing with the following annotations: ${JSON.stringify(unexpectedSources)}`);
+                }
+            };
+            class Visitor {
+                forest;
+                constructor(forest) {
+                    this.forest = forest;
+                }
+                free() {
+                    cursor.free();
+                    (0, internal_1.assert)(this.forest.activeVisitor !== undefined, 0x76d /* Multiple free calls for same visitor */);
+                    this.forest.activeVisitor = undefined;
+                    if (this.forest.additionalAsserts) {
+                        // Schema validation:
+                        // When doing "additionalAsserts", validate the content against the schema after every batch of edits.
+                        this.forest.checkSchema();
                     }
                 }
-            }
-            acquireVisitor() {
-                this.breaker.use();
-                (0, internal_1.assert)(this.activeVisitor === undefined, 0x76c /* Must release existing visitor before acquiring another */);
-                // Note: This code uses cursors, however it also modifies the tree.
-                // In general this is not safe, but this code happens to only modify the tree below the current cursor location,
-                // which happens to work.
-                // This pattern could be generalized/formalized with a concept of an exclusive cursor,
-                // which can edit, but is the only cursor allowed at the time.
-                const cursor = this.allocateCursor("acquireVisitor");
-                cursor.setToAboveDetachedSequences();
+                destroy(detachedField, count) {
+                    preEdit();
+                    const field = this.forest.#roots.fields.get(detachedField);
+                    (0, internal_1.assert)(field !== undefined, 0xd28 /* Destroyed field must exist */);
+                    (0, internal_1.assert)(field.length === count, 0xd29 /* Destroy count must match field length */);
+                    this.forest.delete(detachedField);
+                }
+                create(content, destination) {
+                    preEdit();
+                    (0, internal_1.assert)(!this.forest.#roots.fields.has(destination), 0xd2a /* Create destination must be a new empty field */);
+                    this.forest.add(content, destination);
+                    this.forest.#events.emit("afterRootFieldCreated", destination);
+                }
+                attach(source, count, destination) {
+                    preEdit();
+                    this.attachEdit(source, count, destination);
+                }
+                detach(source, destination, id) {
+                    preEdit();
+                    this.detachEdit(source, destination);
+                }
                 /**
-                 * Called before each edit to allow cursor cleanup to happen and ensure that there are no unexpected cursors.
-                 * This is required for each change since there may be app facing change event handlers which create cursors.
+                 * Attaches the nodes from the given source field into the current field.
+                 * Does not invalidate dependents.
+                 * @param source - The the range to be attached.
+                 * @param count - The number of nodes being attached.
+                 * Expected to match the number of nodes in the source detached field.
+                 * @param destination - The index in the current field at which to attach the content.
                  */
-                const preEdit = () => {
-                    tslib_1.__classPrivateFieldGet(this, _ObjectForest_events, "f").emit("beforeChange");
-                    (0, internal_1.assert)(this.currentCursors.has(cursor), 0x995 /* missing visitor cursor while editing */);
-                    if (this.currentCursors.size > 1) {
-                        const unexpectedSources = [...this.currentCursors].flatMap((c) => c === cursor ? [] : (c.source ?? null));
-                        throw new Error(`Found unexpected cursors when editing with the following annotations: ${JSON.stringify(unexpectedSources)}`);
-                    }
-                };
-                class Visitor {
-                    constructor(forest) {
-                        this.forest = forest;
-                    }
-                    free() {
-                        cursor.free();
-                        (0, internal_1.assert)(this.forest.activeVisitor !== undefined, 0x76d /* Multiple free calls for same visitor */);
-                        this.forest.activeVisitor = undefined;
-                        if (this.forest.additionalAsserts) {
-                            // Schema validation:
-                            // When doing "additionalAsserts", validate the content against the schema after every batch of edits.
-                            this.forest.checkSchema();
-                        }
-                    }
-                    destroy(detachedField, count) {
-                        preEdit();
-                        const field = tslib_1.__classPrivateFieldGet(this.forest, _ObjectForest_roots, "f").fields.get(detachedField);
-                        (0, internal_1.assert)(field !== undefined, 0xd28 /* Destroyed field must exist */);
-                        (0, internal_1.assert)(field.length === count, 0xd29 /* Destroy count must match field length */);
-                        this.forest.delete(detachedField);
-                    }
-                    create(content, destination) {
-                        preEdit();
-                        (0, internal_1.assert)(!tslib_1.__classPrivateFieldGet(this.forest, _ObjectForest_roots, "f").fields.has(destination), 0xd2a /* Create destination must be a new empty field */);
-                        this.forest.add(content, destination);
-                        tslib_1.__classPrivateFieldGet(this.forest, _ObjectForest_events, "f").emit("afterRootFieldCreated", destination);
-                    }
-                    attach(source, count, destination) {
-                        preEdit();
-                        this.attachEdit(source, count, destination);
-                    }
-                    detach(source, destination, id) {
-                        preEdit();
-                        this.detachEdit(source, destination);
-                    }
-                    /**
-                     * Attaches the nodes from the given source field into the current field.
-                     * Does not invalidate dependents.
-                     * @param source - The the range to be attached.
-                     * @param count - The number of nodes being attached.
-                     * Expected to match the number of nodes in the source detached field.
-                     * @param destination - The index in the current field at which to attach the content.
-                     */
-                    attachEdit(source, count, destination) {
-                        (0, index_js_2.assertNonNegativeSafeInteger)(count);
-                        const [parent, key] = cursor.getParent();
-                        (0, internal_1.assert)(parent !== this.forest.roots || key !== source, 0xd2b /* Attach source field must be different from current field */);
-                        const sourceField = tslib_1.__classPrivateFieldGet(this.forest, _ObjectForest_roots, "f").fields.get(source);
-                        (0, internal_1.assert)(sourceField !== undefined, 0xd2c /* Attach source field must exist */);
-                        (0, internal_1.assert)(sourceField.length === count, 0xd2d /* Attach must consume all nodes in source field */);
-                        const existingDestinationField = parent.fields.get(key) ?? [];
-                        (0, internal_1.assert)(destination <= existingDestinationField.length, 0xd2e /* Attach destination must not exceed field length */);
-                        (0, index_js_2.assertValidIndex)(destination, existingDestinationField, true);
-                        const currentField = getOrCreateField(parent, key);
-                        // TODO: this will fail for very large insertions due to argument limits.
-                        currentField.splice(destination, 0, ...sourceField);
-                        this.forest.delete(source);
-                    }
-                    /**
-                     * Detaches the range from the current field and transfers it to the given destination if any.
-                     * Does not invalidate dependents.
-                     * @param source - The bounds of the range to be detached from the current field.
-                     * @param destination - If specified, the destination to transfer the detached range to.
-                     * If not specified, the detached range is destroyed.
-                     */
-                    detachEdit(source, destination) {
-                        const [parent, key] = cursor.getParent();
-                        (0, internal_1.assert)(destination === undefined || parent !== this.forest.roots || key !== destination, 0xd2f /* Detach destination field must be different from current field */);
-                        const currentField = parent.fields.get(key) ?? [];
-                        (0, internal_1.assert)(source.start <= source.end, 0xd30 /* Detach range start must not exceed end */);
-                        (0, internal_1.assert)(source.end <= currentField.length, 0xd31 /* Detach range must not exceed field length */);
-                        (0, index_js_2.assertValidRange)(source, currentField);
-                        if (destination !== undefined) {
-                            (0, internal_1.assert)(!tslib_1.__classPrivateFieldGet(this.forest, _ObjectForest_roots, "f").fields.has(destination), 0xd32 /* Detach destination must be a new empty field */);
-                        }
-                        const content = currentField.splice(source.start, source.end - source.start);
-                        if (destination !== undefined) {
-                            this.forest.addFieldAsDetached(content, destination);
-                        }
-                        // This check is performed after the transfer to ensure that the field is not removed in scenarios
-                        // where the source and destination are the same.
-                        if (currentField.length === 0) {
-                            parent.fields.delete(key);
-                        }
-                    }
-                    enterNode(index) {
-                        cursor.enterNode(index);
-                    }
-                    exitNode(index) {
-                        cursor.exitNode();
+                attachEdit(source, count, destination) {
+                    (0, index_js_2.assertNonNegativeSafeInteger)(count);
+                    const [parent, key] = cursor.getParent();
+                    (0, internal_1.assert)(parent !== this.forest.roots || key !== source, 0xd2b /* Attach source field must be different from current field */);
+                    const sourceField = this.forest.#roots.fields.get(source);
+                    (0, internal_1.assert)(sourceField !== undefined, 0xd2c /* Attach source field must exist */);
+                    (0, internal_1.assert)(sourceField.length === count, 0xd2d /* Attach must consume all nodes in source field */);
+                    const existingDestinationField = parent.fields.get(key) ?? [];
+                    (0, internal_1.assert)(destination <= existingDestinationField.length, 0xd2e /* Attach destination must not exceed field length */);
+                    (0, index_js_2.assertValidIndex)(destination, existingDestinationField, true);
+                    const currentField = getOrCreateField(parent, key);
+                    // TODO: this will fail for very large insertions due to argument limits.
+                    currentField.splice(destination, 0, ...sourceField);
+                    this.forest.delete(source);
+                }
+                /**
+                 * Detaches the range from the current field and transfers it to the given destination if any.
+                 * Does not invalidate dependents.
+                 * @param source - The bounds of the range to be detached from the current field.
+                 * @param destination - If specified, the destination to transfer the detached range to.
+                 * If not specified, the detached range is destroyed.
+                 */
+                detachEdit(source, destination) {
+                    const [parent, key] = cursor.getParent();
+                    (0, internal_1.assert)(destination === undefined || parent !== this.forest.roots || key !== destination, 0xd2f /* Detach destination field must be different from current field */);
+                    const currentField = parent.fields.get(key) ?? [];
+                    (0, internal_1.assert)(source.start <= source.end, 0xd30 /* Detach range start must not exceed end */);
+                    (0, internal_1.assert)(source.end <= currentField.length, 0xd31 /* Detach range must not exceed field length */);
+                    (0, index_js_2.assertValidRange)(source, currentField);
+                    if (destination !== undefined) {
+                        (0, internal_1.assert)(!this.forest.#roots.fields.has(destination), 0xd32 /* Detach destination must be a new empty field */);
                     }
-                    enterField(key) {
-                        cursor.enterField(key);
+                    const content = currentField.splice(source.start, source.end - source.start);
+                    if (destination !== undefined) {
+                        this.forest.addFieldAsDetached(content, destination);
                     }
-                    exitField(key) {
-                        cursor.exitField();
+                    // This check is performed after the transfer to ensure that the field is not removed in scenarios
+                    // where the source and destination are the same.
+                    if (currentField.length === 0) {
+                        parent.fields.delete(key);
                     }
                 }
-                const forestVisitor = new Visitor(this);
-                const announcedVisitors = [];
-                for (const getVisitor of this.deltaVisitors) {
-                    announcedVisitors.push(getVisitor());
+                enterNode(index) {
+                    cursor.enterNode(index);
                 }
-                const visitor = (0, index_js_1.combineVisitors)([
-                    (0, index_js_1.makeBreakingVisitor)(forestVisitor, this.breaker),
-                    ...announcedVisitors,
-                ]);
-                this.activeVisitor = visitor;
-                return visitor;
-            }
-            registerAnnouncedVisitor(visitor) {
-                this.deltaVisitors.add(visitor);
-            }
-            deregisterAnnouncedVisitor(visitor) {
-                this.deltaVisitors.delete(visitor);
-            }
-            newDetachedField() {
-                const range = (0, index_js_2.brand)(String(this.nextRange));
-                this.nextRange += 1;
-                return range;
-            }
-            add(nodes, key) {
-                const field = Array.from(nodes, mapTreeCursor_js_1.mapTreeFromCursor);
-                this.addFieldAsDetached(field, key);
-            }
-            addFieldAsDetached(field, key) {
-                (0, internal_1.assert)(!this.roots.fields.has(key), 0x370 /* new range must not already exist */);
-                if (field.length > 0) {
-                    tslib_1.__classPrivateFieldGet(this, _ObjectForest_roots, "f").fields.set(key, field);
+                exitNode(index) {
+                    cursor.exitNode();
+                }
+                enterField(key) {
+                    cursor.enterField(key);
+                }
+                exitField(key) {
+                    cursor.exitField();
                 }
             }
-            delete(field) {
-                tslib_1.__classPrivateFieldGet(this, _ObjectForest_roots, "f").fields.delete(field);
+            const forestVisitor = new Visitor(this);
+            const announcedVisitors = [];
+            for (const getVisitor of this.deltaVisitors) {
+                announcedVisitors.push(getVisitor());
             }
-            allocateCursor(source) {
-                this.breaker.use();
-                return new Cursor(this, source);
+            const visitor = (0, index_js_1.combineVisitors)([
+                (0, index_js_1.makeBreakingVisitor)(forestVisitor, this.breaker),
+                ...announcedVisitors,
+            ]);
+            this.activeVisitor = visitor;
+            return visitor;
+        }
+        registerAnnouncedVisitor(visitor) {
+            this.deltaVisitors.add(visitor);
+        }
+        deregisterAnnouncedVisitor(visitor) {
+            this.deltaVisitors.delete(visitor);
+        }
+        nextRange = 0;
+        newDetachedField() {
+            const range = (0, index_js_2.brand)(String(this.nextRange));
+            this.nextRange += 1;
+            return range;
+        }
+        add(nodes, key) {
+            const field = Array.from(nodes, mapTreeCursor_js_1.mapTreeFromCursor);
+            this.addFieldAsDetached(field, key);
+        }
+        addFieldAsDetached(field, key) {
+            (0, internal_1.assert)(!this.roots.fields.has(key), 0x370 /* new range must not already exist */);
+            if (field.length > 0) {
+                this.#roots.fields.set(key, field);
             }
-            tryMoveCursorToNode(destination, cursorToMove) {
-                this.breaker.use();
-                const path = this.anchors.locate(destination);
-                if (path === undefined) {
-                    return -1 /* TreeNavigationResult.NotFound */;
-                }
-                this.moveCursorToPath(path, cursorToMove);
-                return 1 /* TreeNavigationResult.Ok */;
+        }
+        delete(field) {
+            this.#roots.fields.delete(field);
+        }
+        allocateCursor(source) {
+            this.breaker.use();
+            return new Cursor(this, source);
+        }
+        tryMoveCursorToNode(destination, cursorToMove) {
+            this.breaker.use();
+            const path = this.anchors.locate(destination);
+            if (path === undefined) {
+                return -1 /* TreeNavigationResult.NotFound */;
             }
-            tryMoveCursorToField(destination, cursorToMove) {
-                this.breaker.use();
-                if (destination.parent === undefined) {
-                    this.moveCursorToPath(undefined, cursorToMove);
-                }
-                else {
-                    const result = this.tryMoveCursorToNode(destination.parent, cursorToMove);
-                    if (result !== 1 /* TreeNavigationResult.Ok */) {
-                        return result;
-                    }
-                }
-                cursorToMove.enterField(destination.fieldKey);
-                return 1 /* TreeNavigationResult.Ok */;
+            this.moveCursorToPath(path, cursorToMove);
+            return 1 /* TreeNavigationResult.Ok */;
+        }
+        tryMoveCursorToField(destination, cursorToMove) {
+            this.breaker.use();
+            if (destination.parent === undefined) {
+                this.moveCursorToPath(undefined, cursorToMove);
             }
-            moveCursorToPath(destination, cursorToMove) {
-                this.breaker.use();
-                (0, internal_1.assert)(cursorToMove instanceof Cursor, 0x337 /* ObjectForest must only be given its own Cursor type */);
-                (0, internal_1.assert)(cursorToMove.forest === this, 0x338 /* ObjectForest must only be given its own Cursor */);
-                const indexStack = [];
-                const keyStack = [];
-                let path = destination;
-                while (path !== undefined) {
-                    indexStack.push(path.parentIndex);
-                    keyStack.push(path.parentField);
-                    path = path.parent;
+            else {
+                const result = this.tryMoveCursorToNode(destination.parent, cursorToMove);
+                if (result !== 1 /* TreeNavigationResult.Ok */) {
+                    return result;
                 }
-                cursorToMove.setToAboveDetachedSequences();
-                while (keyStack.length > 0) {
-                    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-                    cursorToMove.enterField(keyStack.pop());
-                    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-                    cursorToMove.enterNode(indexStack.pop());
-                }
-                return;
             }
-            getCursorAboveDetachedFields() {
-                this.breaker.use();
-                return (0, mapTreeCursor_js_1.cursorForMapTreeNode)(this.roots);
+            cursorToMove.enterField(destination.fieldKey);
+            return 1 /* TreeNavigationResult.Ok */;
+        }
+        moveCursorToPath(destination, cursorToMove) {
+            this.breaker.use();
+            (0, internal_1.assert)(cursorToMove instanceof Cursor, 0x337 /* ObjectForest must only be given its own Cursor type */);
+            (0, internal_1.assert)(cursorToMove.forest === this, 0x338 /* ObjectForest must only be given its own Cursor */);
+            const indexStack = [];
+            const keyStack = [];
+            let path = destination;
+            while (path !== undefined) {
+                indexStack.push(path.parentIndex);
+                keyStack.push(path.parentField);
+                path = path.parent;
             }
-        },
-        _ObjectForest_events = new WeakMap(),
-        _ObjectForest_roots = new WeakMap(),
-        (() => {
-            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(null) : void 0;
-            _checkSchema_decorators = [index_js_2.breakingMethod];
-            tslib_1.__esDecorate(_a, null, _checkSchema_decorators, { kind: "method", name: "checkSchema", static: false, private: false, access: { has: obj => "checkSchema" in obj, get: obj => obj.checkSchema }, metadata: _metadata }, null, _instanceExtraInitializers);
-            if (_metadata) Object.defineProperty(_a, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
-        })(),
-        _a;
+            cursorToMove.setToAboveDetachedSequences();
+            while (keyStack.length > 0) {
+                // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+                cursorToMove.enterField(keyStack.pop());
+                // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+                cursorToMove.enterNode(indexStack.pop());
+            }
+            return;
+        }
+        getCursorAboveDetachedFields() {
+            this.breaker.use();
+            return (0, mapTreeCursor_js_1.cursorForMapTreeNode)(this.roots);
+        }
+    };
 })();
 exports.ObjectForest = ObjectForest;
 /**
  * Cursor implementation for ObjectForest.
  */
 class Cursor extends treeCursorUtils_js_1.SynchronousCursor {
+    forest;
+    source;
+    innerCursor;
+    state;
     /**
      * @param forest - forest this cursor navigates
      * @param innerCursor - underlying cursor implementation this wraps. `undefined` when state is not `Current`
@@ -491,5 +499,4 @@ class Cursor extends treeCursorUtils_js_1.SynchronousCursor {
 function buildForest(breaker, schema, anchors, additionalAsserts = false) {
     return new ObjectForest(breaker, schema, anchors, additionalAsserts);
 }
-exports.buildForest = buildForest;
 //# sourceMappingURL=objectForest.js.map