@fluidframework/tree 2.118.0 → 3.0.0

package/dist/simple-tree/core/treeNodeKernel.js

@@ -3,10 +3,20 @@
  * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
  * Licensed under the MIT License.
  */
-var _TreeNodeKernel_hydrationState, _TreeNodeKernel_eventBuffer, _KernelEventBuffer_instances, _KernelEventBuffer_disposed, _KernelEventBuffer_events, _KernelEventBuffer_eventSource, _KernelEventBuffer_disposeSourceListeners, _KernelEventBuffer_childrenChangedBuffer, _KernelEventBuffer_fieldMarksBuffer, _KernelEventBuffer_invalidatedFieldMarkKeys, _KernelEventBuffer_subTreeChangedBuffer, _KernelEventBuffer_emit, _KernelEventBuffer_handleChildrenChangedAfterBatch, _KernelEventBuffer_handleSubtreeChangedAfterBatch, _KernelEventBuffer_assertNotDisposed;
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.SimpleContextSlot = exports.createTreeNodeFromInner = exports.treeNodeFromAnchor = exports.getInnerNode = exports.getSimpleContextFromInnerNode = exports.getSimpleNodeSchemaFromInnerNode = exports.tryDisposeTreeNode = exports.simpleTreeNodeSlot = exports.splitInnerNodeType = exports.TEST_activeBufferCount = exports.withBufferedTreeEvents = exports.TreeNodeKernel = exports.tryGetTreeNodeSchema = exports.isTreeNode = exports.getKernel = void 0;
-const tslib_1 = require("tslib");
+exports.SimpleContextSlot = exports.simpleTreeNodeSlot = exports.TreeNodeKernel = void 0;
+exports.getKernel = getKernel;
+exports.isTreeNode = isTreeNode;
+exports.tryGetTreeNodeSchema = tryGetTreeNodeSchema;
+exports.withBufferedTreeEvents = withBufferedTreeEvents;
+exports.TEST_activeBufferCount = TEST_activeBufferCount;
+exports.splitInnerNodeType = splitInnerNodeType;
+exports.tryDisposeTreeNode = tryDisposeTreeNode;
+exports.getSimpleNodeSchemaFromInnerNode = getSimpleNodeSchemaFromInnerNode;
+exports.getSimpleContextFromInnerNode = getSimpleContextFromInnerNode;
+exports.getInnerNode = getInnerNode;
+exports.treeNodeFromAnchor = treeNodeFromAnchor;
+exports.createTreeNodeFromInner = createTreeNodeFromInner;
 const client_utils_1 = require("@fluid-internal/client-utils");
 const internal_1 = require("@fluidframework/core-utils/internal");
 const internal_2 = require("@fluidframework/telemetry-utils/internal");
@@ -20,7 +30,6 @@ function getKernel(node) {
     (0, internal_1.assert)(kernel !== undefined, 0x9b1 /* Expected tree node to have kernel */);
     return kernel;
 }
