@angular/core 20.0.0-next.1 → 20.0.0-next.3

package/schematics/bundles/{nodes-7758dbf6.js → nodes-B16H9JUd.js}

@@ -1,6 +1,6 @@
 'use strict';
 /**
- * @license Angular v20.0.0-next.1
+ * @license Angular v20.0.0-next.3
  * (c) 2010-2025 Google LLC. https://angular.io/
  * License: MIT
  */
@@ -8,14 +8,10 @@
 
 var ts = require('typescript');
 
-function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
-
-var ts__default = /*#__PURE__*/_interopDefaultLegacy(ts);
-
 /** Find the closest parent node of a particular kind. */
 function closestNode(node, predicate) {
     let current = node.parent;
-    while (current && !ts__default["default"].isSourceFile(current)) {
+    while (current && !ts.isSourceFile(current)) {
         if (predicate(current)) {
             return current;
         }

package/schematics/bundles/output-migration.js

@@ -1,43 +1,37 @@
 'use strict';
 /**
- * @license Angular v20.0.0-next.1
+ * @license Angular v20.0.0-next.3
  * (c) 2010-2025 Google LLC. https://angular.io/
  * License: MIT
  */
 'use strict';
 
-Object.defineProperty(exports, '__esModule', { value: true });
-
-var schematics = require('@angular-devkit/schematics');
-var project_tsconfig_paths = require('./project_tsconfig_paths-b558633b.js');
-var project_paths = require('./project_paths-17dc204d.js');
-require('os');
 var ts = require('typescript');
-var checker = require('./checker-af521da6.js');
-var program = require('./program-a449f9bf.js');
+require('os');
+var checker = require('./checker-BHb19MHt.js');
+var index$1 = require('./index-I8VbxQcO.js');
 require('path');
-var apply_import_manager = require('./apply_import_manager-e2a7fe5b.js');
-var index = require('./index-1bef3025.js');
+var run_in_devkit = require('./run_in_devkit-C0JPtK2u.js');
+var apply_import_manager = require('./apply_import_manager-BXQEjo09.js');
+var index = require('./index-BL9kAIe5.js');
 require('@angular-devkit/core');
 require('node:path/posix');
 require('fs');
 require('module');
 require('url');
-
-function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
-
-var ts__default = /*#__PURE__*/_interopDefaultLegacy(ts);
+require('@angular-devkit/schematics');
+require('./project_tsconfig_paths-CDVxT6Ov.js');
 
 function isOutputDeclarationEligibleForMigration(node) {
     return (node.initializer !== undefined &&
-        ts__default["default"].isNewExpression(node.initializer) &&
-        ts__default["default"].isIdentifier(node.initializer.expression) &&
+        ts.isNewExpression(node.initializer) &&
+        ts.isIdentifier(node.initializer.expression) &&
         node.initializer.expression.text === 'EventEmitter');
 }
 function isPotentialOutputCallUsage(node, name) {
-    if (ts__default["default"].isCallExpression(node) &&
-        ts__default["default"].isPropertyAccessExpression(node.expression) &&
-        ts__default["default"].isIdentifier(node.expression.name)) {
+    if (ts.isCallExpression(node) &&
+        ts.isPropertyAccessExpression(node.expression) &&
+        ts.isIdentifier(node.expression.name)) {
         return node.expression?.name.text === name;
     }
     else {
@@ -68,8 +62,8 @@ function isTargetOutputDeclaration(node, checker, reflector, dtsReader) {
 function isOutputDeclaration(node, reflector, dtsReader) {
     // `.d.ts` file, so we check the `static ecmp` metadata on the `declare class`.
     if (node.getSourceFile().isDeclarationFile) {
-        if (!ts__default["default"].isIdentifier(node.name) ||
-            !ts__default["default"].isClassDeclaration(node.parent) ||
+        if (!ts.isIdentifier(node.name) ||
+            !ts.isClassDeclaration(node.parent) ||
             node.parent.name === undefined) {
             return false;
         }
@@ -82,7 +76,7 @@ function isOutputDeclaration(node, reflector, dtsReader) {
 }
 function getTargetPropertyDeclaration(targetSymbol) {
     const valDeclaration = targetSymbol.valueDeclaration;
-    if (valDeclaration !== undefined && ts__default["default"].isPropertyDeclaration(valDeclaration)) {
+    if (valDeclaration !== undefined && ts.isPropertyDeclaration(valDeclaration)) {
         return valDeclaration;
     }
     return null;
@@ -96,12 +90,12 @@ function getOutputDecorator(node, reflector) {
 // THINK: this utility + type is not specific to @Output, really, maybe move it to tsurge?
 /** Computes an unique ID for a given Angular `@Output` property. */
 function getUniqueIdForProperty(info, prop) {
-    const { id } = project_paths.projectFile(prop.getSourceFile(), info);
+    const { id } = run_in_devkit.projectFile(prop.getSourceFile(), info);
     id.replace(/\.d\.ts$/, '.ts');
     return `${id}@@${prop.parent.name ?? 'unknown-class'}@@${prop.name.getText()}`;
 }
 function isTestRunnerImport(node) {
-    if (ts__default["default"].isImportDeclaration(node)) {
+    if (ts.isImportDeclaration(node)) {
         const moduleSpecifier = node.moduleSpecifier.getText();
         return moduleSpecifier.includes('jasmine') || moduleSpecifier.includes('catalyst');
     }
@@ -147,27 +141,27 @@ function checkNonTsReferenceCallsField(ref, fieldName) {
     return potentialRead;
 }
 
-const printer = ts__default["default"].createPrinter();
+const printer = ts.createPrinter();
 function calculateDeclarationReplacement(info, node, aliasParam) {
     const sf = node.getSourceFile();
-    const payloadTypes = node.initializer !== undefined && ts__default["default"].isNewExpression(node.initializer)
+    const payloadTypes = node.initializer !== undefined && ts.isNewExpression(node.initializer)
         ? node.initializer?.typeArguments
         : undefined;
-    const outputCall = ts__default["default"].factory.createCallExpression(ts__default["default"].factory.createIdentifier('output'), payloadTypes, aliasParam !== undefined
+    const outputCall = ts.factory.createCallExpression(ts.factory.createIdentifier('output'), payloadTypes, aliasParam !== undefined
         ? [
-            ts__default["default"].factory.createObjectLiteralExpression([
-                ts__default["default"].factory.createPropertyAssignment('alias', ts__default["default"].factory.createStringLiteral(aliasParam, true)),
+            ts.factory.createObjectLiteralExpression([
+                ts.factory.createPropertyAssignment('alias', ts.factory.createStringLiteral(aliasParam, true)),
             ], false),
         ]
         : []);
-    const existingModifiers = (node.modifiers ?? []).filter((modifier) => !ts__default["default"].isDecorator(modifier) && modifier.kind !== ts__default["default"].SyntaxKind.ReadonlyKeyword);
-    const updatedOutputDeclaration = ts__default["default"].factory.createPropertyDeclaration(
+    const existingModifiers = (node.modifiers ?? []).filter((modifier) => !ts.isDecorator(modifier) && modifier.kind !== ts.SyntaxKind.ReadonlyKeyword);
+    const updatedOutputDeclaration = ts.factory.createPropertyDeclaration(
     // Think: this logic of dealing with modifiers is applicable to all signal-based migrations
-    ts__default["default"].factory.createNodeArray([
+    ts.factory.createNodeArray([
         ...existingModifiers,
-        ts__default["default"].factory.createModifier(ts__default["default"].SyntaxKind.ReadonlyKeyword),
+        ts.factory.createModifier(ts.SyntaxKind.ReadonlyKeyword),
     ]), node.name, undefined, undefined, outputCall);
-    return prepareTextReplacementForNode(info, node, printer.printNode(ts__default["default"].EmitHint.Unspecified, updatedOutputDeclaration, sf));
+    return prepareTextReplacementForNode(info, node, printer.printNode(ts.EmitHint.Unspecified, updatedOutputDeclaration, sf));
 }
 function calculateImportReplacements(info, sourceFiles) {
     const importReplacements = {};
@@ -175,7 +169,7 @@ function calculateImportReplacements(info, sourceFiles) {
         const importManager = new checker.ImportManager();
         const addOnly = [];
         const addRemove = [];
-        const file = project_paths.projectFile(sf, info);
+        const file = run_in_devkit.projectFile(sf, info);
         importManager.addImport({
             requestedFile: sf,
             exportModuleSpecifier: '@angular/core',
@@ -205,7 +199,7 @@ function calculateCompleteCallReplacement(info, node) {
     return prepareTextReplacementForNode(info, node, '', node.getFullStart());
 }
 function calculatePipeCallReplacement(info, node) {
-    if (ts__default["default"].isPropertyAccessExpression(node.expression)) {
+    if (ts.isPropertyAccessExpression(node.expression)) {
         const sf = node.getSourceFile();
         const importManager = new checker.ImportManager();
         const outputToObservableIdent = importManager.addImport({
@@ -213,13 +207,13 @@ function calculatePipeCallReplacement(info, node) {
             exportModuleSpecifier: '@angular/core/rxjs-interop',
             exportSymbolName: 'outputToObservable',
         });
-        const toObsCallExp = ts__default["default"].factory.createCallExpression(outputToObservableIdent, undefined, [
+        const toObsCallExp = ts.factory.createCallExpression(outputToObservableIdent, undefined, [
             node.expression.expression,
         ]);
-        const pipePropAccessExp = ts__default["default"].factory.updatePropertyAccessExpression(node.expression, toObsCallExp, node.expression.name);
-        const pipeCallExp = ts__default["default"].factory.updateCallExpression(node, pipePropAccessExp, [], node.arguments);
+        const pipePropAccessExp = ts.factory.updatePropertyAccessExpression(node.expression, toObsCallExp, node.expression.name);
+        const pipeCallExp = ts.factory.updateCallExpression(node, pipePropAccessExp, [], node.arguments);
         const replacements = [
-            prepareTextReplacementForNode(info, node, printer.printNode(ts__default["default"].EmitHint.Unspecified, pipeCallExp, sf)),
+            prepareTextReplacementForNode(info, node, printer.printNode(ts.EmitHint.Unspecified, pipeCallExp, sf)),
         ];
         apply_import_manager.applyImportManagerChanges(importManager, replacements, [sf], info);
         return replacements;
@@ -231,36 +225,36 @@ function calculatePipeCallReplacement(info, node) {
 }
 function prepareTextReplacementForNode(info, node, replacement, start) {
     const sf = node.getSourceFile();
-    return new project_paths.Replacement(project_paths.projectFile(sf, info), new project_paths.TextUpdate({
+    return new run_in_devkit.Replacement(run_in_devkit.projectFile(sf, info), new run_in_devkit.TextUpdate({
         position: start ?? node.getStart(),
         end: node.getEnd(),
         toInsert: replacement,
     }));
 }
 function prepareTextReplacement(file, replacement, start, end) {
-    return new project_paths.Replacement(file, new project_paths.TextUpdate({
+    return new run_in_devkit.Replacement(file, new run_in_devkit.TextUpdate({
         position: start,
         end: end,
         toInsert: replacement,
     }));
 }
 
-class OutputMigration extends project_paths.TsurgeFunnelMigration {
+class OutputMigration extends run_in_devkit.TsurgeFunnelMigration {
     config;
     constructor(config = {}) {
         super();
         this.config = config;
     }
     async analyze(info) {
-        const { sourceFiles, program: program$1 } = info;
+        const { sourceFiles, program } = info;
         const outputFieldReplacements = {};
         const problematicUsages = {};
         let problematicDeclarationCount = 0;
         const filesWithOutputDeclarations = new Set();
-        const checker$1 = program$1.getTypeChecker();
+        const checker$1 = program.getTypeChecker();
         const reflector = new checker.TypeScriptReflectionHost(checker$1);
-        const dtsReader = new program.DtsMetadataReader(checker$1, reflector);
-        const evaluator = new program.PartialEvaluator(reflector, checker$1, null);
+        const dtsReader = new index$1.DtsMetadataReader(checker$1, reflector);
+        const evaluator = new index$1.PartialEvaluator(reflector, checker$1, null);
         const resourceLoader = info.ngCompiler?.['resourceManager'] ?? null;
         // Pre-analyze the program and get access to the template type checker.
         // If we are processing a non-Angular target, there is no template info.
@@ -288,7 +282,7 @@ class OutputMigration extends project_paths.TsurgeFunnelMigration {
         let isTestFile = false;
         const outputMigrationVisitor = (node) => {
             // detect output declarations
-            if (ts__default["default"].isPropertyDeclaration(node)) {
+            if (ts.isPropertyDeclaration(node)) {
                 const outputDecorator = getOutputDecorator(node, reflector);
                 if (outputDecorator !== null) {
                     if (isOutputDeclarationEligibleForMigration(node)) {
@@ -296,7 +290,7 @@ class OutputMigration extends project_paths.TsurgeFunnelMigration {
                             id: getUniqueIdForProperty(info, node),
                             aliasParam: outputDecorator.args?.at(0),
                         };
-                        const outputFile = project_paths.projectFile(node.getSourceFile(), info);
+                        const outputFile = run_in_devkit.projectFile(node.getSourceFile(), info);
                         if (this.config.shouldMigrate === undefined ||
                             this.config.shouldMigrate({
                                 key: outputDef.id,
@@ -320,21 +314,21 @@ class OutputMigration extends project_paths.TsurgeFunnelMigration {
                 }
             }
             // detect .next usages that should be migrated to .emit
-            if (isPotentialNextCallUsage(node) && ts__default["default"].isPropertyAccessExpression(node.expression)) {
+            if (isPotentialNextCallUsage(node) && ts.isPropertyAccessExpression(node.expression)) {
                 const propertyDeclaration = isTargetOutputDeclaration(node.expression.expression, checker$1, reflector, dtsReader);
                 if (propertyDeclaration !== null) {
                     const id = getUniqueIdForProperty(info, propertyDeclaration);
-                    const outputFile = project_paths.projectFile(node.getSourceFile(), info);
+                    const outputFile = run_in_devkit.projectFile(node.getSourceFile(), info);
                     addOutputReplacement(outputFieldReplacements, id, outputFile, calculateNextFnReplacement(info, node.expression.name));
                 }
             }
             // detect .complete usages that should be removed
-            if (isPotentialCompleteCallUsage(node) && ts__default["default"].isPropertyAccessExpression(node.expression)) {
+            if (isPotentialCompleteCallUsage(node) && ts.isPropertyAccessExpression(node.expression)) {
                 const propertyDeclaration = isTargetOutputDeclaration(node.expression.expression, checker$1, reflector, dtsReader);
                 if (propertyDeclaration !== null) {
                     const id = getUniqueIdForProperty(info, propertyDeclaration);
-                    const outputFile = project_paths.projectFile(node.getSourceFile(), info);
-                    if (ts__default["default"].isExpressionStatement(node.parent)) {
+                    const outputFile = run_in_devkit.projectFile(node.getSourceFile(), info);
+                    if (ts.isExpressionStatement(node.parent)) {
                         addOutputReplacement(outputFieldReplacements, id, outputFile, calculateCompleteCallReplacement(info, node.parent));
                     }
                     else {
@@ -347,12 +341,12 @@ class OutputMigration extends project_paths.TsurgeFunnelMigration {
                 isTestFile = true;
             }
             // detect unsafe access of the output property
-            if (isPotentialPipeCallUsage(node) && ts__default["default"].isPropertyAccessExpression(node.expression)) {
+            if (isPotentialPipeCallUsage(node) && ts.isPropertyAccessExpression(node.expression)) {
                 const propertyDeclaration = isTargetOutputDeclaration(node.expression.expression, checker$1, reflector, dtsReader);
                 if (propertyDeclaration !== null) {
                     const id = getUniqueIdForProperty(info, propertyDeclaration);
                     if (isTestFile) {
-                        const outputFile = project_paths.projectFile(node.getSourceFile(), info);
+                        const outputFile = run_in_devkit.projectFile(node.getSourceFile(), info);
                         addOutputReplacement(outputFieldReplacements, id, outputFile, ...calculatePipeCallReplacement(info, node));
                     }
                     else {
@@ -360,12 +354,12 @@ class OutputMigration extends project_paths.TsurgeFunnelMigration {
                     }
                 }
             }
-            ts__default["default"].forEachChild(node, outputMigrationVisitor);
+            ts.forEachChild(node, outputMigrationVisitor);
         };
         // calculate output migration replacements
         for (const sf of sourceFiles) {
             isTestFile = false;
-            ts__default["default"].forEachChild(sf, outputMigrationVisitor);
+            ts.forEachChild(sf, outputMigrationVisitor);
         }
         // take care of the references in templates and host bindings
         const referenceResult = { references: [] };
@@ -373,7 +367,7 @@ class OutputMigration extends project_paths.TsurgeFunnelMigration {
         referenceResult);
         // calculate template / host binding replacements
         for (const sf of sourceFiles) {
-            ts__default["default"].forEachChild(sf, templateHostRefVisitor);
+            ts.forEachChild(sf, templateHostRefVisitor);
         }
         for (const ref of referenceResult.references) {
             // detect .next usages that should be migrated to .emit in template and host binding expressions
@@ -396,7 +390,7 @@ class OutputMigration extends project_paths.TsurgeFunnelMigration {
         }
         // calculate import replacements but do so only for files that have output declarations
         const importReplacements = calculateImportReplacements(info, filesWithOutputDeclarations);
-        return project_paths.confirmAsSerializable({
+        return run_in_devkit.confirmAsSerializable({
             problematicDeclarationCount,
             outputFields: outputFieldReplacements,
             importReplacements,
@@ -426,7 +420,7 @@ class OutputMigration extends project_paths.TsurgeFunnelMigration {
                 problematicUsages[declId] = unit.problematicUsages[declId];
             }
         }
-        return project_paths.confirmAsSerializable({
+        return run_in_devkit.confirmAsSerializable({
             problematicDeclarationCount,
             outputFields,
             importReplacements,
@@ -448,7 +442,7 @@ class OutputMigration extends project_paths.TsurgeFunnelMigration {
             }
         }
         // Noop here as we don't have any form of special global metadata.
-        return project_paths.confirmAsSerializable(combinedData);
+        return run_in_devkit.confirmAsSerializable(combinedData);
     }
     async stats(globalMetadata) {
         const detectedOutputs = new Set(Object.keys(globalMetadata.outputFields)).size +
@@ -507,73 +501,45 @@ function addOutputReplacement(outputFieldReplacements, outputId, file, ...replac
 
 function migrate(options) {
     return async (tree, context) => {
-        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 run output migration.');
-        }
-        const fs = new project_paths.DevkitMigrationFilesystem(tree);
-        checker.setFileSystem(fs);
-        const migration = new OutputMigration({
-            shouldMigrate: (_, file) => {
-                return (file.rootRelativePath.startsWith(fs.normalize(options.path)) &&
-                    !/(^|\/)node_modules\//.test(file.rootRelativePath));
+        await run_in_devkit.runMigrationInDevkit({
+            tree,
+            getMigration: (fs) => new OutputMigration({
+                shouldMigrate: (_, file) => {
+                    return (file.rootRelativePath.startsWith(fs.normalize(options.path)) &&
+                        !/(^|\/)node_modules\//.test(file.rootRelativePath));
+                },
+            }),
+            beforeProgramCreation: (tsconfigPath) => {
+                context.logger.info(`Preparing analysis for: ${tsconfigPath}...`);
             },
-        });
-        const analysisPath = fs.resolve(options.analysisDir);
-        const unitResults = [];
-        const programInfos = [...buildPaths, ...testPaths].map((tsconfigPath) => {
-            context.logger.info(`Preparing analysis for: ${tsconfigPath}..`);
-            const baseInfo = migration.createProgram(tsconfigPath, fs);
-            const info = migration.prepareProgram(baseInfo);
-            // Support restricting the analysis to subfolders for larger projects.
-            if (analysisPath !== '/') {
-                info.sourceFiles = info.sourceFiles.filter((sf) => sf.fileName.startsWith(analysisPath));
-                info.fullProgramSourceFiles = info.fullProgramSourceFiles.filter((sf) => sf.fileName.startsWith(analysisPath));
-            }
-            return { info, tsconfigPath };
-        });
-        // Analyze phase. Treat all projects as compilation units as
-        // this allows us to support references between those.
-        for (const { info, tsconfigPath } of programInfos) {
-            context.logger.info(`Scanning for outputs: ${tsconfigPath}..`);
-            unitResults.push(await migration.analyze(info));
-        }
-        context.logger.info(``);
-        context.logger.info(`Processing analysis data between targets..`);
-        context.logger.info(``);
-        const combined = await project_paths.synchronouslyCombineUnitData(migration, unitResults);
-        if (combined === null) {
-            context.logger.error('Migration failed unexpectedly with no analysis data');
-            return;
-        }
-        const globalMeta = await migration.globalMeta(combined);
-        const replacementsPerFile = new Map();
-        for (const { info, tsconfigPath } of programInfos) {
-            context.logger.info(`Migrating: ${tsconfigPath}..`);
-            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);
+            afterProgramCreation: (info, fs) => {
+                const analysisPath = fs.resolve(options.analysisDir);
+                // Support restricting the analysis to subfolders for larger projects.
+                if (analysisPath !== '/') {
+                    info.sourceFiles = info.sourceFiles.filter((sf) => sf.fileName.startsWith(analysisPath));
+                    info.fullProgramSourceFiles = info.fullProgramSourceFiles.filter((sf) => sf.fileName.startsWith(analysisPath));
                 }
-            }
-        }
-        context.logger.info(`Applying 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)
-                    .insertLeft(c.data.position, c.data.toInsert);
-            }
-            tree.commitUpdate(recorder);
-        }
-        const { counters: { detectedOutputs, problematicOutputs, successRate }, } = await migration.stats(globalMeta);
-        const migratedOutputs = detectedOutputs - problematicOutputs;
-        const successRatePercent = (successRate * 100).toFixed(2);
-        context.logger.info('');
-        context.logger.info(`Successfully migrated to outputs as functions 🎉`);
-        context.logger.info(`  -> Migrated ${migratedOutputs} out of ${detectedOutputs} detected outputs (${successRatePercent} %).`);
+            },
+            beforeUnitAnalysis: (tsconfigPath) => {
+                context.logger.info(`Scanning for outputs: ${tsconfigPath}...`);
+            },
+            afterAllAnalyzed: () => {
+                context.logger.info(``);
+                context.logger.info(`Processing analysis data between targets...`);
+                context.logger.info(``);
+            },
+            afterAnalysisFailure: () => {
+                context.logger.error('Migration failed unexpectedly with no analysis data');
+            },
+            whenDone: ({ counters }) => {
+                const { detectedOutputs, problematicOutputs, successRate } = counters;
+                const migratedOutputs = detectedOutputs - problematicOutputs;
+                const successRatePercent = (successRate * 100).toFixed(2);
+                context.logger.info('');
+                context.logger.info(`Successfully migrated to outputs as functions 🎉`);
+                context.logger.info(`  -> Migrated ${migratedOutputs} out of ${detectedOutputs} detected outputs (${successRatePercent} %).`);
+            },
+        });
     };
 }
 

package/schematics/bundles/{project_tsconfig_paths-b558633b.js → project_tsconfig_paths-CDVxT6Ov.js}

@@ -1,6 +1,6 @@
 'use strict';
 /**
- * @license Angular v20.0.0-next.1
+ * @license Angular v20.0.0-next.3
  * (c) 2010-2025 Google LLC. https://angular.io/
  * License: MIT
  */

package/schematics/bundles/{property_name-ac18447e.js → property_name-BBwFuqMe.js}

@@ -1,6 +1,6 @@
 'use strict';
 /**
- * @license Angular v20.0.0-next.1
+ * @license Angular v20.0.0-next.3
  * (c) 2010-2025 Google LLC. https://angular.io/
  * License: MIT
  */
@@ -8,23 +8,19 @@
 
 var ts = require('typescript');
 
-function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
-
-var ts__default = /*#__PURE__*/_interopDefaultLegacy(ts);
-
 /**
  * Gets the text of the given property name. Returns null if the property
  * name couldn't be determined statically.
  */
 function getPropertyNameText(node) {
-    if (ts__default["default"].isIdentifier(node) || ts__default["default"].isStringLiteralLike(node)) {
+    if (ts.isIdentifier(node) || ts.isStringLiteralLike(node)) {
         return node.text;
     }
     return null;
 }
 /** Finds a property with a specific name in an object literal expression. */
 function findLiteralProperty(literal, name) {
-    return literal.properties.find((prop) => prop.name && ts__default["default"].isIdentifier(prop.name) && prop.name.text === name);
+    return literal.properties.find((prop) => prop.name && ts.isIdentifier(prop.name) && prop.name.text === name);
 }
 
 exports.findLiteralProperty = findLiteralProperty;