@fluidframework/tree 2.118.0 → 3.0.0

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

@@ -2,7 +2,7 @@
  * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
  * Licensed under the MIT License.
  */
-import { __classPrivateFieldGet, __classPrivateFieldSet, __esDecorate, __runInitializers } from "tslib";
+import { __esDecorate, __runInitializers } from "tslib";
 import { createEmitter } from "@fluid-internal/client-utils";
 import { assert, fail } from "@fluidframework/core-utils/internal";
 import { AnchorSet, ITreeSubscriptionCursorState, aboveRootPlaceholder, combineVisitors, deepCopyMapTree, makeBreakingVisitor, rootFieldKey, } from "../../core/index.js";
@@ -29,305 +29,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 __classPrivateFieldGet(this, _ObjectForest_roots, "f");
-            }
-            constructor(breaker, 
-            /**
-             * If provided, may be used for validation, but otherwise unused.
-             */
-            schema, anchors = new AnchorSet(), additionalAsserts = false, roots) {
-                this.breaker = (__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, createEmitter());
-                this.events = __classPrivateFieldGet(this, _ObjectForest_events, "f");
-                _ObjectForest_roots.set(this, void 0);
-                this.nextRange = 0;
-                __classPrivateFieldSet(this, _ObjectForest_roots, roots === undefined
+    return class ObjectForest {
+        static {
+            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(null) : void 0;
+            _checkSchema_decorators = [breakingMethod];
+            __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 = __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 = 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 AnchorSet(), additionalAsserts = false, roots) {
+            this.breaker = breaker;
+            this.schema = schema;
+            this.anchors = anchors;
+            this.additionalAsserts = additionalAsserts;
+            this.#roots =
+                roots === undefined
                     ? {
                         type: aboveRootPlaceholder,
                         fields: new Map(),
                     }
-                    : deepCopyMapTree(roots), "f");
-                if (additionalAsserts) {
-                    this.checkSchema();
-                }
-            }
-            get isEmpty() {
-                this.breaker.use();
-                return this.roots.fields.size === 0;
+                    : deepCopyMapTree(roots);
+            if (additionalAsserts) {
+                this.checkSchema();
             }
-            clone(schema, breaker) {
-                this.breaker.use();
-                return new _a(breaker ?? this.breaker, schema, undefined, this.additionalAsserts, this.roots);
-            }
-            chunkField(cursor) {
-                this.breaker.use();
-                return chunkField(cursor, { idCompressor: undefined, policy: 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 chunkField(cursor, { idCompressor: undefined, policy: 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(), rootFieldKey]);
+                for (const key of roots) {
+                    const documentRoot = this.roots.fields.get(key) ?? [];
+                    const fieldSchema = key === 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: FieldKinds.sequence.identifier,
+                                types: new Set(documentRoot.map((node) => node.type)),
+                                // Metadata is not used for schema checks
+                                persistedMetadata: undefined,
+                            };
+                    isFieldInSchema(documentRoot, fieldSchema, {
+                        schema,
+                        policy: defaultSchemaPolicy,
+                    }, throwOutOfSchema);
+                }
             }
+        }
+        acquireVisitor() {
+            this.breaker.use();
+            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(), rootFieldKey]);
-                    for (const key of roots) {
-                        const documentRoot = this.roots.fields.get(key) ?? [];
-                        const fieldSchema = key === 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: FieldKinds.sequence.identifier,
-                                    types: new Set(documentRoot.map((node) => node.type)),
-                                    // Metadata is not used for schema checks
-                                    persistedMetadata: undefined,
-                                };
-                        isFieldInSchema(documentRoot, fieldSchema, {
-                            schema,
-                            policy: defaultSchemaPolicy,
-                        }, throwOutOfSchema);
+            const preEdit = () => {
+                this.#events.emit("beforeChange");
+                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();
+                    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();
-                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);
+                    assert(field !== undefined, 0xd28 /* Destroyed field must exist */);
+                    assert(field.length === count, 0xd29 /* Destroy count must match field length */);
+                    this.forest.delete(detachedField);
+                }
+                create(content, destination) {
+                    preEdit();
+                    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 = () => {
-                    __classPrivateFieldGet(this, _ObjectForest_events, "f").emit("beforeChange");
-                    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();
-                        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 = __classPrivateFieldGet(this.forest, _ObjectForest_roots, "f").fields.get(detachedField);
-                        assert(field !== undefined, 0xd28 /* Destroyed field must exist */);
-                        assert(field.length === count, 0xd29 /* Destroy count must match field length */);
-                        this.forest.delete(detachedField);
-                    }
-                    create(content, destination) {
-                        preEdit();
-                        assert(!__classPrivateFieldGet(this.forest, _ObjectForest_roots, "f").fields.has(destination), 0xd2a /* Create destination must be a new empty field */);
-                        this.forest.add(content, destination);
-                        __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) {
-                        assertNonNegativeSafeInteger(count);
-                        const [parent, key] = cursor.getParent();
-                        assert(parent !== this.forest.roots || key !== source, 0xd2b /* Attach source field must be different from current field */);
-                        const sourceField = __classPrivateFieldGet(this.forest, _ObjectForest_roots, "f").fields.get(source);
-                        assert(sourceField !== undefined, 0xd2c /* Attach source field must exist */);
-                        assert(sourceField.length === count, 0xd2d /* Attach must consume all nodes in source field */);
-                        const existingDestinationField = parent.fields.get(key) ?? [];
-                        assert(destination <= existingDestinationField.length, 0xd2e /* Attach destination must not exceed field length */);
-                        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();
-                        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) ?? [];
-                        assert(source.start <= source.end, 0xd30 /* Detach range start must not exceed end */);
-                        assert(source.end <= currentField.length, 0xd31 /* Detach range must not exceed field length */);
-                        assertValidRange(source, currentField);
-                        if (destination !== undefined) {
-                            assert(!__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) {
+                    assertNonNegativeSafeInteger(count);
+                    const [parent, key] = cursor.getParent();
+                    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);
+                    assert(sourceField !== undefined, 0xd2c /* Attach source field must exist */);
+                    assert(sourceField.length === count, 0xd2d /* Attach must consume all nodes in source field */);
+                    const existingDestinationField = parent.fields.get(key) ?? [];
+                    assert(destination <= existingDestinationField.length, 0xd2e /* Attach destination must not exceed field length */);
+                    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();
+                    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) ?? [];
+                    assert(source.start <= source.end, 0xd30 /* Detach range start must not exceed end */);
+                    assert(source.end <= currentField.length, 0xd31 /* Detach range must not exceed field length */);
+                    assertValidRange(source, currentField);
+                    if (destination !== undefined) {
+                        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 = combineVisitors([
-                    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 = brand(String(this.nextRange));
-                this.nextRange += 1;
-                return range;
-            }
-            add(nodes, key) {
-                const field = Array.from(nodes, mapTreeFromCursor);
-                this.addFieldAsDetached(field, key);
-            }
-            addFieldAsDetached(field, key) {
-                assert(!this.roots.fields.has(key), 0x370 /* new range must not already exist */);
-                if (field.length > 0) {
-                    __classPrivateFieldGet(this, _ObjectForest_roots, "f").fields.set(key, field);
+                exitNode(index) {
+                    cursor.exitNode();
+                }
+                enterField(key) {
+                    cursor.enterField(key);
+                }
+                exitField(key) {
+                    cursor.exitField();
                 }
             }
-            delete(field) {
-                __classPrivateFieldGet(this, _ObjectForest_roots, "f").fields.delete(field);
+            const forestVisitor = new Visitor(this);
+            const announcedVisitors = [];
+            for (const getVisitor of this.deltaVisitors) {
+                announcedVisitors.push(getVisitor());
+            }
+            const visitor = combineVisitors([
+                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 = brand(String(this.nextRange));
+            this.nextRange += 1;
+            return range;
+        }
+        add(nodes, key) {
+            const field = Array.from(nodes, mapTreeFromCursor);
+            this.addFieldAsDetached(field, key);
+        }
+        addFieldAsDetached(field, key) {
+            assert(!this.roots.fields.has(key), 0x370 /* new range must not already exist */);
+            if (field.length > 0) {
+                this.#roots.fields.set(key, field);
             }
-            allocateCursor(source) {
-                this.breaker.use();
-                return new Cursor(this, source);
+        }
+        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 */;
             }
-            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 */;
+            this.moveCursorToPath(path, cursorToMove);
+            return 1 /* TreeNavigationResult.Ok */;
+        }
+        tryMoveCursorToField(destination, cursorToMove) {
+            this.breaker.use();
+            if (destination.parent === undefined) {
+                this.moveCursorToPath(undefined, cursorToMove);
             }
-            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;
-                    }
+            else {
+                const result = this.tryMoveCursorToNode(destination.parent, cursorToMove);
+                if (result !== 1 /* TreeNavigationResult.Ok */) {
+                    return result;
                 }
-                cursorToMove.enterField(destination.fieldKey);
-                return 1 /* TreeNavigationResult.Ok */;
             }
-            moveCursorToPath(destination, cursorToMove) {
-                this.breaker.use();
-                assert(cursorToMove instanceof Cursor, 0x337 /* ObjectForest must only be given its own Cursor type */);
-                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;
-                }
-                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;
+            cursorToMove.enterField(destination.fieldKey);
+            return 1 /* TreeNavigationResult.Ok */;
+        }
+        moveCursorToPath(destination, cursorToMove) {
+            this.breaker.use();
+            assert(cursorToMove instanceof Cursor, 0x337 /* ObjectForest must only be given its own Cursor type */);
+            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;
             }
-            getCursorAboveDetachedFields() {
-                this.breaker.use();
-                return cursorForMapTreeNode(this.roots);
+            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());
             }
-        },
-        _ObjectForest_events = new WeakMap(),
-        _ObjectForest_roots = new WeakMap(),
-        (() => {
-            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(null) : void 0;
-            _checkSchema_decorators = [breakingMethod];
-            __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;
+            return;
+        }
+        getCursorAboveDetachedFields() {
+            this.breaker.use();
+            return cursorForMapTreeNode(this.roots);
+        }
+    };
 })();
 export { ObjectForest };
 /**
  * Cursor implementation for ObjectForest.
  */
 class Cursor extends SynchronousCursor {
+    forest;
+    source;
+    innerCursor;
+    state;
     /**
      * @param forest - forest this cursor navigates
      * @param innerCursor - underlying cursor implementation this wraps. `undefined` when state is not `Current`