-exports.getKernel = getKernel;
 /**
  * Detects if the given 'candidate' is a TreeNode.
  *
@@ -38,7 +47,6 @@ exports.getKernel = getKernel;
 function isTreeNode(candidate) {
     return treeNodeToKernel.has(candidate);
 }
-exports.isTreeNode = isTreeNode;
 /**
  * Returns a schema for a value if the value is a {@link TreeNode}.
  *
@@ -50,7 +58,6 @@ function tryGetTreeNodeSchema(value) {
     const kernel = treeNodeToKernel.get(value);
     return kernel?.schema;
 }
-exports.tryGetTreeNodeSchema = tryGetTreeNodeSchema;
 /** True if and only if the given {@link HydrationState} is post-hydration */
 function isHydrated(state) {
     return state.innerNode.isHydrated();
@@ -61,6 +68,33 @@ function isHydrated(state) {
  * The kernel has the same lifetime as the node and spans both its unhydrated and hydrated states.
  */
 class TreeNodeKernel {
+    node;
+    schema;
+    initialContext;
+    disposed = false;
+    /**
+     * Generation number which is incremented any time we have an edit on the node.
+     * Used during iteration to make sure there has been no edits that were concurrently made.
+     * @remarks
+     * This is updated monotonically by this class when edits are applied.
+     * TODO: update this when applying edits to unhydrated trees.
+     *
+     * If TypeScript supported making this immutable from outside the class without making it readonly from inside, that would be used here,
+     * but they only way to do that is add a separate public accessor and make it private, which was deemed not worth the boilerplate, runtime overhead and bundle size.
+     */
+    generationNumber = 0;
+    #hydrationState;
+    /**
+     * Handler for events listeners registered with the kernel.
+     *
+     * @remarks
+     * Supports event buffering via {@link withBufferedEvents}.
+     *
+     * Allocated lazily on first access to {@link TreeNodeKernel.events}.
+     * We expect the majority of nodes to never have event listeners registered, so
+     * deferring construction avoids per-kernel allocations.
+     */
+    #eventBuffer;
     /**
      * Create a TreeNodeKernel which can be looked up with {@link getKernel}.
      *
@@ -73,30 +107,6 @@ class TreeNodeKernel {
         this.node = node;
         this.schema = schema;
         this.initialContext = initialContext;
-        this.disposed = false;
-        /**
-         * Generation number which is incremented any time we have an edit on the node.
-         * Used during iteration to make sure there has been no edits that were concurrently made.
-         * @remarks
-         * This is updated monotonically by this class when edits are applied.
-         * TODO: update this when applying edits to unhydrated trees.
-         *
-         * If TypeScript supported making this immutable from outside the class without making it readonly from inside, that would be used here,
-         * but they only way to do that is add a separate public accessor and make it private, which was deemed not worth the boilerplate, runtime overhead and bundle size.
-         */
-        this.generationNumber = 0;
-        _TreeNodeKernel_hydrationState.set(this, void 0);
-        /**
-         * Handler for events listeners registered with the kernel.
-         *
-         * @remarks
-         * Supports event buffering via {@link withBufferedEvents}.
-         *
-         * Allocated lazily on first access to {@link TreeNodeKernel.events}.
-         * We expect the majority of nodes to never have event listeners registered, so
-         * deferring construction avoids per-kernel allocations.
-         */
-        _TreeNodeKernel_eventBuffer.set(this, void 0);
         splitInnerNodeType(innerNode);
         (0, internal_1.assert)(!treeNodeToKernel.has(node), 0xa1a /* only one kernel per node can be made */);
         treeNodeToKernel.set(node, this);
@@ -104,19 +114,19 @@ class TreeNodeKernel {
             // Unhydrated case
             (0, internal_1.debugAssert)(() => innerNode.treeNode === undefined);
             innerNode.treeNode = node;
-            tslib_1.__classPrivateFieldSet(this, _TreeNodeKernel_hydrationState, {
+            this.#hydrationState = {
                 innerNode,
-            }, "f");
+            };
         }
         else {
             // Hydrated case
-            tslib_1.__classPrivateFieldSet(this, _TreeNodeKernel_hydrationState, this.createHydratedState(innerNode), "f");
+            this.#hydrationState = this.createHydratedState(innerNode);
         }
     }
     get context() {
-        if (isHydrated(tslib_1.__classPrivateFieldGet(this, _TreeNodeKernel_hydrationState, "f"))) {
+        if (isHydrated(this.#hydrationState)) {
             // This can't be cached on this.#hydrated during hydration since initial tree is hydrated before the context is cached on the anchorSet.
-            return (tslib_1.__classPrivateFieldGet(this, _TreeNodeKernel_hydrationState, "f").innerNode.anchorNode.anchorSet.slots.get(exports.SimpleContextSlot) ??
+            return (this.#hydrationState.innerNode.anchorNode.anchorSet.slots.get(exports.SimpleContextSlot) ??
                 (0, internal_1.fail)(0xb40 /* missing simple-tree context */));
         }
         return this.initialContext;
@@ -130,12 +140,12 @@ class TreeNodeKernel {
      */
     hydrate(inner) {
         (0, internal_1.assert)(!this.disposed, 0xa2a /* cannot hydrate a disposed node */);
-        (0, internal_1.assert)(!isHydrated(tslib_1.__classPrivateFieldGet(this, _TreeNodeKernel_hydrationState, "f")), 0xa2b /* hydration should only happen once */);
-        tslib_1.__classPrivateFieldSet(this, _TreeNodeKernel_hydrationState, this.createHydratedState(inner), "f");
+        (0, internal_1.assert)(!isHydrated(this.#hydrationState), 0xa2b /* hydration should only happen once */);
+        this.#hydrationState = this.createHydratedState(inner);
         // Lazily migrate existing event listeners to the anchor node.
         // If no one ever subscribed to this kernel's events, the buffer was never allocated
         // and there is nothing to migrate.
-        tslib_1.__classPrivateFieldGet(this, _TreeNodeKernel_eventBuffer, "f")?.migrateEventSource(inner.anchorNode.events);
+        this.#eventBuffer?.migrateEventSource(inner.anchorNode.events);
     }
     createHydratedState(innerNode) {
         (0, internal_1.assert)(!innerNode.anchorNode.slots.has(exports.simpleTreeNodeSlot), 0x7f5 /* Cannot associate an flex node with multiple simple-tree nodes */);
@@ -155,47 +165,47 @@ class TreeNodeKernel {
         if (this.disposed) {
             return index_js_3.TreeStatus.Deleted;
         }
-        if (!isHydrated(tslib_1.__classPrivateFieldGet(this, _TreeNodeKernel_hydrationState, "f"))) {
+        if (!isHydrated(this.#hydrationState)) {
             return index_js_3.TreeStatus.New;
         }
         // TODO: Replace this check with the proper check against the cursor state when the cursor becomes part of the kernel
-        const flex = tslib_1.__classPrivateFieldGet(this, _TreeNodeKernel_hydrationState, "f").innerNode.anchorNode.slots.get(index_js_3.flexTreeSlot);
+        const flex = this.#hydrationState.innerNode.anchorNode.slots.get(index_js_3.flexTreeSlot);
         if (flex !== undefined) {
             (0, internal_1.assert)(flex instanceof index_js_3.LazyEntity, 0x9b4 /* Unexpected flex node implementation */);
             if (flex.isFreed()) {
                 return index_js_3.TreeStatus.Deleted;
             }
         }
-        return (0, index_js_3.treeStatusFromAnchorCache)(tslib_1.__classPrivateFieldGet(this, _TreeNodeKernel_hydrationState, "f").innerNode.anchorNode);
+        return (0, index_js_3.treeStatusFromAnchorCache)(this.#hydrationState.innerNode.anchorNode);
     }
     get events() {
         (0, internal_1.assert)(!this.disposed, 0xcfa /* Cannot register events on a disposed node */);
         // Allocate the buffer on first access. See {@link TreeNodeKernel.#eventBuffer} for rationale.
-        if (tslib_1.__classPrivateFieldGet(this, _TreeNodeKernel_eventBuffer, "f") === undefined) {
-            const eventSource = isHydrated(tslib_1.__classPrivateFieldGet(this, _TreeNodeKernel_hydrationState, "f"))
-                ? tslib_1.__classPrivateFieldGet(this, _TreeNodeKernel_hydrationState, "f").innerNode.anchorNode.events
-                : tslib_1.__classPrivateFieldGet(this, _TreeNodeKernel_hydrationState, "f").innerNode.events;
-            tslib_1.__classPrivateFieldSet(this, _TreeNodeKernel_eventBuffer, new KernelEventBuffer(eventSource), "f");
+        if (this.#eventBuffer === undefined) {
+            const eventSource = isHydrated(this.#hydrationState)
+                ? this.#hydrationState.innerNode.anchorNode.events
+                : this.#hydrationState.innerNode.events;
+            this.#eventBuffer = new KernelEventBuffer(eventSource);
         }
-        return tslib_1.__classPrivateFieldGet(this, _TreeNodeKernel_eventBuffer, "f");
+        return this.#eventBuffer;
     }
     dispose() {
         (0, internal_1.debugAssert)(() => !this.disposed || "Cannot dispose a disposed node");
         this.disposed = true;
-        if (isHydrated(tslib_1.__classPrivateFieldGet(this, _TreeNodeKernel_hydrationState, "f"))) {
-            for (const off of tslib_1.__classPrivateFieldGet(this, _TreeNodeKernel_hydrationState, "f").offAnchorNode) {
+        if (isHydrated(this.#hydrationState)) {
+            for (const off of this.#hydrationState.offAnchorNode) {
                 off();
             }
         }
-        tslib_1.__classPrivateFieldGet(this, _TreeNodeKernel_eventBuffer, "f")?.dispose();
+        this.#eventBuffer?.dispose();
         // TODO: go to the context and remove myself from withAnchors
     }
     isHydrated() {
-        return isHydrated(tslib_1.__classPrivateFieldGet(this, _TreeNodeKernel_hydrationState, "f"));
+        return isHydrated(this.#hydrationState);
     }
     get anchorNode() {
-        return isHydrated(tslib_1.__classPrivateFieldGet(this, _TreeNodeKernel_hydrationState, "f"))
-            ? tslib_1.__classPrivateFieldGet(this, _TreeNodeKernel_hydrationState, "f").innerNode.anchorNode
+        return isHydrated(this.#hydrationState)
+            ? this.#hydrationState.innerNode.anchorNode
             : undefined;
     }
     /**
@@ -208,28 +218,27 @@ class TreeNodeKernel {
      * @throws A {@link @fluidframework/telemetry-utils#UsageError} if the node has been deleted.
      */
     getInnerNode() {
-        if (!isHydrated(tslib_1.__classPrivateFieldGet(this, _TreeNodeKernel_hydrationState, "f"))) {
-            (0, internal_1.debugAssert)(() => tslib_1.__classPrivateFieldGet(this, _TreeNodeKernel_hydrationState, "f").innerNode?.context.isDisposed() === false ||
+        if (!isHydrated(this.#hydrationState)) {
+            (0, internal_1.debugAssert)(() => this.#hydrationState.innerNode?.context.isDisposed() === false ||
                 "Unhydrated node should never be disposed");
-            return tslib_1.__classPrivateFieldGet(this, _TreeNodeKernel_hydrationState, "f").innerNode; // Unhydrated case
+            return this.#hydrationState.innerNode; // Unhydrated case
         }
         if (this.disposed) {
             throw new internal_2.UsageError("Cannot access a deleted node.");
         }
-        return tslib_1.__classPrivateFieldGet(this, _TreeNodeKernel_hydrationState, "f").innerNode;
+        return this.#hydrationState.innerNode;
     }
     /**
      * Retrieves the {@link UnhydratedFlexTreeNode} if unhydrated. otherwise undefined.
      */
     getInnerNodeIfUnhydrated() {
-        if (isHydrated(tslib_1.__classPrivateFieldGet(this, _TreeNodeKernel_hydrationState, "f"))) {
+        if (isHydrated(this.#hydrationState)) {
             return undefined;
         }
-        return tslib_1.__classPrivateFieldGet(this, _TreeNodeKernel_hydrationState, "f").innerNode;
+        return this.#hydrationState.innerNode;
     }
 }
 exports.TreeNodeKernel = TreeNodeKernel;
-_TreeNodeKernel_hydrationState = new WeakMap(), _TreeNodeKernel_eventBuffer = new WeakMap();
 // eslint-disable-next-line @typescript-eslint/no-unused-vars
 const kernelEvents = ["childrenChangedAfterBatch", "subtreeChangedAfterBatch"];
 // #region TreeNodeEventBuffer
@@ -275,7 +284,6 @@ function withBufferedTreeEvents(callback) {
         }
     }
 }
-exports.withBufferedTreeEvents = withBufferedTreeEvents;
 /**
  * Set of {@link KernelEventBuffer}s that have accumulated buffered events during the current
  * {@link withBufferedTreeEvents} window and therefore need to be flushed when it ends.
@@ -291,13 +299,40 @@ const activeBuffers = new Set();
 function TEST_activeBufferCount() {
     return activeBuffers.size;
 }
-exports.TEST_activeBufferCount = TEST_activeBufferCount;
 /**
  * Event emitter for {@link TreeNodeKernel}, which optionally buffers events based on {@link bufferTreeEvents}.
  * @remarks When buffering is active, this adds itself to {@link activeBuffers} so that
  * {@link withBufferedTreeEvents} can flush it at the end of the buffering window.
  */
 class KernelEventBuffer {
+    #disposed = false;
+    #events = (0, client_utils_1.createEmitter)();
+    #eventSource;
+    #disposeSourceListeners = new Map();
+    /**
+     * Buffer of fields that have changed since events were paused.
+     * When events are flushed, a single {@link AnchorEvents.childrenChangedAfterBatch} event will be emitted
+     * containing the accumulated set of changed fields.
+     */
+    #childrenChangedBuffer = new Set();
+    /**
+     * Buffer of field marks accumulated since events were paused.
+     * Emitted alongside the buffered changed-fields set when flushed.
+     */
+    #fieldMarksBuffer = new Map();
+    /**
+     * Fields whose marks have been permanently invalidated within the current buffer window due to
+     * two or more separate delta batches touching the same field.
+     * Once a key is in this set it must never be re-added to the marks buffer, even if
+     * a third (or later) batch arrives for that field.
+     */
+    #invalidatedFieldMarkKeys = new Set();
+    /**
+     * Whether or not the subtree has changed since events were paused.
+     * When events are flushed, a single {@link AnchorEvents.subTreeChanged} event will be emitted if and only
+     * if the subtree has changed.
+     */
+    #subTreeChangedBuffer = false;
     constructor(
     /**
      * Source of the kernel events.
@@ -305,36 +340,7 @@ class KernelEventBuffer {
      * and those subscriptions will be cleaned up when all corresponding listeners have been removed.
      */
     eventSource) {
-        _KernelEventBuffer_instances.add(this);
-        _KernelEventBuffer_disposed.set(this, false);
-        _KernelEventBuffer_events.set(this, (0, client_utils_1.createEmitter)());
-        _KernelEventBuffer_eventSource.set(this, void 0);
-        _KernelEventBuffer_disposeSourceListeners.set(this, new Map());
-        /**
-         * Buffer of fields that have changed since events were paused.
-         * When events are flushed, a single {@link AnchorEvents.childrenChangedAfterBatch} event will be emitted
-         * containing the accumulated set of changed fields.
-         */
-        _KernelEventBuffer_childrenChangedBuffer.set(this, new Set());
-        /**
-         * Buffer of field marks accumulated since events were paused.
-         * Emitted alongside the buffered changed-fields set when flushed.
-         */
-        _KernelEventBuffer_fieldMarksBuffer.set(this, new Map());
-        /**
-         * Fields whose marks have been permanently invalidated within the current buffer window due to
-         * two or more separate delta batches touching the same field.
-         * Once a key is in this set it must never be re-added to the marks buffer, even if
-         * a third (or later) batch arrives for that field.
-         */
-        _KernelEventBuffer_invalidatedFieldMarkKeys.set(this, new Set());
-        /**
-         * Whether or not the subtree has changed since events were paused.
-         * When events are flushed, a single {@link AnchorEvents.subTreeChanged} event will be emitted if and only
-         * if the subtree has changed.
-         */
-        _KernelEventBuffer_subTreeChangedBuffer.set(this, false);
-        tslib_1.__classPrivateFieldSet(this, _KernelEventBuffer_eventSource, eventSource, "f");
+        this.#eventSource = eventSource;
     }
     /**
      * Migrate this event buffer to a new event source.
@@ -345,143 +351,145 @@ class KernelEventBuffer {
      */
     migrateEventSource(newSource) {
         // Unsubscribe from the old source
-        for (const off of tslib_1.__classPrivateFieldGet(this, _KernelEventBuffer_disposeSourceListeners, "f").values()) {
+        for (const off of this.#disposeSourceListeners.values()) {
             off();
         }
-        tslib_1.__classPrivateFieldGet(this, _KernelEventBuffer_disposeSourceListeners, "f").clear();
-        tslib_1.__classPrivateFieldSet(this, _KernelEventBuffer_eventSource, newSource, "f");
-        if (tslib_1.__classPrivateFieldGet(this, _KernelEventBuffer_events, "f").hasListeners("childrenChangedAfterBatch")) {
-            const off = tslib_1.__classPrivateFieldGet(this, _KernelEventBuffer_eventSource, "f").on("childrenChangedAfterBatch", ({ changedFields, fieldMarks }) => tslib_1.__classPrivateFieldGet(this, _KernelEventBuffer_instances, "m", _KernelEventBuffer_emit).call(this, "childrenChangedAfterBatch", { changedFields, fieldMarks }));
-            tslib_1.__classPrivateFieldGet(this, _KernelEventBuffer_disposeSourceListeners, "f").set("childrenChangedAfterBatch", off);
+        this.#disposeSourceListeners.clear();
+        this.#eventSource = newSource;
+        if (this.#events.hasListeners("childrenChangedAfterBatch")) {
+            const off = this.#eventSource.on("childrenChangedAfterBatch", ({ changedFields, fieldMarks }) => this.#emit("childrenChangedAfterBatch", { changedFields, fieldMarks }));
+            this.#disposeSourceListeners.set("childrenChangedAfterBatch", off);
         }
-        if (tslib_1.__classPrivateFieldGet(this, _KernelEventBuffer_events, "f").hasListeners("subtreeChangedAfterBatch")) {
-            const off = tslib_1.__classPrivateFieldGet(this, _KernelEventBuffer_eventSource, "f").on("subtreeChangedAfterBatch", () => tslib_1.__classPrivateFieldGet(this, _KernelEventBuffer_instances, "m", _KernelEventBuffer_emit).call(this, "subtreeChangedAfterBatch"));
-            tslib_1.__classPrivateFieldGet(this, _KernelEventBuffer_disposeSourceListeners, "f").set("subtreeChangedAfterBatch", off);
+        if (this.#events.hasListeners("subtreeChangedAfterBatch")) {
+            const off = this.#eventSource.on("subtreeChangedAfterBatch", () => this.#emit("subtreeChangedAfterBatch"));
+            this.#disposeSourceListeners.set("subtreeChangedAfterBatch", off);
         }
     }
     on(eventName, listener) {
-        tslib_1.__classPrivateFieldGet(this, _KernelEventBuffer_instances, "m", _KernelEventBuffer_assertNotDisposed).call(this);
+        this.#assertNotDisposed();
         // Lazily bind event listeners to the source.
         // If we do not have any existing listeners for this event, then we need to bind to the source.
-        if (!tslib_1.__classPrivateFieldGet(this, _KernelEventBuffer_events, "f").hasListeners(eventName)) {
-            (0, internal_1.assert)(!tslib_1.__classPrivateFieldGet(this, _KernelEventBuffer_disposeSourceListeners, "f").has(eventName), 0xc4f /* Should not have a dispose function without listeners */);
+        if (!this.#events.hasListeners(eventName)) {
+            (0, internal_1.assert)(!this.#disposeSourceListeners.has(eventName), 0xc4f /* Should not have a dispose function without listeners */);
             const off = eventName === "childrenChangedAfterBatch"
-                ? tslib_1.__classPrivateFieldGet(this, _KernelEventBuffer_eventSource, "f").on(eventName, (args) => tslib_1.__classPrivateFieldGet(this, _KernelEventBuffer_instances, "m", _KernelEventBuffer_emit).call(this, eventName, args))
-                : tslib_1.__classPrivateFieldGet(this, _KernelEventBuffer_eventSource, "f").on(eventName, () => tslib_1.__classPrivateFieldGet(this, _KernelEventBuffer_instances, "m", _KernelEventBuffer_emit).call(this, eventName));
-            tslib_1.__classPrivateFieldGet(this, _KernelEventBuffer_disposeSourceListeners, "f").set(eventName, off);
+                ? this.#eventSource.on(eventName, (args) => this.#emit(eventName, args))
+                : this.#eventSource.on(eventName, () => this.#emit(eventName));
+            this.#disposeSourceListeners.set(eventName, off);
         }
-        tslib_1.__classPrivateFieldGet(this, _KernelEventBuffer_events, "f").on(eventName, listener);
+        this.#events.on(eventName, listener);
         // Return a bound method instead of an arrow closure. A bound function captures
         // (target, thisArg, ...boundArgs) in a fixed shape that V8 can optimize more
         // uniformly than a closure that captures its lexical context.
         return this.off.bind(this, eventName, listener);
     }
     off(eventName, listener) {
-        tslib_1.__classPrivateFieldGet(this, _KernelEventBuffer_events, "f").off(eventName, listener);
+        this.#events.off(eventName, listener);
         // If there are no remaining listeners for the event, unbind from the source
-        if (!tslib_1.__classPrivateFieldGet(this, _KernelEventBuffer_events, "f").hasListeners(eventName)) {
-            const off = tslib_1.__classPrivateFieldGet(this, _KernelEventBuffer_disposeSourceListeners, "f").get(eventName);
+        if (!this.#events.hasListeners(eventName)) {
+            const off = this.#disposeSourceListeners.get(eventName);
             off?.();
-            tslib_1.__classPrivateFieldGet(this, _KernelEventBuffer_disposeSourceListeners, "f").delete(eventName);
+            this.#disposeSourceListeners.delete(eventName);
+        }
+    }
+    #emit(eventName, arg) {
+        this.#assertNotDisposed();
+        switch (eventName) {
+            case "childrenChangedAfterBatch": {
+                (0, internal_1.assert)(arg !== undefined, 0xcea /* childrenChangedAfterBatch requires arg */);
+                return this.#handleChildrenChangedAfterBatch(arg.changedFields, arg.fieldMarks);
+            }
+            case "subtreeChangedAfterBatch": {
+                return this.#handleSubtreeChangedAfterBatch();
+            }
+            default: {
+                (0, internal_1.unreachableCase)(eventName);
+            }
+        }
+    }
+    #handleChildrenChangedAfterBatch(changedFields, fieldMarks) {
+        if (bufferTreeEvents) {
+            activeBuffers.add(this);
+            for (const fieldKey of changedFields) {
+                this.#childrenChangedBuffer.add(fieldKey);
+            }
+            for (const [key, marks] of fieldMarks) {
+                if (this.#invalidatedFieldMarkKeys.has(key)) {
+                    // Already permanently invalidated by an earlier collision; ignore this batch too.
+                    // TODO: Once the eventing stack is rewritten to walk the composed delta at flush
+                    // time, this collision path will be unreachable and can be removed entirely.
+                    continue;
+                }
+                if (this.#fieldMarksBuffer.has(key)) {
+                    // A second batch of marks arrived for the same field before the buffer was flushed.
+                    // We have no delta composition logic, so permanently invalidate this field so that
+                    // any further batches are also discarded rather than incorrectly surfaced.
+                    this.#fieldMarksBuffer.delete(key);
+                    this.#invalidatedFieldMarkKeys.add(key);
+                }
+                else {
+                    this.#fieldMarksBuffer.set(key, marks);
+                }
+            }
+        }
+        else {
+            this.#events.emit("childrenChangedAfterBatch", { changedFields, fieldMarks });
+        }
+    }
+    #handleSubtreeChangedAfterBatch() {
+        if (bufferTreeEvents) {
+            activeBuffers.add(this);
+            this.#subTreeChangedBuffer = true;
+        }
+        else {
+            this.#events.emit("subtreeChangedAfterBatch");
         }
     }
     /**
      * Flushes any events buffered due to {@link withBufferedTreeEvents}.
      */
     flush() {
-        tslib_1.__classPrivateFieldGet(this, _KernelEventBuffer_instances, "m", _KernelEventBuffer_assertNotDisposed).call(this);
-        if (tslib_1.__classPrivateFieldGet(this, _KernelEventBuffer_childrenChangedBuffer, "f").size > 0) {
-            tslib_1.__classPrivateFieldGet(this, _KernelEventBuffer_events, "f").emit("childrenChangedAfterBatch", {
-                changedFields: tslib_1.__classPrivateFieldGet(this, _KernelEventBuffer_childrenChangedBuffer, "f"),
-                fieldMarks: tslib_1.__classPrivateFieldGet(this, _KernelEventBuffer_fieldMarksBuffer, "f"),
+        this.#assertNotDisposed();
+        if (this.#childrenChangedBuffer.size > 0) {
+            this.#events.emit("childrenChangedAfterBatch", {
+                changedFields: this.#childrenChangedBuffer,
+                fieldMarks: this.#fieldMarksBuffer,
             });
-            tslib_1.__classPrivateFieldGet(this, _KernelEventBuffer_childrenChangedBuffer, "f").clear();
-            tslib_1.__classPrivateFieldGet(this, _KernelEventBuffer_fieldMarksBuffer, "f").clear();
-            tslib_1.__classPrivateFieldGet(this, _KernelEventBuffer_invalidatedFieldMarkKeys, "f").clear();
+            this.#childrenChangedBuffer.clear();
+            this.#fieldMarksBuffer.clear();
+            this.#invalidatedFieldMarkKeys.clear();
         }
-        if (tslib_1.__classPrivateFieldGet(this, _KernelEventBuffer_subTreeChangedBuffer, "f")) {
-            tslib_1.__classPrivateFieldGet(this, _KernelEventBuffer_events, "f").emit("subtreeChangedAfterBatch");
-            tslib_1.__classPrivateFieldSet(this, _KernelEventBuffer_subTreeChangedBuffer, false, "f");
+        if (this.#subTreeChangedBuffer) {
+            this.#events.emit("subtreeChangedAfterBatch");
+            this.#subTreeChangedBuffer = false;
         }
     }
+    #assertNotDisposed() {
+        (0, internal_1.assert)(!this.#disposed, 0xc51 /* Event handler disposed. */);
+    }
     dispose() {
-        if (tslib_1.__classPrivateFieldGet(this, _KernelEventBuffer_disposed, "f")) {
+        if (this.#disposed) {
             return;
         }
-        (0, internal_1.debugAssert)(() => (tslib_1.__classPrivateFieldGet(this, _KernelEventBuffer_childrenChangedBuffer, "f").size === 0 && !tslib_1.__classPrivateFieldGet(this, _KernelEventBuffer_subTreeChangedBuffer, "f")) ||
+        (0, internal_1.debugAssert)(() => (this.#childrenChangedBuffer.size === 0 && !this.#subTreeChangedBuffer) ||
             "Buffered kernel events should have been flushed before disposing.");
         (0, internal_1.debugAssert)(() => !activeBuffers.has(this) || "Disposed buffer should not be in activeBuffers.");
-        for (const off of tslib_1.__classPrivateFieldGet(this, _KernelEventBuffer_disposeSourceListeners, "f").values()) {
+        for (const off of this.#disposeSourceListeners.values()) {
             off();
         }
-        tslib_1.__classPrivateFieldGet(this, _KernelEventBuffer_disposeSourceListeners, "f").clear();
-        tslib_1.__classPrivateFieldGet(this, _KernelEventBuffer_childrenChangedBuffer, "f").clear();
-        tslib_1.__classPrivateFieldGet(this, _KernelEventBuffer_fieldMarksBuffer, "f").clear();
-        tslib_1.__classPrivateFieldGet(this, _KernelEventBuffer_invalidatedFieldMarkKeys, "f").clear();
-        tslib_1.__classPrivateFieldSet(this, _KernelEventBuffer_subTreeChangedBuffer, false, "f");
-        tslib_1.__classPrivateFieldSet(this, _KernelEventBuffer_disposed, true, "f");
+        this.#disposeSourceListeners.clear();
+        this.#childrenChangedBuffer.clear();
+        this.#fieldMarksBuffer.clear();
+        this.#invalidatedFieldMarkKeys.clear();
+        this.#subTreeChangedBuffer = false;
+        this.#disposed = true;
     }
 }
-_KernelEventBuffer_disposed = new WeakMap(), _KernelEventBuffer_events = new WeakMap(), _KernelEventBuffer_eventSource = new WeakMap(), _KernelEventBuffer_disposeSourceListeners = new WeakMap(), _KernelEventBuffer_childrenChangedBuffer = new WeakMap(), _KernelEventBuffer_fieldMarksBuffer = new WeakMap(), _KernelEventBuffer_invalidatedFieldMarkKeys = new WeakMap(), _KernelEventBuffer_subTreeChangedBuffer = new WeakMap(), _KernelEventBuffer_instances = new WeakSet(), _KernelEventBuffer_emit = function _KernelEventBuffer_emit(eventName, arg) {
-    tslib_1.__classPrivateFieldGet(this, _KernelEventBuffer_instances, "m", _KernelEventBuffer_assertNotDisposed).call(this);
-    switch (eventName) {
-        case "childrenChangedAfterBatch": {
-            (0, internal_1.assert)(arg !== undefined, 0xcea /* childrenChangedAfterBatch requires arg */);
-            return tslib_1.__classPrivateFieldGet(this, _KernelEventBuffer_instances, "m", _KernelEventBuffer_handleChildrenChangedAfterBatch).call(this, arg.changedFields, arg.fieldMarks);
-        }
-        case "subtreeChangedAfterBatch": {
-            return tslib_1.__classPrivateFieldGet(this, _KernelEventBuffer_instances, "m", _KernelEventBuffer_handleSubtreeChangedAfterBatch).call(this);
-        }
-        default: {
-            (0, internal_1.unreachableCase)(eventName);
-        }
-    }
-}, _KernelEventBuffer_handleChildrenChangedAfterBatch = function _KernelEventBuffer_handleChildrenChangedAfterBatch(changedFields, fieldMarks) {
-    if (bufferTreeEvents) {
-        activeBuffers.add(this);
-        for (const fieldKey of changedFields) {
-            tslib_1.__classPrivateFieldGet(this, _KernelEventBuffer_childrenChangedBuffer, "f").add(fieldKey);
-        }
-        for (const [key, marks] of fieldMarks) {
-            if (tslib_1.__classPrivateFieldGet(this, _KernelEventBuffer_invalidatedFieldMarkKeys, "f").has(key)) {
-                // Already permanently invalidated by an earlier collision; ignore this batch too.
-                // TODO: Once the eventing stack is rewritten to walk the composed delta at flush
-                // time, this collision path will be unreachable and can be removed entirely.
-                continue;
-            }
-            if (tslib_1.__classPrivateFieldGet(this, _KernelEventBuffer_fieldMarksBuffer, "f").has(key)) {
-                // A second batch of marks arrived for the same field before the buffer was flushed.
-                // We have no delta composition logic, so permanently invalidate this field so that
-                // any further batches are also discarded rather than incorrectly surfaced.
-                tslib_1.__classPrivateFieldGet(this, _KernelEventBuffer_fieldMarksBuffer, "f").delete(key);
-                tslib_1.__classPrivateFieldGet(this, _KernelEventBuffer_invalidatedFieldMarkKeys, "f").add(key);
-            }
-            else {
-                tslib_1.__classPrivateFieldGet(this, _KernelEventBuffer_fieldMarksBuffer, "f").set(key, marks);
-            }
-        }
-    }
-    else {
-        tslib_1.__classPrivateFieldGet(this, _KernelEventBuffer_events, "f").emit("childrenChangedAfterBatch", { changedFields, fieldMarks });
-    }
-}, _KernelEventBuffer_handleSubtreeChangedAfterBatch = function _KernelEventBuffer_handleSubtreeChangedAfterBatch() {
-    if (bufferTreeEvents) {
-        activeBuffers.add(this);
-        tslib_1.__classPrivateFieldSet(this, _KernelEventBuffer_subTreeChangedBuffer, true, "f");
-    }
-    else {
-        tslib_1.__classPrivateFieldGet(this, _KernelEventBuffer_events, "f").emit("subtreeChangedAfterBatch");
-    }
-}, _KernelEventBuffer_assertNotDisposed = function _KernelEventBuffer_assertNotDisposed() {
-    (0, internal_1.assert)(!tslib_1.__classPrivateFieldGet(this, _KernelEventBuffer_disposed, "f"), 0xc51 /* Event handler disposed. */);
-};
 /**
  * Narrows innerNode to either {@link UnhydratedFlexTreeNode} or {@link HydratedFlexTreeNode}.
  */
 function splitInnerNodeType(innerNode) {
     (0, internal_1.assert)(innerNode instanceof unhydratedFlexTree_js_1.UnhydratedFlexTreeNode || innerNode.isHydrated(), 0xbc8 /* Invalid inner node type */);
 }
-exports.splitInnerNodeType = splitInnerNodeType;
 /**
  * An anchor slot which associates an anchor with its corresponding {@link TreeNode}, if there is one.
  * @remarks
@@ -500,7 +508,6 @@ function tryDisposeTreeNode(anchorNode) {
         anchorNode.slots.delete(exports.simpleTreeNodeSlot);
     }
 }
-exports.tryDisposeTreeNode = tryDisposeTreeNode;
 /**
  * Gets the {@link TreeNodeSchema} for the {@link InnerNode}.
  */
@@ -508,7 +515,6 @@ function getSimpleNodeSchemaFromInnerNode(innerNode) {
     const context = getSimpleContextFromInnerNode(innerNode);
     return context.schema.get(innerNode.type) ?? (0, internal_1.fail)(0xb3f /* missing schema from context */);
 }
-exports.getSimpleNodeSchemaFromInnerNode = getSimpleNodeSchemaFromInnerNode;
 /**
  * Gets the {@link Context} for the {@link InnerNode}.
  */
@@ -521,7 +527,6 @@ function getSimpleContextFromInnerNode(innerNode) {
     (0, internal_1.assert)(context !== undefined, 0xa55 /* missing simple tree context */);
     return context;
 }
-exports.getSimpleContextFromInnerNode = getSimpleContextFromInnerNode;
 /**
  * Retrieves the flex node associated with the given target.
  * @remarks
@@ -535,7 +540,6 @@ function getInnerNode(treeNode) {
     const kernel = getKernel(treeNode);
     return kernel.getInnerNode();
 }
-exports.getInnerNode = getInnerNode;
 /**
  * Gets a flex node from an anchor node
  */
@@ -562,7 +566,6 @@ function treeNodeFromAnchor(anchorNode) {
     const flexNode = flexNodeFromAnchor(anchorNode);
     return createTreeNodeFromInner(flexNode);
 }
-exports.treeNodeFromAnchor = treeNodeFromAnchor;
 /**
  * Constructs a TreeNode from an InnerNode.
  * @remarks
@@ -575,7 +578,6 @@ function createTreeNodeFromInner(innerNode) {
         ? new classSchema(internal)
         : classSchema.create(internal);
 }
-exports.createTreeNodeFromInner = createTreeNodeFromInner;
 /**
  * Creating multiple simple tree contexts for the same branch, and thus with the same underlying AnchorSet does not work due to how TreeNode caching works.
  * This slot is used to detect if one already exists and error if creating a second.