@fluidframework/tree 2.117.0 → 3.0.0

package/dist/simple-tree/core/toStored.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"toStored.d.ts","sourceRoot":"","sources":["../../../src/simple-tree/core/toStored.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,mBAAmB,CAAC;AAEvD;;;;GAIG;AACH,MAAM,WAAW,yBAAyB;IACzC;;;;OAIG;IACH,aAAa,CAAC,OAAO,EAAE,aAAa,GAAG,OAAO,CAAC;IAE/C;;;;;OAKG;IACH,qBAAqB,CAAC,OAAO,EAAE,aAAa,GAAG,OAAO,CAAC;CACvD;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,MAAM,WAAW,gCAAgC;IAChD;;;;;;;;OAQG;IACH,QAAQ,CAAC,WAAW,EAAE,yBAAyB,CAAC;IAChD;;;;;;OAMG;IACH,QAAQ,CAAC,UAAU,EAAE,yBAAyB,CAAC;IAC/C;;;;;;;;;OASG;IACH,qBAAqB,CAAC,GAAG,QAAQ,EAAE,aAAa,EAAE,GAAG,yBAAyB,CAAC;CAC/E;AAED;;;GAGG;AACH,eAAO,MAAM,yBAAyB,EAAE,gCAqBvC,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,YAAY,eAAyB,CAAC;AACnD,MAAM,MAAM,YAAY,GAAG,OAAO,YAAY,CAAC;AAE/C;;;;GAIG;AACH,eAAO,MAAM,SAAS,eAAsB,CAAC;AAC7C,MAAM,MAAM,SAAS,GAAG,OAAO,SAAS,CAAC;AAEzC;;GAEG;AACH,MAAM,MAAM,6BAA6B,GAAG,yBAAyB,GAAG,YAAY,CAAC;AAErF;;;;;;GAMG;AACH,MAAM,MAAM,iCAAiC,GAC1C,yBAAyB,GACzB,YAAY,GACZ,SAAS,CAAC"}
+{"version":3,"file":"toStored.d.ts","sourceRoot":"","sources":["../../../src/simple-tree/core/toStored.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,mBAAmB,CAAC;AAEvD;;;;GAIG;AACH,MAAM,WAAW,yBAAyB;IACzC;;;;;OAKG;IACH,QAAQ,CAAC,6BAA6B,CAAC,EAAE,OAAO,CAAC;IAEjD;;;;OAIG;IACH,aAAa,CAAC,OAAO,EAAE,aAAa,GAAG,OAAO,CAAC;IAE/C;;;;;OAKG;IACH,qBAAqB,CAAC,OAAO,EAAE,aAAa,GAAG,OAAO,CAAC;CACvD;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,MAAM,WAAW,gCAAgC;IAChD;;;;;;;;OAQG;IACH,QAAQ,CAAC,WAAW,EAAE,yBAAyB,CAAC;IAChD;;;;;;OAMG;IACH,QAAQ,CAAC,UAAU,EAAE,yBAAyB,CAAC;IAC/C;;;;;;;;;OASG;IACH,qBAAqB,CAAC,GAAG,QAAQ,EAAE,aAAa,EAAE,GAAG,yBAAyB,CAAC;CAC/E;AAED;;;GAGG;AACH,eAAO,MAAM,yBAAyB,EAAE,gCAqBvC,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,YAAY,eAAyB,CAAC;AACnD,MAAM,MAAM,YAAY,GAAG,OAAO,YAAY,CAAC;AAE/C;;;;GAIG;AACH,eAAO,MAAM,SAAS,eAAsB,CAAC;AAC7C,MAAM,MAAM,SAAS,GAAG,OAAO,SAAS,CAAC;AAEzC;;GAEG;AACH,MAAM,MAAM,6BAA6B,GAAG,yBAAyB,GAAG,YAAY,CAAC;AAErF;;;;;;GAMG;AACH,MAAM,MAAM,iCAAiC,GAC1C,yBAAyB,GACzB,YAAY,GACZ,SAAS,CAAC"}

package/dist/simple-tree/core/toStored.js.map

@@ -1 +1 @@
-{"version":3,"file":"toStored.js","sourceRoot":"","sources":["../../../src/simple-tree/core/toStored.ts"],"names":[],"mappings":";AAAA;;;GAGG;;;AAsFH;;;GAGG;AACU,QAAA,yBAAyB,GAAqC;IAC1E,WAAW,EAAE;QACZ,aAAa,EAAE,GAAG,EAAE,CAAC,KAAK;QAC1B,qBAAqB,EAAE,GAAG,EAAE,CAAC,KAAK;KAClC;IAED,UAAU,EAAE;QACX,aAAa,EAAE,GAAG,EAAE,CAAC,IAAI;QACzB,qBAAqB,EAAE,GAAG,EAAE,CAAC,IAAI;KACjC;IAED,qBAAqB,CAAC,GAAG,QAAyB;QACjD,IAAI,QAAQ,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;YAC3B,OAAO,iCAAyB,CAAC,WAAW,CAAC;QAC9C,CAAC;QACD,MAAM,iBAAiB,GAAG,IAAI,GAAG,CAAC,QAAQ,CAAC,CAAC;QAC5C,OAAO;YACN,aAAa,EAAE,CAAC,OAAO,EAAE,EAAE,CAAC,iBAAiB,CAAC,GAAG,CAAC,OAAO,CAAC;YAC1D,qBAAqB,EAAE,CAAC,OAAO,EAAE,EAAE,CAAC,iBAAiB,CAAC,GAAG,CAAC,OAAO,CAAC;SAClE,CAAC;IACH,CAAC;CACD,CAAC;AAEF;;GAEG;AACU,QAAA,YAAY,GAAG,MAAM,CAAC,cAAc,CAAC,CAAC;AAGnD;;;;GAIG;AACU,QAAA,SAAS,GAAG,MAAM,CAAC,WAAW,CAAC,CAAC","sourcesContent":["/*!\n * Copyright (c) Microsoft Corporation and contributors. All rights reserved.\n * Licensed under the MIT License.\n */\n\nimport type { SchemaUpgrade } from \"./allowedTypes.js\";\n\n/**\n * Policy controlling which staged schema upgrades are included when generating stored schema from a view schema.\n * @input\n * @alpha\n */\nexport interface StagedSchemaUpgradePolicy {\n\t/**\n\t * Determines whether to include staged allowed types in the resulting stored schema.\n\t * @remarks\n\t * Due to caching, the behavior of this function must be pure.\n\t */\n\tincludeStaged(upgrade: SchemaUpgrade): boolean;\n\n\t/**\n\t * Determines whether to treat a staged optional field as optional\n\t * (rather than required) in the resulting stored schema.\n\t * @remarks\n\t * Due to caching, the behavior of this function must be pure.\n\t */\n\tincludeStagedOptional(upgrade: SchemaUpgrade): boolean;\n}\n\n/**\n * Provides factory methods for creating {@link (StagedSchemaUpgradePolicy:interface)} instances.\n *\n * @remarks\n * Use the properties and methods on this object to obtain staged-schema generation options\n * for different scenarios:\n *\n * - {@link StagedSchemaUpgradePolicyFactory.restrictive} — no staged upgrades (default)\n *\n * - {@link StagedSchemaUpgradePolicyFactory.permissive} — all staged upgrades enabled\n *\n * - {@link StagedSchemaUpgradePolicyFactory.enabledStagedUpgrades} — only specific upgrades enabled\n *\n * @example\n * ```typescript\n * // Enable specific upgrades:\n * const options = StagedSchemaUpgradePolicy.enabledStagedUpgrades(myUpgrade);\n *\n * // Use restrictive (default, no staged upgrades):\n * const options = StagedSchemaUpgradePolicy.restrictive;\n *\n * // Use permissive (all staged upgrades, useful for testing):\n * const options = StagedSchemaUpgradePolicy.permissive;\n * ```\n *\n * @sealed\n * @alpha\n */\nexport interface StagedSchemaUpgradePolicyFactory {\n\t/**\n\t * Restrictive policy — excludes all staged schema members.\n\t *\n\t * @remarks\n\t * Use this when you want the most conservative stored schema for compatibility-sensitive\n\t * scenarios, or when staged schema upgrades should remain disabled.\n\t *\n\t * This is the default behavior when no staged upgrades are enabled.\n\t */\n\treadonly restrictive: StagedSchemaUpgradePolicy;\n\t/**\n\t * Permissive policy — includes all staged schema upgrades.\n\t *\n\t * @remarks\n\t * Use this for testing, validation, and rollout rehearsal scenarios where you want to exercise\n\t * future document shapes before enabling staged upgrades broadly.\n\t */\n\treadonly permissive: StagedSchemaUpgradePolicy;\n\t/**\n\t * Creates options that include only the specified staged schema upgrades.\n\t *\n\t * @param upgrades - The staged schema upgrades to enable.\n\t * @returns Options that include only the specified upgrades.\n\t *\n\t * @remarks\n\t * If an empty set of upgrades is passed, the result is equivalent to\n\t * `StagedSchemaUpgradePolicy.restrictive`.\n\t */\n\tenabledStagedUpgrades(...upgrades: SchemaUpgrade[]): StagedSchemaUpgradePolicy;\n}\n\n/**\n * {@inheritDoc (StagedSchemaUpgradePolicyFactory:interface)}\n * @alpha\n */\nexport const StagedSchemaUpgradePolicy: StagedSchemaUpgradePolicyFactory = {\n\trestrictive: {\n\t\tincludeStaged: () => false,\n\t\tincludeStagedOptional: () => false,\n\t},\n\n\tpermissive: {\n\t\tincludeStaged: () => true,\n\t\tincludeStagedOptional: () => true,\n\t},\n\n\tenabledStagedUpgrades(...upgrades: SchemaUpgrade[]): StagedSchemaUpgradePolicy {\n\t\tif (upgrades.length === 0) {\n\t\t\treturn StagedSchemaUpgradePolicy.restrictive;\n\t\t}\n\t\tconst enabledUpgradeSet = new Set(upgrades);\n\t\treturn {\n\t\t\tincludeStaged: (upgrade) => enabledUpgradeSet.has(upgrade),\n\t\t\tincludeStagedOptional: (upgrade) => enabledUpgradeSet.has(upgrade),\n\t\t};\n\t},\n};\n\n/**\n * Marker type indicating that the input schema is already a stored schema.\n */\nexport const ExpectStored = Symbol(\"ExpectStored\");\nexport type ExpectStored = typeof ExpectStored;\n\n/**\n * Marker type indicating that the input schema should not be transformed: data accessible from the simple schema API surface should be copied as is.\n * @remarks\n * The only real use-cases for this are deep-copying simple schema, and copying objects that implement more than just simple schema (such as {@link TreeSchema}) into simple object without extra prototypes and properties.\n */\nexport const Unchanged = Symbol(\"Unchanged\");\nexport type Unchanged = typeof Unchanged;\n\n/**\n * Subset of {@link SimpleSchemaTransformationOptions} for when the output is a known to be a stored schema.\n */\nexport type StoredSchemaGenerationOptions = StagedSchemaUpgradePolicy | ExpectStored;\n\n/**\n * Options for transforming a schema.\n * @remarks\n * See also {@link generateSchemaFromSimpleSchema} for a different schema transformation.\n * Note that if we want to make `generateSchemaFromSimpleSchema` consume view simple-schema, and use these transformation APIs to generate that view simple-schema from a stored simple-schema,\n * we will need to add a \"ToView\" option here.\n */\nexport type SimpleSchemaTransformationOptions =\n\t| StagedSchemaUpgradePolicy\n\t| ExpectStored\n\t| Unchanged;\n"]}
+{"version":3,"file":"toStored.js","sourceRoot":"","sources":["../../../src/simple-tree/core/toStored.ts"],"names":[],"mappings":";AAAA;;;GAGG;;;AA8FH;;;GAGG;AACU,QAAA,yBAAyB,GAAqC;IAC1E,WAAW,EAAE;QACZ,aAAa,EAAE,GAAG,EAAE,CAAC,KAAK;QAC1B,qBAAqB,EAAE,GAAG,EAAE,CAAC,KAAK;KAClC;IAED,UAAU,EAAE;QACX,aAAa,EAAE,GAAG,EAAE,CAAC,IAAI;QACzB,qBAAqB,EAAE,GAAG,EAAE,CAAC,IAAI;KACjC;IAED,qBAAqB,CAAC,GAAG,QAAyB;QACjD,IAAI,QAAQ,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;YAC3B,OAAO,iCAAyB,CAAC,WAAW,CAAC;QAC9C,CAAC;QACD,MAAM,iBAAiB,GAAG,IAAI,GAAG,CAAC,QAAQ,CAAC,CAAC;QAC5C,OAAO;YACN,aAAa,EAAE,CAAC,OAAO,EAAE,EAAE,CAAC,iBAAiB,CAAC,GAAG,CAAC,OAAO,CAAC;YAC1D,qBAAqB,EAAE,CAAC,OAAO,EAAE,EAAE,CAAC,iBAAiB,CAAC,GAAG,CAAC,OAAO,CAAC;SAClE,CAAC;IACH,CAAC;CACD,CAAC;AAEF;;GAEG;AACU,QAAA,YAAY,GAAG,MAAM,CAAC,cAAc,CAAC,CAAC;AAGnD;;;;GAIG;AACU,QAAA,SAAS,GAAG,MAAM,CAAC,WAAW,CAAC,CAAC","sourcesContent":["/*!\n * Copyright (c) Microsoft Corporation and contributors. All rights reserved.\n * Licensed under the MIT License.\n */\n\nimport type { SchemaUpgrade } from \"./allowedTypes.js\";\n\n/**\n * Policy controlling which staged schema upgrades are included when generating stored schema from a view schema.\n * @input\n * @alpha\n */\nexport interface StagedSchemaUpgradePolicy {\n\t/**\n\t * Whether schema upgrades should include staged upgrades that are already enabled in the\n\t * document's stored schema.\n\t *\n\t * @defaultValue `true`\n\t */\n\treadonly includeAlreadyEnabledUpgrades?: boolean;\n\n\t/**\n\t * Determines whether to include staged allowed types in the resulting stored schema.\n\t * @remarks\n\t * Due to caching, the behavior of this function must be pure.\n\t */\n\tincludeStaged(upgrade: SchemaUpgrade): boolean;\n\n\t/**\n\t * Determines whether to treat a staged optional field as optional\n\t * (rather than required) in the resulting stored schema.\n\t * @remarks\n\t * Due to caching, the behavior of this function must be pure.\n\t */\n\tincludeStagedOptional(upgrade: SchemaUpgrade): boolean;\n}\n\n/**\n * Provides factory methods for creating {@link (StagedSchemaUpgradePolicy:interface)} instances.\n *\n * @remarks\n * Use the properties and methods on this object to obtain staged-schema generation options\n * for different scenarios:\n *\n * - {@link StagedSchemaUpgradePolicyFactory.restrictive} — no staged upgrades (default)\n *\n * - {@link StagedSchemaUpgradePolicyFactory.permissive} — all staged upgrades enabled\n *\n * - {@link StagedSchemaUpgradePolicyFactory.enabledStagedUpgrades} — only specific upgrades enabled\n *\n * @example\n * ```typescript\n * // Enable specific upgrades:\n * const options = StagedSchemaUpgradePolicy.enabledStagedUpgrades(myUpgrade);\n *\n * // Use restrictive (default, no staged upgrades):\n * const options = StagedSchemaUpgradePolicy.restrictive;\n *\n * // Use permissive (all staged upgrades, useful for testing):\n * const options = StagedSchemaUpgradePolicy.permissive;\n * ```\n *\n * @sealed\n * @alpha\n */\nexport interface StagedSchemaUpgradePolicyFactory {\n\t/**\n\t * Restrictive policy — excludes all staged schema members.\n\t *\n\t * @remarks\n\t * Use this when you want the most conservative stored schema for compatibility-sensitive\n\t * scenarios, or when staged schema upgrades should remain disabled.\n\t *\n\t * This is the default behavior when no staged upgrades are enabled.\n\t */\n\treadonly restrictive: StagedSchemaUpgradePolicy;\n\t/**\n\t * Permissive policy — includes all staged schema upgrades.\n\t *\n\t * @remarks\n\t * Use this for testing, validation, and rollout rehearsal scenarios where you want to exercise\n\t * future document shapes before enabling staged upgrades broadly.\n\t */\n\treadonly permissive: StagedSchemaUpgradePolicy;\n\t/**\n\t * Creates options that include only the specified staged schema upgrades.\n\t *\n\t * @param upgrades - The staged schema upgrades to enable.\n\t * @returns Options that include only the specified upgrades.\n\t *\n\t * @remarks\n\t * If an empty set of upgrades is passed, the result is equivalent to\n\t * `StagedSchemaUpgradePolicy.restrictive`.\n\t */\n\tenabledStagedUpgrades(...upgrades: SchemaUpgrade[]): StagedSchemaUpgradePolicy;\n}\n\n/**\n * {@inheritDoc (StagedSchemaUpgradePolicyFactory:interface)}\n * @alpha\n */\nexport const StagedSchemaUpgradePolicy: StagedSchemaUpgradePolicyFactory = {\n\trestrictive: {\n\t\tincludeStaged: () => false,\n\t\tincludeStagedOptional: () => false,\n\t},\n\n\tpermissive: {\n\t\tincludeStaged: () => true,\n\t\tincludeStagedOptional: () => true,\n\t},\n\n\tenabledStagedUpgrades(...upgrades: SchemaUpgrade[]): StagedSchemaUpgradePolicy {\n\t\tif (upgrades.length === 0) {\n\t\t\treturn StagedSchemaUpgradePolicy.restrictive;\n\t\t}\n\t\tconst enabledUpgradeSet = new Set(upgrades);\n\t\treturn {\n\t\t\tincludeStaged: (upgrade) => enabledUpgradeSet.has(upgrade),\n\t\t\tincludeStagedOptional: (upgrade) => enabledUpgradeSet.has(upgrade),\n\t\t};\n\t},\n};\n\n/**\n * Marker type indicating that the input schema is already a stored schema.\n */\nexport const ExpectStored = Symbol(\"ExpectStored\");\nexport type ExpectStored = typeof ExpectStored;\n\n/**\n * Marker type indicating that the input schema should not be transformed: data accessible from the simple schema API surface should be copied as is.\n * @remarks\n * The only real use-cases for this are deep-copying simple schema, and copying objects that implement more than just simple schema (such as {@link TreeSchema}) into simple object without extra prototypes and properties.\n */\nexport const Unchanged = Symbol(\"Unchanged\");\nexport type Unchanged = typeof Unchanged;\n\n/**\n * Subset of {@link SimpleSchemaTransformationOptions} for when the output is a known to be a stored schema.\n */\nexport type StoredSchemaGenerationOptions = StagedSchemaUpgradePolicy | ExpectStored;\n\n/**\n * Options for transforming a schema.\n * @remarks\n * See also {@link generateSchemaFromSimpleSchema} for a different schema transformation.\n * Note that if we want to make `generateSchemaFromSimpleSchema` consume view simple-schema, and use these transformation APIs to generate that view simple-schema from a stored simple-schema,\n * we will need to add a \"ToView\" option here.\n */\nexport type SimpleSchemaTransformationOptions =\n\t| StagedSchemaUpgradePolicy\n\t| ExpectStored\n\t| Unchanged;\n"]}

package/dist/simple-tree/core/treeNode.d.ts

@@ -3,7 +3,7 @@
  * Licensed under the MIT License.
  */
 import { type TreeNodeSchemaClass } from "./treeNodeSchema.js";
-import type { WithType, typeNameSymbol, typeSchemaSymbol } from "./withType.js";
+import type { WithType, schemaIdentifierBrand, typeSchemaSymbol } from "./withType.js";
 /**
  * A non-{@link NodeKind.Leaf|leaf} SharedTree node. Includes objects, arrays, and maps.
  *
@@ -40,11 +40,10 @@ import type { WithType, typeNameSymbol, typeSchemaSymbol } from "./withType.js";
 export declare abstract class TreeNode implements WithType {
     #private;
     /**
-     * Adds a schema identifier brand for stronger and more efficient type checking.
+     * Adds a `schemaIdentifierBrand` for stronger and more efficient type checking.
      * @privateRemarks Subclasses provide more specific values to distinguish otherwise type-compatible nodes.
-     * @deprecated Use {@link typeSchemaSymbol} instead.
      */
-    abstract get [typeNameSymbol](): string;
+    abstract get [schemaIdentifierBrand](): string;
     /**
      * {@inheritDoc typeSchemaSymbol}
      * @privateRemarks

package/dist/simple-tree/core/treeNode.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"treeNode.d.ts","sourceRoot":"","sources":["../../../src/simple-tree/core/treeNode.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAOH,OAAO,EAAY,KAAK,mBAAmB,EAAE,MAAM,qBAAqB,CAAC;AACzE,OAAO,KAAK,EACX,QAAQ,EAER,cAAc,EACd,gBAAgB,EAChB,MAAM,eAAe,CAAC;AAEvB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH,8BAAsB,QAAS,YAAW,QAAQ;;IA8BjD;;;;OAIG;IAEH,aAAoB,CAAC,cAAc,CAAC,IAAI,MAAM,CAAC;IAE/C;;;;OAIG;IACH,aAAoB,CAAC,gBAAgB,CAAC,IAAI,mBAAmB,CAAC;IAE9D;;;;;;OAMG;WACW,CAAC,MAAM,CAAC,WAAW,CAAC,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,QAAQ;IAErE;;;;;;OAMG;WACW,CAAC,MAAM,CAAC,WAAW,CAAC,CACjC,OAAO,SAAS,QAAQ,MACvB,GAAG,IAAI,EAAE,GAAG,EAAE,KACV,QAAQ,EACZ,IAAI,EAAE,OAAO,EAAE,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,YAAY,CAAC,OAAO,CAAC;IAahE;;;;;;;OAOG;IACH,SAAS,aAAa,KAAK,EAAE,OAAO;CAKpC;AAID;;GAEG;AACH,eAAO,MAAM,YAAY,IAAK,CAAC;AAE/B;;;;;GAKG;AAEH,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,CAS9E"}
+{"version":3,"file":"treeNode.d.ts","sourceRoot":"","sources":["../../../src/simple-tree/core/treeNode.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAOH,OAAO,EAAY,KAAK,mBAAmB,EAAE,MAAM,qBAAqB,CAAC;AACzE,OAAO,KAAK,EAAE,QAAQ,EAAE,qBAAqB,EAAE,gBAAgB,EAAE,MAAM,eAAe,CAAC;AAEvF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH,8BAAsB,QAAS,YAAW,QAAQ;;IA8BjD;;;OAGG;IACH,aAAoB,CAAC,qBAAqB,CAAC,IAAI,MAAM,CAAC;IAEtD;;;;OAIG;IACH,aAAoB,CAAC,gBAAgB,CAAC,IAAI,mBAAmB,CAAC;IAE9D;;;;;;OAMG;WACW,CAAC,MAAM,CAAC,WAAW,CAAC,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,QAAQ;IAErE;;;;;;OAMG;WACW,CAAC,MAAM,CAAC,WAAW,CAAC,CACjC,OAAO,SAAS,QAAQ,MACvB,GAAG,IAAI,EAAE,GAAG,EAAE,KACV,QAAQ,EACZ,IAAI,EAAE,OAAO,EAAE,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,YAAY,CAAC,OAAO,CAAC;IAahE;;;;;;;OAOG;IACH,SAAS,aAAa,KAAK,EAAE,OAAO;CAKpC;AAID;;GAEG;AACH,eAAO,MAAM,YAAY,IAAK,CAAC;AAE/B;;;;;GAKG;AAEH,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,CAS9E"}

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

@@ -3,9 +3,9 @@
  * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
  * Licensed under the MIT License.
  */
-var _TreeNode_brand;
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.inPrototypeChain = exports.privateToken = exports.TreeNode = void 0;
+exports.privateToken = exports.TreeNode = void 0;
+exports.inPrototypeChain = inPrototypeChain;
 const internal_1 = require("@fluidframework/core-utils/internal");
 const internal_2 = require("@fluidframework/telemetry-utils/internal");
 const flexList_js_1 = require("./flexList.js");
@@ -45,7 +45,35 @@ const treeNodeSchema_js_1 = require("./treeNodeSchema.js");
  * @sealed @public
  */
 class TreeNode {
-    static [(_TreeNode_brand = new WeakMap(), Symbol.hasInstance)](value) {
+    /**
+     * This is added to prevent TypeScript from implicitly allowing non-TreeNode types to be used as TreeNodes.
+     * @remarks
+     * This field forces TypeScript to use nominal instead of structural typing,
+     * preventing compiler error messages and tools like "add missing properties"
+     * from adding the [type] field as a solution when using a non-TreeNode object where a TreeNode is required.
+     * Instead TreeNodes must be created through the appropriate APIs, see the documentation on {@link TreeNode} for details.
+     *
+     * @privateRemarks
+     * This is a JavaScript private field, so is not accessible from outside this class.
+     * This prevents it from having name collisions with object fields.
+     * Since this is private, the type of this field is stripped in the d.ts file.
+     * To get matching type checking within and from outside the package, the least informative type (`unknown`) is used.
+     * To avoid this having any runtime impact, the field is uninitialized.
+     *
+     * Making this field optional results in different type checking within this project than outside of it, since the d.ts file drops the optional aspect of the field.
+     * This is extra confusing since since the tests get in-project typing for intellisense and separate project checking at build time.
+     * To avoid all this mess, this field is required, not optional.
+     *
+     * Another option would be to use a symbol (possibly as a private field).
+     * That approach ran into some strange difficulties causing SchemaFactory to fail to compile, and was not investigated further.
+     *
+     * The [type] symbol provides a lot of the value this private brand does, but is not all of it:
+     * someone could manually (or via Intellisense auto-implement completion, or in response to a type error)
+     * make an object literal with the [type] field and pass it off as a node: this private brand prevents that.
+     */
+    // eslint-disable-next-line no-unused-private-class-members -- Exists for type checking sideeffect. See private remarks above.
+    #brand;
+    static [Symbol.hasInstance](value) {
         const schema = (0, treeNodeKernel_js_1.tryGetTreeNodeSchema)(value);
         if (schema === undefined || schema.kind === treeNodeSchema_js_1.NodeKind.Leaf) {
             return false;
@@ -62,34 +90,6 @@ class TreeNode {
      * All valid subclass should use {@link TreeNodeValid}, but this code doesn't directly reference it to avoid cyclic dependencies.
      */
     constructor(token) {
-        /**
-         * This is added to prevent TypeScript from implicitly allowing non-TreeNode types to be used as TreeNodes.
-         * @remarks
-         * This field forces TypeScript to use nominal instead of structural typing,
-         * preventing compiler error messages and tools like "add missing properties"
-         * from adding the [type] field as a solution when using a non-TreeNode object where a TreeNode is required.
-         * Instead TreeNodes must be created through the appropriate APIs, see the documentation on {@link TreeNode} for details.
-         *
-         * @privateRemarks
-         * This is a JavaScript private field, so is not accessible from outside this class.
-         * This prevents it from having name collisions with object fields.
-         * Since this is private, the type of this field is stripped in the d.ts file.
-         * To get matching type checking within and from outside the package, the least informative type (`unknown`) is used.
-         * To avoid this having any runtime impact, the field is uninitialized.
-         *
-         * Making this field optional results in different type checking within this project than outside of it, since the d.ts file drops the optional aspect of the field.
-         * This is extra confusing since since the tests get in-project typing for intellisense and separate project checking at build time.
-         * To avoid all this mess, this field is required, not optional.
-         *
-         * Another option would be to use a symbol (possibly as a private field).
-         * That approach ran into some strange difficulties causing SchemaFactory to fail to compile, and was not investigated further.
-         *
-         * The [type] symbol provides a lot of the value this private brand does, but is not all of it:
-         * someone could manually (or via Intellisense auto-implement completion, or in response to a type error)
-         * make an object literal with the [type] field and pass it off as a node: this private brand prevents that.
-         */
-        // eslint-disable-next-line no-unused-private-class-members -- Exists for type checking sideeffect. See private remarks above.
-        _TreeNode_brand.set(this, void 0);
         if (token !== exports.privateToken) {
             throw new internal_2.UsageError("TreeNodes must extend schema classes created by SchemaFactory");
         }
@@ -119,5 +119,4 @@ function inPrototypeChain(derived, base) {
     }
     return false;
 }
-exports.inPrototypeChain = inPrototypeChain;
 //# sourceMappingURL=treeNode.js.map

package/dist/simple-tree/core/treeNode.js.map

@@ -1 +1 @@
-{"version":3,"file":"treeNode.js","sourceRoot":"","sources":["../../../src/simple-tree/core/treeNode.ts"],"names":[],"mappings":";AAAA;;;GAGG;;;;AAEH,kEAA6D;AAC7D,uEAAsE;AAEtE,+CAA0C;AAC1C,2DAA2D;AAC3D,2DAAyE;AAQzE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH,MAAsB,QAAQ;IAmEtB,MAAM,CAAC,mCAAC,MAAM,CAAC,WAAW,EAAC,CAA8B,KAAc;QAC7E,MAAM,MAAM,GAAG,IAAA,wCAAoB,EAAC,KAAK,CAAC,CAAC;QAE3C,IAAI,MAAM,KAAK,SAAS,IAAI,MAAM,CAAC,IAAI,KAAK,4BAAQ,CAAC,IAAI,EAAE,CAAC;YAC3D,OAAO,KAAK,CAAC;QACd,CAAC;QAED,IAAA,iBAAM,EAAC,WAAW,IAAI,MAAM,EAAE,KAAK,CAAC,iCAAiC,CAAC,CAAC;QACvE,OAAO,gBAAgB,CAAC,MAAM,CAAC,SAAS,EAAE,IAAI,CAAC,SAAS,CAAC,CAAC;IAC3D,CAAC;IAED;;;;;;;OAOG;IACH,YAAsB,KAAc;QArFpC;;;;;;;;;;;;;;;;;;;;;;;;;WAyBG;QACH,8HAA8H;QACrH,kCAAiB;QA2DzB,IAAI,KAAK,KAAK,oBAAY,EAAE,CAAC;YAC5B,MAAM,IAAI,qBAAU,CAAC,+DAA+D,CAAC,CAAC;QACvF,CAAC;IACF,CAAC;CACD;AA3FD,4BA2FC;AACD,gJAAgJ;AAChJ,IAAA,uBAAS,EAAC,QAAQ,CAAC,CAAC;AAEpB;;GAEG;AACU,QAAA,YAAY,GAAG,EAAE,CAAC;AAE/B;;;;;GAKG;AACH,+EAA+E;AAC/E,SAAgB,gBAAgB,CAAC,OAAsB,EAAE,IAAY;IACpE,IAAI,QAAQ,GAAG,OAAO,CAAC;IACvB,OAAO,QAAQ,KAAK,IAAI,EAAE,CAAC;QAC1B,IAAI,IAAI,KAAK,QAAQ,EAAE,CAAC;YACvB,OAAO,IAAI,CAAC;QACb,CAAC;QACD,QAAQ,GAAG,OAAO,CAAC,cAAc,CAAC,QAAQ,CAAC,CAAC;IAC7C,CAAC;IACD,OAAO,KAAK,CAAC;AACd,CAAC;AATD,4CASC","sourcesContent":["/*!\n * Copyright (c) Microsoft Corporation and contributors. All rights reserved.\n * Licensed under the MIT License.\n */\n\nimport { assert } from \"@fluidframework/core-utils/internal\";\nimport { UsageError } from \"@fluidframework/telemetry-utils/internal\";\n\nimport { markEager } from \"./flexList.js\";\nimport { tryGetTreeNodeSchema } from \"./treeNodeKernel.js\";\nimport { NodeKind, type TreeNodeSchemaClass } from \"./treeNodeSchema.js\";\nimport type {\n\tWithType,\n\t// eslint-disable-next-line import-x/no-deprecated -- Required to implement the deprecated typeNameSymbol API.\n\ttypeNameSymbol,\n\ttypeSchemaSymbol,\n} from \"./withType.js\";\n\n/**\n * A non-{@link NodeKind.Leaf|leaf} SharedTree node. Includes objects, arrays, and maps.\n *\n * @remarks\n * Base type which all nodes extend.\n *\n * This type can be used as a type to indicate/document values which should be tree nodes.\n * Runtime use of this class object (for example when used with `instanceof` or extending it), is not currently supported.\n *\n * There are three ways to get instances of TreeNode:\n *\n * 1. From a {@link TreeView} loading nodes from an existing document, or creating local copies of nodes inserted by a remote collaborator.\n * This case provides an {@link InternalTreeNode} to the constructor: subclasses must not modify how the constructor handles this case.\n *\n * 2. Explicit construction of {@link Unhydrated} nodes using either {@link TreeNodeSchemaClass} as a constructor or {@link TreeNodeSchemaNonClass|TreeNodeSchemaNonClass.create}.\n * Either way the {@link TreeNodeSchema} produced must be produced using a {@link SchemaFactory}.\n * There are also higher level APIs which wrap these, including {@link (TreeBeta:interface).create}, {@link (TreeBeta:interface).clone},\n * and import APIs like {@link (TreeBeta:interface).importConcise}, {@link (TreeAlpha:interface).importVerbose}, and {@link (TreeAlpha:interface).importCompressed}.\n *\n * 3. Implicit construction: Several APIs which logically require an unhydrated TreeNode also allow passing in a value which could be used to explicitly construct the node instead.\n * These APIs internally call the constructor with the provided value (typically behaving like {@link (TreeAlpha:interface).create}), so it's really just a special case of the above option.\n * Note that when constructing nodes, sometimes implicit construction is not allowed\n * (either at runtime due to ambiguous types or at compile time due to TypeScript limitations):\n * in such cases, explicit construction must be used.\n * @privateRemarks\n * This is a class not an interface to enable stricter type checking (see {@link TreeNode.#brand})\n * and some runtime enforcement of schema class policy (see the the validation in the constructor).\n *\n * Not all node implementations include this in their prototype chain (some hide it with a proxy),\n * and thus cause the default/built in `instanceof` to return false despite our type checking and all other APIs treating them as TreeNodes.\n * This class provides a custom `Symbol.hasInstance` to fix `instanceof` for this class and all classes extending it.\n * @sealed @public\n */\nexport abstract class TreeNode implements WithType {\n\t/**\n\t * This is added to prevent TypeScript from implicitly allowing non-TreeNode types to be used as TreeNodes.\n\t * @remarks\n\t * This field forces TypeScript to use nominal instead of structural typing,\n\t * preventing compiler error messages and tools like \"add missing properties\"\n\t * from adding the [type] field as a solution when using a non-TreeNode object where a TreeNode is required.\n\t * Instead TreeNodes must be created through the appropriate APIs, see the documentation on {@link TreeNode} for details.\n\t *\n\t * @privateRemarks\n\t * This is a JavaScript private field, so is not accessible from outside this class.\n\t * This prevents it from having name collisions with object fields.\n\t * Since this is private, the type of this field is stripped in the d.ts file.\n\t * To get matching type checking within and from outside the package, the least informative type (`unknown`) is used.\n\t * To avoid this having any runtime impact, the field is uninitialized.\n\t *\n\t * Making this field optional results in different type checking within this project than outside of it, since the d.ts file drops the optional aspect of the field.\n\t * This is extra confusing since since the tests get in-project typing for intellisense and separate project checking at build time.\n\t * To avoid all this mess, this field is required, not optional.\n\t *\n\t * Another option would be to use a symbol (possibly as a private field).\n\t * That approach ran into some strange difficulties causing SchemaFactory to fail to compile, and was not investigated further.\n\t *\n\t * The [type] symbol provides a lot of the value this private brand does, but is not all of it:\n\t * someone could manually (or via Intellisense auto-implement completion, or in response to a type error)\n\t * make an object literal with the [type] field and pass it off as a node: this private brand prevents that.\n\t */\n\t// eslint-disable-next-line no-unused-private-class-members -- Exists for type checking sideeffect. See private remarks above.\n\treadonly #brand!: unknown;\n\n\t/**\n\t * Adds a schema identifier brand for stronger and more efficient type checking.\n\t * @privateRemarks Subclasses provide more specific values to distinguish otherwise type-compatible nodes.\n\t * @deprecated Use {@link typeSchemaSymbol} instead.\n\t */\n\t// eslint-disable-next-line import-x/no-deprecated -- Required to implement the deprecated typeNameSymbol API.\n\tpublic abstract get [typeNameSymbol](): string;\n\n\t/**\n\t * {@inheritDoc typeSchemaSymbol}\n\t * @privateRemarks\n\t * Subclasses provide more specific values for this to get strong typing of otherwise type compatible nodes.\n\t */\n\tpublic abstract get [typeSchemaSymbol](): TreeNodeSchemaClass;\n\n\t/**\n\t * Provides `instanceof` support for testing if a value is a `TreeNode`.\n\t * @remarks\n\t * For more options, like including leaf values or narrowing to collections of schema, use `is` or `schema` from {@link TreeNodeApi}.\n\t * @privateRemarks\n\t * Due to type-only export, this functionality is not available outside the package.\n\t */\n\tpublic static [Symbol.hasInstance](value: unknown): value is TreeNode;\n\n\t/**\n\t * Provides `instanceof` support for all schema classes with public constructors.\n\t * @remarks\n\t * For more options, like including leaf values or narrowing to collections of schema, use `is` or `schema` from {@link TreeNodeApi}.\n\t * @privateRemarks\n\t * Despite type-only export, this functionality is available outside the package since it is inherited by subclasses.\n\t */\n\tpublic static [Symbol.hasInstance]<\n\t\tTSchema extends abstract new (\n\t\t\t...args: any[]\n\t\t) => TreeNode,\n\t>(this: TSchema, value: unknown): value is InstanceType<TSchema>;\n\n\tpublic static [Symbol.hasInstance](this: { prototype: object }, value: unknown): boolean {\n\t\tconst schema = tryGetTreeNodeSchema(value);\n\n\t\tif (schema === undefined || schema.kind === NodeKind.Leaf) {\n\t\t\treturn false;\n\t\t}\n\n\t\tassert(\"prototype\" in schema, 0x98a /* expected class based schema */);\n\t\treturn inPrototypeChain(schema.prototype, this.prototype);\n\t}\n\n\t/**\n\t * TreeNodes must extend schema classes created by SchemaFactory, and therefore this constructor should not be invoked directly by code outside this package.\n\t * @privateRemarks\n\t * `token` must be the {@link privateToken} value, which is not package exported.\n\t * This is used to detect invalid subclasses.\n\t *\n\t * All valid subclass should use {@link TreeNodeValid}, but this code doesn't directly reference it to avoid cyclic dependencies.\n\t */\n\tprotected constructor(token: unknown) {\n\t\tif (token !== privateToken) {\n\t\t\tthrow new UsageError(\"TreeNodes must extend schema classes created by SchemaFactory\");\n\t\t}\n\t}\n}\n// Class objects are functions (callable), so we need a strong way to distinguish between `schema` and `() => schema` when used as a `LazyItem`.\nmarkEager(TreeNode);\n\n/**\n * `token` to pass to {@link TreeNode}'s constructor used to detect invalid subclasses.\n */\nexport const privateToken = {};\n\n/**\n * Check if the prototype derived's prototype chain contains `base`.\n * @param derived - prototype to check\n * @param base - prototype to search for\n * @returns true iff `base` is in the prototype chain starting at `derived`.\n */\n// eslint-disable-next-line @rushstack/no-new-null -- getPrototypeOf uses null.\nexport function inPrototypeChain(derived: object | null, base: object): boolean {\n\tlet checking = derived;\n\twhile (checking !== null) {\n\t\tif (base === checking) {\n\t\t\treturn true;\n\t\t}\n\t\tchecking = Reflect.getPrototypeOf(checking);\n\t}\n\treturn false;\n}\n"]}
+{"version":3,"file":"treeNode.js","sourceRoot":"","sources":["../../../src/simple-tree/core/treeNode.ts"],"names":[],"mappings":";AAAA;;;GAGG;;;AAoJH,4CASC;AA3JD,kEAA6D;AAC7D,uEAAsE;AAEtE,+CAA0C;AAC1C,2DAA2D;AAC3D,2DAAyE;AAGzE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH,MAAsB,QAAQ;IAC7B;;;;;;;;;;;;;;;;;;;;;;;;;OAyBG;IACH,8HAA8H;IACrH,MAAM,CAAW;IAqCnB,MAAM,CAAC,CAAC,MAAM,CAAC,WAAW,CAAC,CAA8B,KAAc;QAC7E,MAAM,MAAM,GAAG,IAAA,wCAAoB,EAAC,KAAK,CAAC,CAAC;QAE3C,IAAI,MAAM,KAAK,SAAS,IAAI,MAAM,CAAC,IAAI,KAAK,4BAAQ,CAAC,IAAI,EAAE,CAAC;YAC3D,OAAO,KAAK,CAAC;QACd,CAAC;QAED,IAAA,iBAAM,EAAC,WAAW,IAAI,MAAM,EAAE,KAAK,CAAC,iCAAiC,CAAC,CAAC;QACvE,OAAO,gBAAgB,CAAC,MAAM,CAAC,SAAS,EAAE,IAAI,CAAC,SAAS,CAAC,CAAC;IAC3D,CAAC;IAED;;;;;;;OAOG;IACH,YAAsB,KAAc;QACnC,IAAI,KAAK,KAAK,oBAAY,EAAE,CAAC;YAC5B,MAAM,IAAI,qBAAU,CAAC,+DAA+D,CAAC,CAAC;QACvF,CAAC;IACF,CAAC;CACD;AAzFD,4BAyFC;AACD,gJAAgJ;AAChJ,IAAA,uBAAS,EAAC,QAAQ,CAAC,CAAC;AAEpB;;GAEG;AACU,QAAA,YAAY,GAAG,EAAE,CAAC;AAE/B;;;;;GAKG;AACH,+EAA+E;AAC/E,SAAgB,gBAAgB,CAAC,OAAsB,EAAE,IAAY;IACpE,IAAI,QAAQ,GAAG,OAAO,CAAC;IACvB,OAAO,QAAQ,KAAK,IAAI,EAAE,CAAC;QAC1B,IAAI,IAAI,KAAK,QAAQ,EAAE,CAAC;YACvB,OAAO,IAAI,CAAC;QACb,CAAC;QACD,QAAQ,GAAG,OAAO,CAAC,cAAc,CAAC,QAAQ,CAAC,CAAC;IAC7C,CAAC;IACD,OAAO,KAAK,CAAC;AACd,CAAC","sourcesContent":["/*!\n * Copyright (c) Microsoft Corporation and contributors. All rights reserved.\n * Licensed under the MIT License.\n */\n\nimport { assert } from \"@fluidframework/core-utils/internal\";\nimport { UsageError } from \"@fluidframework/telemetry-utils/internal\";\n\nimport { markEager } from \"./flexList.js\";\nimport { tryGetTreeNodeSchema } from \"./treeNodeKernel.js\";\nimport { NodeKind, type TreeNodeSchemaClass } from \"./treeNodeSchema.js\";\nimport type { WithType, schemaIdentifierBrand, typeSchemaSymbol } from \"./withType.js\";\n\n/**\n * A non-{@link NodeKind.Leaf|leaf} SharedTree node. Includes objects, arrays, and maps.\n *\n * @remarks\n * Base type which all nodes extend.\n *\n * This type can be used as a type to indicate/document values which should be tree nodes.\n * Runtime use of this class object (for example when used with `instanceof` or extending it), is not currently supported.\n *\n * There are three ways to get instances of TreeNode:\n *\n * 1. From a {@link TreeView} loading nodes from an existing document, or creating local copies of nodes inserted by a remote collaborator.\n * This case provides an {@link InternalTreeNode} to the constructor: subclasses must not modify how the constructor handles this case.\n *\n * 2. Explicit construction of {@link Unhydrated} nodes using either {@link TreeNodeSchemaClass} as a constructor or {@link TreeNodeSchemaNonClass|TreeNodeSchemaNonClass.create}.\n * Either way the {@link TreeNodeSchema} produced must be produced using a {@link SchemaFactory}.\n * There are also higher level APIs which wrap these, including {@link (TreeBeta:interface).create}, {@link (TreeBeta:interface).clone},\n * and import APIs like {@link (TreeBeta:interface).importConcise}, {@link (TreeAlpha:interface).importVerbose}, and {@link (TreeAlpha:interface).importCompressed}.\n *\n * 3. Implicit construction: Several APIs which logically require an unhydrated TreeNode also allow passing in a value which could be used to explicitly construct the node instead.\n * These APIs internally call the constructor with the provided value (typically behaving like {@link (TreeAlpha:interface).create}), so it's really just a special case of the above option.\n * Note that when constructing nodes, sometimes implicit construction is not allowed\n * (either at runtime due to ambiguous types or at compile time due to TypeScript limitations):\n * in such cases, explicit construction must be used.\n * @privateRemarks\n * This is a class not an interface to enable stricter type checking (see {@link TreeNode.#brand})\n * and some runtime enforcement of schema class policy (see the the validation in the constructor).\n *\n * Not all node implementations include this in their prototype chain (some hide it with a proxy),\n * and thus cause the default/built in `instanceof` to return false despite our type checking and all other APIs treating them as TreeNodes.\n * This class provides a custom `Symbol.hasInstance` to fix `instanceof` for this class and all classes extending it.\n * @sealed @public\n */\nexport abstract class TreeNode implements WithType {\n\t/**\n\t * This is added to prevent TypeScript from implicitly allowing non-TreeNode types to be used as TreeNodes.\n\t * @remarks\n\t * This field forces TypeScript to use nominal instead of structural typing,\n\t * preventing compiler error messages and tools like \"add missing properties\"\n\t * from adding the [type] field as a solution when using a non-TreeNode object where a TreeNode is required.\n\t * Instead TreeNodes must be created through the appropriate APIs, see the documentation on {@link TreeNode} for details.\n\t *\n\t * @privateRemarks\n\t * This is a JavaScript private field, so is not accessible from outside this class.\n\t * This prevents it from having name collisions with object fields.\n\t * Since this is private, the type of this field is stripped in the d.ts file.\n\t * To get matching type checking within and from outside the package, the least informative type (`unknown`) is used.\n\t * To avoid this having any runtime impact, the field is uninitialized.\n\t *\n\t * Making this field optional results in different type checking within this project than outside of it, since the d.ts file drops the optional aspect of the field.\n\t * This is extra confusing since since the tests get in-project typing for intellisense and separate project checking at build time.\n\t * To avoid all this mess, this field is required, not optional.\n\t *\n\t * Another option would be to use a symbol (possibly as a private field).\n\t * That approach ran into some strange difficulties causing SchemaFactory to fail to compile, and was not investigated further.\n\t *\n\t * The [type] symbol provides a lot of the value this private brand does, but is not all of it:\n\t * someone could manually (or via Intellisense auto-implement completion, or in response to a type error)\n\t * make an object literal with the [type] field and pass it off as a node: this private brand prevents that.\n\t */\n\t// eslint-disable-next-line no-unused-private-class-members -- Exists for type checking sideeffect. See private remarks above.\n\treadonly #brand!: unknown;\n\n\t/**\n\t * Adds a `schemaIdentifierBrand` for stronger and more efficient type checking.\n\t * @privateRemarks Subclasses provide more specific values to distinguish otherwise type-compatible nodes.\n\t */\n\tpublic abstract get [schemaIdentifierBrand](): string;\n\n\t/**\n\t * {@inheritDoc typeSchemaSymbol}\n\t * @privateRemarks\n\t * Subclasses provide more specific values for this to get strong typing of otherwise type compatible nodes.\n\t */\n\tpublic abstract get [typeSchemaSymbol](): TreeNodeSchemaClass;\n\n\t/**\n\t * Provides `instanceof` support for testing if a value is a `TreeNode`.\n\t * @remarks\n\t * For more options, like including leaf values or narrowing to collections of schema, use `is` or `schema` from {@link TreeNodeApi}.\n\t * @privateRemarks\n\t * Due to type-only export, this functionality is not available outside the package.\n\t */\n\tpublic static [Symbol.hasInstance](value: unknown): value is TreeNode;\n\n\t/**\n\t * Provides `instanceof` support for all schema classes with public constructors.\n\t * @remarks\n\t * For more options, like including leaf values or narrowing to collections of schema, use `is` or `schema` from {@link TreeNodeApi}.\n\t * @privateRemarks\n\t * Despite type-only export, this functionality is available outside the package since it is inherited by subclasses.\n\t */\n\tpublic static [Symbol.hasInstance]<\n\t\tTSchema extends abstract new (\n\t\t\t...args: any[]\n\t\t) => TreeNode,\n\t>(this: TSchema, value: unknown): value is InstanceType<TSchema>;\n\n\tpublic static [Symbol.hasInstance](this: { prototype: object }, value: unknown): boolean {\n\t\tconst schema = tryGetTreeNodeSchema(value);\n\n\t\tif (schema === undefined || schema.kind === NodeKind.Leaf) {\n\t\t\treturn false;\n\t\t}\n\n\t\tassert(\"prototype\" in schema, 0x98a /* expected class based schema */);\n\t\treturn inPrototypeChain(schema.prototype, this.prototype);\n\t}\n\n\t/**\n\t * TreeNodes must extend schema classes created by SchemaFactory, and therefore this constructor should not be invoked directly by code outside this package.\n\t * @privateRemarks\n\t * `token` must be the {@link privateToken} value, which is not package exported.\n\t * This is used to detect invalid subclasses.\n\t *\n\t * All valid subclass should use {@link TreeNodeValid}, but this code doesn't directly reference it to avoid cyclic dependencies.\n\t */\n\tprotected constructor(token: unknown) {\n\t\tif (token !== privateToken) {\n\t\t\tthrow new UsageError(\"TreeNodes must extend schema classes created by SchemaFactory\");\n\t\t}\n\t}\n}\n// Class objects are functions (callable), so we need a strong way to distinguish between `schema` and `() => schema` when used as a `LazyItem`.\nmarkEager(TreeNode);\n\n/**\n * `token` to pass to {@link TreeNode}'s constructor used to detect invalid subclasses.\n */\nexport const privateToken = {};\n\n/**\n * Check if the prototype derived's prototype chain contains `base`.\n * @param derived - prototype to check\n * @param base - prototype to search for\n * @returns true iff `base` is in the prototype chain starting at `derived`.\n */\n// eslint-disable-next-line @rushstack/no-new-null -- getPrototypeOf uses null.\nexport function inPrototypeChain(derived: object | null, base: object): boolean {\n\tlet checking = derived;\n\twhile (checking !== null) {\n\t\tif (base === checking) {\n\t\t\treturn true;\n\t\t}\n\t\tchecking = Reflect.getPrototypeOf(checking);\n\t}\n\treturn false;\n}\n"]}