@angular/core 20.0.0-next.0 → 20.0.0-next.2

package/schematics/bundles/{index-42d84d69.js → index-DnkWgagp.js}

@@ -1,30 +1,26 @@
 'use strict';
 /**
- * @license Angular v20.0.0-next.0
- * (c) 2010-2024 Google LLC. https://angular.io/
+ * @license Angular v20.0.0-next.2
+ * (c) 2010-2025 Google LLC. https://angular.io/
  * License: MIT
  */
 'use strict';
 
 var ts = require('typescript');
 require('os');
-var checker = require('./checker-cf6f7980.js');
-var program = require('./program-362689f0.js');
+var checker = require('./checker-DF8ZaFW5.js');
+var program = require('./program-BZk27Ndu.js');
 require('path');
-var project_paths = require('./project_paths-7d2daa1e.js');
-
-function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
-
-var ts__default = /*#__PURE__*/_interopDefaultLegacy(ts);
+var project_paths = require('./project_paths-Jtbi76Bs.js');
 
 function getMemberName(member) {
     if (member.name === undefined) {
         return null;
     }
-    if (ts__default["default"].isIdentifier(member.name) || ts__default["default"].isStringLiteralLike(member.name)) {
+    if (ts.isIdentifier(member.name) || ts.isStringLiteralLike(member.name)) {
         return member.name.text;
     }
-    if (ts__default["default"].isPrivateIdentifier(member.name)) {
+    if (ts.isPrivateIdentifier(member.name)) {
         return `#${member.name.text}`;
     }
     return null;
@@ -32,8 +28,8 @@ function getMemberName(member) {
 
 /** Checks whether the given node can be an `@Input()` declaration node. */
 function isInputContainerNode(node) {
-    return (((ts__default["default"].isAccessor(node) && ts__default["default"].isClassDeclaration(node.parent)) ||
-        ts__default["default"].isPropertyDeclaration(node)) &&
+    return (((ts.isAccessor(node) && ts.isClassDeclaration(node.parent)) ||
+        ts.isPropertyDeclaration(node)) &&
         getMemberName(node) !== null);
 }
 
@@ -56,17 +52,17 @@ class DebugElementComponentInstance {
         if (this.cache.has(node)) {
             return this.cache.get(node);
         }
-        if (!ts__default["default"].isPropertyAccessExpression(node)) {
+        if (!ts.isPropertyAccessExpression(node)) {
             return null;
         }
         // Check for `<>.componentInstance`.
-        if (!ts__default["default"].isIdentifier(node.name) || node.name.text !== 'componentInstance') {
+        if (!ts.isIdentifier(node.name) || node.name.text !== 'componentInstance') {
             return null;
         }
         // Check for `<>.query(..).<>`.
-        if (!ts__default["default"].isCallExpression(node.expression) ||
-            !ts__default["default"].isPropertyAccessExpression(node.expression.expression) ||
-            !ts__default["default"].isIdentifier(node.expression.expression.name) ||
+        if (!ts.isCallExpression(node.expression) ||
+            !ts.isPropertyAccessExpression(node.expression.expression) ||
+            !ts.isIdentifier(node.expression.expression.name) ||
             node.expression.expression.name.text !== 'query') {
             return null;
         }
@@ -76,13 +72,13 @@ class DebugElementComponentInstance {
         }
         const queryArg = queryCall.arguments[0];
         let typeExpr;
-        if (ts__default["default"].isCallExpression(queryArg) &&
+        if (ts.isCallExpression(queryArg) &&
             queryArg.arguments.length === 1 &&
-            ts__default["default"].isIdentifier(queryArg.arguments[0])) {
+            ts.isIdentifier(queryArg.arguments[0])) {
             // Detect references, like: `query(By.directive(T))`.
             typeExpr = queryArg.arguments[0];
         }
-        else if (ts__default["default"].isIdentifier(queryArg)) {
+        else if (ts.isIdentifier(queryArg)) {
             // Detect references, like: `harness.query(T)`.
             typeExpr = queryArg;
         }
@@ -91,7 +87,7 @@ class DebugElementComponentInstance {
         }
         const symbol = this.checker.getSymbolAtLocation(typeExpr);
         if (symbol?.valueDeclaration === undefined ||
-            !ts__default["default"].isClassDeclaration(symbol?.valueDeclaration)) {
+            !ts.isClassDeclaration(symbol?.valueDeclaration)) {
             // Cache this as we use the expensive type checker.
             this.cache.set(node, null);
             return null;
@@ -123,8 +119,8 @@ class PartialDirectiveTypeInCatalystTests {
     }
     detect(node) {
         // Detect `Partial<...>`
-        if (!ts__default["default"].isTypeReferenceNode(node) ||
-            !ts__default["default"].isIdentifier(node.typeName) ||
+        if (!ts.isTypeReferenceNode(node) ||
+            !ts.isIdentifier(node.typeName) ||
             node.typeName.text !== 'Partial') {
             return null;
         }
@@ -135,8 +131,8 @@ class PartialDirectiveTypeInCatalystTests {
         // Extract T of `Partial<T>`.
         const cmpTypeArg = node.typeArguments?.[0];
         if (!cmpTypeArg ||
-            !ts__default["default"].isTypeReferenceNode(cmpTypeArg) ||
-            !ts__default["default"].isIdentifier(cmpTypeArg.typeName)) {
+            !ts.isTypeReferenceNode(cmpTypeArg) ||
+            !ts.isIdentifier(cmpTypeArg.typeName)) {
             return null;
         }
         const cmpType = cmpTypeArg.typeName;
@@ -144,7 +140,7 @@ class PartialDirectiveTypeInCatalystTests {
         // Note: Technically the class might be derived of an input-containing class,
         // but this is out of scope for now. We can expand if we see it's a common case.
         if (symbol?.valueDeclaration === undefined ||
-            !ts__default["default"].isClassDeclaration(symbol.valueDeclaration) ||
+            !ts.isClassDeclaration(symbol.valueDeclaration) ||
             !this.knownFields.shouldTrackClassReference(symbol.valueDeclaration)) {
             return null;
         }
@@ -320,7 +316,7 @@ class TemplateReferenceVisitor extends checker.RecursiveVisitor$1 {
  * This resolution is important to be able to migrate references to inputs
  * that will be migrated to signal inputs.
  */
-class TemplateExpressionReferenceVisitor extends checker.RecursiveAstVisitor$1 {
+class TemplateExpressionReferenceVisitor extends checker.RecursiveAstVisitor {
     typeChecker;
     templateTypeChecker;
     componentClass;
@@ -547,7 +543,7 @@ function identifyHostBindingReferences(node, programInfo, checker$1, reflector,
         return;
     }
     const metadataNode = checker.unwrapExpression(ngDecorator.args[0]);
-    if (!ts__default["default"].isObjectLiteralExpression(metadataNode)) {
+    if (!ts.isObjectLiteralExpression(metadataNode)) {
         return;
     }
     const metadata = checker.reflectObjectLiteral(metadataNode);
@@ -557,26 +553,26 @@ function identifyHostBindingReferences(node, programInfo, checker$1, reflector,
     let hostField = checker.unwrapExpression(metadata.get('host'));
     // Special-case in case host bindings are shared via a variable.
     // e.g. Material button shares host bindings as a constant in the same target.
-    if (ts__default["default"].isIdentifier(hostField)) {
+    if (ts.isIdentifier(hostField)) {
         let symbol = checker$1.getSymbolAtLocation(hostField);
         // Plain identifier references can point to alias symbols (e.g. imports).
-        if (symbol !== undefined && symbol.flags & ts__default["default"].SymbolFlags.Alias) {
+        if (symbol !== undefined && symbol.flags & ts.SymbolFlags.Alias) {
             symbol = checker$1.getAliasedSymbol(symbol);
         }
         if (symbol !== undefined &&
             symbol.valueDeclaration !== undefined &&
-            ts__default["default"].isVariableDeclaration(symbol.valueDeclaration)) {
+            ts.isVariableDeclaration(symbol.valueDeclaration)) {
             hostField = symbol?.valueDeclaration.initializer;
         }
     }
-    if (hostField === undefined || !ts__default["default"].isObjectLiteralExpression(hostField)) {
+    if (hostField === undefined || !ts.isObjectLiteralExpression(hostField)) {
         return;
     }
     const hostMap = checker.reflectObjectLiteral(hostField);
     const expressionResult = [];
     const expressionVisitor = new TemplateExpressionReferenceVisitor(checker$1, null, node, knownFields, fieldNamesToConsiderForReferenceLookup);
     for (const [rawName, expression] of hostMap.entries()) {
-        if (!ts__default["default"].isStringLiteralLike(expression)) {
+        if (!ts.isStringLiteralLike(expression)) {
             continue;
         }
         const isEventBinding = rawName.startsWith('(');
@@ -639,7 +635,7 @@ function attemptExtractTemplateDefinition(node, checker$1, reflector, resourceLo
     if (ngDecorators.length === 0 ||
         ngDecorators[0].args === null ||
         ngDecorators[0].args.length === 0 ||
-        !ts__default["default"].isObjectLiteralExpression(ngDecorators[0].args[0])) {
+        !ts.isObjectLiteralExpression(ngDecorators[0].args[0])) {
         return null;
     }
     const properties = checker.reflectObjectLiteral(ngDecorators[0].args[0]);
@@ -755,7 +751,7 @@ function extractTemplateWithoutCompilerAnalysis(node, checker$1, reflector, reso
 function resolveBindingElement(node) {
     const name = node.propertyName ?? node.name;
     // If we are discovering a non-analyzable element in the path, abort.
-    if (!ts__default["default"].isStringLiteralLike(name) && !ts__default["default"].isIdentifier(name)) {
+    if (!ts.isStringLiteralLike(name) && !ts.isIdentifier(name)) {
         return null;
     }
     return {
@@ -766,7 +762,7 @@ function resolveBindingElement(node) {
 /** Gets the declaration node of the given binding element. */
 function getBindingElementDeclaration(node) {
     while (true) {
-        if (ts__default["default"].isBindingElement(node.parent.parent)) {
+        if (ts.isBindingElement(node.parent.parent)) {
             node = node.parent.parent;
         }
         else {
@@ -786,10 +782,10 @@ function getBindingElementDeclaration(node) {
  * variable for narrowing. Replacing just the identifier is wrong.
  */
 function traverseAccess(access) {
-    if (ts__default["default"].isPropertyAccessExpression(access.parent) && access.parent.name === access) {
+    if (ts.isPropertyAccessExpression(access.parent) && access.parent.name === access) {
         return access.parent;
     }
-    else if (ts__default["default"].isElementAccessExpression(access.parent) &&
+    else if (ts.isElementAccessExpression(access.parent) &&
         access.parent.argumentExpression === access) {
         return access.parent;
     }
@@ -801,10 +797,10 @@ function traverseAccess(access) {
  * parenthesized expression or `as` expression.
  */
 function unwrapParent(node) {
-    if (ts__default["default"].isParenthesizedExpression(node.parent)) {
+    if (ts.isParenthesizedExpression(node.parent)) {
         return unwrapParent(node.parent);
     }
-    else if (ts__default["default"].isAsExpression(node.parent)) {
+    else if (ts.isAsExpression(node.parent)) {
         return unwrapParent(node.parent);
     }
     return node;
@@ -817,18 +813,18 @@ function unwrapParent(node) {
  * something or not.
  */
 const writeBinaryOperators = [
-    ts__default["default"].SyntaxKind.EqualsToken,
-    ts__default["default"].SyntaxKind.BarBarEqualsToken,
-    ts__default["default"].SyntaxKind.BarEqualsToken,
-    ts__default["default"].SyntaxKind.AmpersandEqualsToken,
-    ts__default["default"].SyntaxKind.AmpersandAmpersandEqualsToken,
-    ts__default["default"].SyntaxKind.SlashEqualsToken,
-    ts__default["default"].SyntaxKind.MinusEqualsToken,
-    ts__default["default"].SyntaxKind.PlusEqualsToken,
-    ts__default["default"].SyntaxKind.CaretEqualsToken,
-    ts__default["default"].SyntaxKind.PercentEqualsToken,
-    ts__default["default"].SyntaxKind.AsteriskEqualsToken,
-    ts__default["default"].SyntaxKind.ExclamationEqualsToken,
+    ts.SyntaxKind.EqualsToken,
+    ts.SyntaxKind.BarBarEqualsToken,
+    ts.SyntaxKind.BarEqualsToken,
+    ts.SyntaxKind.AmpersandEqualsToken,
+    ts.SyntaxKind.AmpersandAmpersandEqualsToken,
+    ts.SyntaxKind.SlashEqualsToken,
+    ts.SyntaxKind.MinusEqualsToken,
+    ts.SyntaxKind.PlusEqualsToken,
+    ts.SyntaxKind.CaretEqualsToken,
+    ts.SyntaxKind.PercentEqualsToken,
+    ts.SyntaxKind.AsteriskEqualsToken,
+    ts.SyntaxKind.ExclamationEqualsToken,
 ];
 
 /**
@@ -849,7 +845,7 @@ function identifyPotentialTypeScriptReference(node, programInfo, checker, knownF
     let target = undefined;
     // Resolve binding elements to their declaration symbol.
     // Commonly inputs are accessed via object expansion. e.g. `const {input} = this;`.
-    if (ts__default["default"].isBindingElement(node.parent)) {
+    if (ts.isBindingElement(node.parent)) {
         // Skip binding elements that are using spread.
         if (node.parent.dotDotDotToken !== undefined) {
             return;
@@ -867,11 +863,11 @@ function identifyPotentialTypeScriptReference(node, programInfo, checker, knownF
         target = checker.getSymbolAtLocation(node);
     }
     noTargetSymbolCheck: if (target === undefined) {
-        if (ts__default["default"].isPropertyAccessExpression(node.parent) && node.parent.name === node) {
+        if (ts.isPropertyAccessExpression(node.parent) && node.parent.name === node) {
             const propAccessSymbol = checker.getSymbolAtLocation(node.parent.expression);
             if (propAccessSymbol !== undefined &&
                 propAccessSymbol.valueDeclaration !== undefined &&
-                ts__default["default"].isVariableDeclaration(propAccessSymbol.valueDeclaration) &&
+                ts.isVariableDeclaration(propAccessSymbol.valueDeclaration) &&
                 propAccessSymbol.valueDeclaration.initializer !== undefined) {
                 target = advisors.debugElComponentInstanceTracker
                     .detect(propAccessSymbol.valueDeclaration.initializer)
@@ -890,7 +886,7 @@ function identifyPotentialTypeScriptReference(node, programInfo, checker, knownF
     }
     const access = unwrapParent(traverseAccess(node));
     const accessParent = access.parent;
-    const isWriteReference = ts__default["default"].isBinaryExpression(accessParent) &&
+    const isWriteReference = ts.isBinaryExpression(accessParent) &&
         accessParent.left === access &&
         writeBinaryOperators.includes(accessParent.operatorToken.kind);
     // track accesses from source files to known fields.
@@ -900,7 +896,7 @@ function identifyPotentialTypeScriptReference(node, programInfo, checker, knownF
             node,
             file: project_paths.projectFile(node.getSourceFile(), programInfo),
             isWrite: isWriteReference,
-            isPartOfElementBinding: ts__default["default"].isBindingElement(node.parent),
+            isPartOfElementBinding: ts.isBindingElement(node.parent),
         },
         target: targetInput,
     });
@@ -935,7 +931,7 @@ function createFindAllSourceFileReferencesVisitor(programInfo, checker, reflecto
         let lastTime = currentTimeInMs();
         // Note: If there is no template type checker and resource loader, we aren't processing
         // an Angular program, and can skip template detection.
-        if (ts__default["default"].isClassDeclaration(node) && templateTypeChecker !== null && resourceLoader !== null) {
+        if (ts.isClassDeclaration(node) && templateTypeChecker !== null && resourceLoader !== null) {
             identifyTemplateReferences(programInfo, node, reflector, checker, evaluator, templateTypeChecker, resourceLoader, programInfo.userOptions, result, knownFields, fieldNamesToConsiderForReferenceLookup);
             perfCounters.template += (currentTimeInMs() - lastTime) / 1000;
             lastTime = currentTimeInMs();
@@ -945,7 +941,7 @@ function createFindAllSourceFileReferencesVisitor(programInfo, checker, reflecto
         }
         lastTime = currentTimeInMs();
         // find references, but do not capture input declarations itself.
-        if (ts__default["default"].isIdentifier(node) &&
+        if (ts.isIdentifier(node) &&
             !(isInputContainerNode(node.parent) && node.parent.name === node)) {
             identifyPotentialTypeScriptReference(node, programInfo, checker, knownFields, result, fieldNamesToConsiderForReferenceLookup, {
                 debugElComponentInstanceTracker,

package/schematics/bundles/{index-6675d6bc.js → index-vGJcp5M7.js}

@@ -1,15 +1,15 @@
 'use strict';
 /**
- * @license Angular v20.0.0-next.0
- * (c) 2010-2024 Google LLC. https://angular.io/
+ * @license Angular v20.0.0-next.2
+ * (c) 2010-2025 Google LLC. https://angular.io/
  * License: MIT
  */
 'use strict';
 
 require('os');
 require('typescript');
-var checker = require('./checker-cf6f7980.js');
-require('./program-362689f0.js');
+var checker = require('./checker-DF8ZaFW5.js');
+require('./program-BZk27Ndu.js');
 require('path');
 
 /**
@@ -17,7 +17,7 @@ require('path');
  * @description
  * Entry point for all public APIs of the compiler-cli package.
  */
-new checker.Version('20.0.0-next.0');
+new checker.Version('20.0.0-next.2');
 
 var LogLevel;
 (function (LogLevel) {

package/schematics/bundles/inject-flags.js

@@ -0,0 +1,181 @@
+'use strict';
+/**
+ * @license Angular v20.0.0-next.2
+ * (c) 2010-2025 Google LLC. https://angular.io/
+ * License: MIT
+ */
+'use strict';
+
+var schematics = require('@angular-devkit/schematics');
+var project_tsconfig_paths = require('./project_tsconfig_paths-CDVxT6Ov.js');
+var project_paths = require('./project_paths-Jtbi76Bs.js');
+require('os');
+var ts = require('typescript');
+var checker = require('./checker-DF8ZaFW5.js');
+require('./program-BZk27Ndu.js');
+require('path');
+var apply_import_manager = require('./apply_import_manager-CyRT0UvU.js');
+var imports = require('./imports-CIX-JgAN.js');
+require('@angular-devkit/core');
+require('node:path/posix');
+require('fs');
+require('module');
+require('url');
+
+/** Mapping between `InjectFlag` enum members to their object literal equvalients. */
+const FLAGS_TO_FIELDS = {
+    'Default': 'default',
+    'Host': 'host',
+    'Optional': 'optional',
+    'Self': 'self',
+    'SkipSelf': 'skipSelf',
+};
+/** Migration that replaces `InjectFlags` usages with object literals. */
+class InjectFlagsMigration extends project_paths.TsurgeFunnelMigration {
+    async analyze(info) {
+        const locations = {};
+        const importRemovals = {};
+        for (const sourceFile of info.sourceFiles) {
+            const specifier = imports.getImportSpecifier(sourceFile, '@angular/core', 'InjectFlags');
+            if (specifier === null) {
+                continue;
+            }
+            const file = project_paths.projectFile(sourceFile, info);
+            const importManager = new checker.ImportManager();
+            const importReplacements = [];
+            // Always remove the `InjectFlags` since it has been removed from Angular.
+            // Note that it be better to do this inside of `migrate`, but we don't have AST access there.
+            importManager.removeImport(sourceFile, 'InjectFlags', '@angular/core');
+            apply_import_manager.applyImportManagerChanges(importManager, importReplacements, [sourceFile], info);
+            importRemovals[file.id] = importReplacements;
+            sourceFile.forEachChild(function walk(node) {
+                if (
+                // Note: we don't use the type checker for matching here, because
+                // the `InjectFlags` will be removed which can break the lookup.
+                ts.isPropertyAccessExpression(node) &&
+                    ts.isIdentifier(node.expression) &&
+                    node.expression.text === specifier.name.text &&
+                    FLAGS_TO_FIELDS.hasOwnProperty(node.name.text)) {
+                    const root = getInjectFlagsRootExpression(node);
+                    if (root !== null) {
+                        const flagName = FLAGS_TO_FIELDS[node.name.text];
+                        const id = getNodeID(file, root);
+                        locations[id] ??= { file, flags: [], position: root.getStart(), end: root.getEnd() };
+                        // The flags can't be a set here, because they need to be serializable.
+                        if (!locations[id].flags.includes(flagName)) {
+                            locations[id].flags.push(flagName);
+                        }
+                    }
+                }
+                else {
+                    node.forEachChild(walk);
+                }
+            });
+        }
+        return project_paths.confirmAsSerializable({ locations, importRemovals });
+    }
+    async migrate(globalData) {
+        const replacements = [];
+        for (const removals of Object.values(globalData.importRemovals)) {
+            replacements.push(...removals);
+        }
+        for (const { file, position, end, flags } of Object.values(globalData.locations)) {
+            // Declare a property for each flag, except for `default` which does not have a flag.
+            const properties = flags.filter((flag) => flag !== 'default').map((flag) => `${flag}: true`);
+            const toInsert = properties.length ? `{ ${properties.join(', ')} }` : '{}';
+            replacements.push(new project_paths.Replacement(file, new project_paths.TextUpdate({ position, end, toInsert })));
+        }
+        return project_paths.confirmAsSerializable({ replacements });
+    }
+    async combine(unitA, unitB) {
+        return project_paths.confirmAsSerializable({
+            locations: {
+                ...unitA.locations,
+                ...unitB.locations,
+            },
+            importRemovals: {
+                ...unitA.importRemovals,
+                ...unitB.importRemovals,
+            },
+        });
+    }
+    async globalMeta(combinedData) {
+        return project_paths.confirmAsSerializable(combinedData);
+    }
+    async stats() {
+        return { counters: {} };
+    }
+}
+/** Gets an ID that can be used to look up a node based on its location. */
+function getNodeID(file, node) {
+    return `${file.id}/${node.getStart()}/${node.getWidth()}`;
+}
+/**
+ * Gets the root expression of an `InjectFlags` usage. For example given `InjectFlags.Optional`.
+ * in `InjectFlags.Host | InjectFlags.Optional | InjectFlags.SkipSelf`, the function will return
+ * the top-level binary expression.
+ * @param start Node from which to start searching.
+ */
+function getInjectFlagsRootExpression(start) {
+    let current = start;
+    let parent = current?.parent;
+    while (parent && (ts.isBinaryExpression(parent) || ts.isParenthesizedExpression(parent))) {
+        current = parent;
+        parent = current.parent;
+    }
+    // Only allow allow expressions that are call parameters, variable initializer or parameter
+    // initializers which are the only officially supported usages of `InjectFlags`.
+    if (current &&
+        parent &&
+        ((ts.isCallExpression(parent) && parent.arguments.includes(current)) ||
+            (ts.isVariableDeclaration(parent) && parent.initializer === current) ||
+            (ts.isParameter(parent) && parent.initializer === current))) {
+        return current;
+    }
+    return null;
+}
+
+function migrate() {
+    return async (tree) => {
+        const { buildPaths, testPaths } = await project_tsconfig_paths.getProjectTsConfigPaths(tree);
+        if (!buildPaths.length && !testPaths.length) {
+            throw new schematics.SchematicsException('Could not find any tsconfig file. Cannot replace `InjectFlags` usages.');
+        }
+        const fs = new project_paths.DevkitMigrationFilesystem(tree);
+        checker.setFileSystem(fs);
+        const migration = new InjectFlagsMigration();
+        const unitResults = [];
+        const programInfos = [...buildPaths, ...testPaths].map((tsconfigPath) => {
+            const baseInfo = migration.createProgram(tsconfigPath, fs);
+            const info = migration.prepareProgram(baseInfo);
+            return { info, tsconfigPath };
+        });
+        for (const { info } of programInfos) {
+            unitResults.push(await migration.analyze(info));
+        }
+        const combined = await project_paths.synchronouslyCombineUnitData(migration, unitResults);
+        if (combined === null) {
+            return;
+        }
+        const globalMeta = await migration.globalMeta(combined);
+        const replacementsPerFile = new Map();
+        const { replacements } = await migration.migrate(globalMeta);
+        const changesPerFile = project_paths.groupReplacementsByFile(replacements);
+        for (const [file, changes] of changesPerFile) {
+            if (!replacementsPerFile.has(file)) {
+                replacementsPerFile.set(file, changes);
+            }
+        }
+        for (const [file, changes] of replacementsPerFile) {
+            const recorder = tree.beginUpdate(file);
+            for (const c of changes) {
+                recorder
+                    .remove(c.data.position, c.data.end - c.data.position)
+                    .insertRight(c.data.position, c.data.toInsert);
+            }
+            tree.commitUpdate(recorder);
+        }
+    };
+}
+
+exports.migrate = migrate;