| "use strict"; |
| Object.defineProperty(exports, "__esModule", { value: true }); |
| const util_1 = require("./util"); |
| const ts = require("typescript"); |
| var DeclarationDomain; |
| (function (DeclarationDomain) { |
| DeclarationDomain[DeclarationDomain["Namespace"] = 1] = "Namespace"; |
| DeclarationDomain[DeclarationDomain["Type"] = 2] = "Type"; |
| DeclarationDomain[DeclarationDomain["Value"] = 4] = "Value"; |
| DeclarationDomain[DeclarationDomain["Import"] = 8] = "Import"; |
| DeclarationDomain[DeclarationDomain["Any"] = 7] = "Any"; |
| })(DeclarationDomain = exports.DeclarationDomain || (exports.DeclarationDomain = {})); |
| var UsageDomain; |
| (function (UsageDomain) { |
| UsageDomain[UsageDomain["Namespace"] = 1] = "Namespace"; |
| UsageDomain[UsageDomain["Type"] = 2] = "Type"; |
| UsageDomain[UsageDomain["Value"] = 4] = "Value"; |
| UsageDomain[UsageDomain["ValueOrNamespace"] = 5] = "ValueOrNamespace"; |
| UsageDomain[UsageDomain["Any"] = 7] = "Any"; |
| UsageDomain[UsageDomain["TypeQuery"] = 8] = "TypeQuery"; |
| })(UsageDomain = exports.UsageDomain || (exports.UsageDomain = {})); |
| function getUsageDomain(node) { |
| const parent = node.parent; |
| switch (parent.kind) { |
| case ts.SyntaxKind.TypeReference: |
| return node.originalKeywordKind !== ts.SyntaxKind.ConstKeyword ? 2 : undefined; |
| case ts.SyntaxKind.ExpressionWithTypeArguments: |
| return parent.parent.token === ts.SyntaxKind.ImplementsKeyword || |
| parent.parent.parent.kind === ts.SyntaxKind.InterfaceDeclaration |
| ? 2 |
| : 4; |
| case ts.SyntaxKind.TypeQuery: |
| return 5 | 8; |
| case ts.SyntaxKind.QualifiedName: |
| if (parent.left === node) { |
| if (getEntityNameParent(parent).kind === ts.SyntaxKind.TypeQuery) |
| return 1 | 8; |
| return 1; |
| } |
| break; |
| case ts.SyntaxKind.ExportSpecifier: |
| if (parent.propertyName === undefined || |
| parent.propertyName === node) |
| return 7; |
| break; |
| case ts.SyntaxKind.ExportAssignment: |
| return 7; |
| case ts.SyntaxKind.BindingElement: |
| if (parent.initializer === node) |
| return 5; |
| break; |
| case ts.SyntaxKind.Parameter: |
| case ts.SyntaxKind.EnumMember: |
| case ts.SyntaxKind.PropertyDeclaration: |
| case ts.SyntaxKind.VariableDeclaration: |
| case ts.SyntaxKind.PropertyAssignment: |
| case ts.SyntaxKind.PropertyAccessExpression: |
| case ts.SyntaxKind.ImportEqualsDeclaration: |
| if (parent.name !== node) |
| return 5; |
| break; |
| case ts.SyntaxKind.JsxAttribute: |
| case ts.SyntaxKind.FunctionDeclaration: |
| case ts.SyntaxKind.FunctionExpression: |
| case ts.SyntaxKind.NamespaceImport: |
| case ts.SyntaxKind.ClassDeclaration: |
| case ts.SyntaxKind.ClassExpression: |
| case ts.SyntaxKind.ModuleDeclaration: |
| case ts.SyntaxKind.MethodDeclaration: |
| case ts.SyntaxKind.EnumDeclaration: |
| case ts.SyntaxKind.GetAccessor: |
| case ts.SyntaxKind.SetAccessor: |
| case ts.SyntaxKind.LabeledStatement: |
| case ts.SyntaxKind.BreakStatement: |
| case ts.SyntaxKind.ContinueStatement: |
| case ts.SyntaxKind.ImportClause: |
| case ts.SyntaxKind.ImportSpecifier: |
| case ts.SyntaxKind.TypePredicate: |
| case ts.SyntaxKind.MethodSignature: |
| case ts.SyntaxKind.PropertySignature: |
| case ts.SyntaxKind.NamespaceExportDeclaration: |
| case ts.SyntaxKind.InterfaceDeclaration: |
| case ts.SyntaxKind.TypeAliasDeclaration: |
| case ts.SyntaxKind.TypeParameter: |
| break; |
| default: |
| return 5; |
| } |
| } |
| exports.getUsageDomain = getUsageDomain; |
| function getDeclarationDomain(node) { |
| switch (node.parent.kind) { |
| case ts.SyntaxKind.TypeParameter: |
| case ts.SyntaxKind.InterfaceDeclaration: |
| case ts.SyntaxKind.TypeAliasDeclaration: |
| return 2; |
| case ts.SyntaxKind.ClassDeclaration: |
| case ts.SyntaxKind.ClassExpression: |
| return 2 | 4; |
| case ts.SyntaxKind.EnumDeclaration: |
| return 7; |
| case ts.SyntaxKind.NamespaceImport: |
| case ts.SyntaxKind.ImportClause: |
| return 7 | 8; |
| case ts.SyntaxKind.ImportEqualsDeclaration: |
| case ts.SyntaxKind.ImportSpecifier: |
| return node.parent.name === node |
| ? 7 | 8 |
| : undefined; |
| case ts.SyntaxKind.ModuleDeclaration: |
| return 1; |
| case ts.SyntaxKind.Parameter: |
| if (node.parent.parent.kind === ts.SyntaxKind.IndexSignature || node.originalKeywordKind === ts.SyntaxKind.ThisKeyword) |
| return; |
| case ts.SyntaxKind.BindingElement: |
| case ts.SyntaxKind.VariableDeclaration: |
| return node.parent.name === node ? 4 : undefined; |
| case ts.SyntaxKind.FunctionDeclaration: |
| case ts.SyntaxKind.FunctionExpression: |
| return 4; |
| } |
| } |
| exports.getDeclarationDomain = getDeclarationDomain; |
| function collectVariableUsage(sourceFile) { |
| return new UsageWalker().getUsage(sourceFile); |
| } |
| exports.collectVariableUsage = collectVariableUsage; |
| class AbstractScope { |
| constructor(_global) { |
| this._global = _global; |
| this._variables = new Map(); |
| this._uses = []; |
| this._namespaceScopes = undefined; |
| this._enumScopes = undefined; |
| } |
| addVariable(identifier, name, selector, exported, domain) { |
| const variables = this.getDestinationScope(selector).getVariables(); |
| const declaration = { |
| domain, |
| exported, |
| declaration: name, |
| }; |
| const variable = variables.get(identifier); |
| if (variable === undefined) { |
| variables.set(identifier, { |
| domain, |
| declarations: [declaration], |
| uses: [], |
| }); |
| } |
| else { |
| variable.domain |= domain; |
| variable.declarations.push(declaration); |
| } |
| } |
| addUse(use) { |
| this._uses.push(use); |
| } |
| getVariables() { |
| return this._variables; |
| } |
| getFunctionScope() { |
| return this; |
| } |
| end(cb) { |
| if (this._namespaceScopes !== undefined) |
| this._namespaceScopes.forEach((value) => value.finish(cb)); |
| this._namespaceScopes = this._enumScopes = undefined; |
| this._applyUses(); |
| this._variables.forEach((variable) => { |
| for (const declaration of variable.declarations) { |
| const result = { |
| declarations: [], |
| domain: declaration.domain, |
| exported: declaration.exported, |
| inGlobalScope: this._global, |
| uses: [], |
| }; |
| for (const other of variable.declarations) |
| if (other.domain & declaration.domain) |
| result.declarations.push(other.declaration); |
| for (const use of variable.uses) |
| if (use.domain & declaration.domain) |
| result.uses.push(use); |
| cb(result, declaration.declaration, this); |
| } |
| }); |
| } |
| markExported(_name) { } |
| createOrReuseNamespaceScope(name, _exported, ambient, hasExportStatement) { |
| let scope; |
| if (this._namespaceScopes === undefined) { |
| this._namespaceScopes = new Map(); |
| } |
| else { |
| scope = this._namespaceScopes.get(name); |
| } |
| if (scope === undefined) { |
| scope = new NamespaceScope(ambient, hasExportStatement, this); |
| this._namespaceScopes.set(name, scope); |
| } |
| else { |
| scope.refresh(ambient, hasExportStatement); |
| } |
| return scope; |
| } |
| createOrReuseEnumScope(name, _exported) { |
| let scope; |
| if (this._enumScopes === undefined) { |
| this._enumScopes = new Map(); |
| } |
| else { |
| scope = this._enumScopes.get(name); |
| } |
| if (scope === undefined) { |
| scope = new EnumScope(this); |
| this._enumScopes.set(name, scope); |
| } |
| return scope; |
| } |
| _applyUses() { |
| for (const use of this._uses) |
| if (!this._applyUse(use)) |
| this._addUseToParent(use); |
| this._uses = []; |
| } |
| _applyUse(use, variables = this._variables) { |
| const variable = variables.get(use.location.text); |
| if (variable === undefined || (variable.domain & use.domain) === 0) |
| return false; |
| variable.uses.push(use); |
| return true; |
| } |
| _addUseToParent(_use) { } |
| } |
| class RootScope extends AbstractScope { |
| constructor(_exportAll, global) { |
| super(global); |
| this._exportAll = _exportAll; |
| this._exports = undefined; |
| this._innerScope = new NonRootScope(this, 1); |
| } |
| addVariable(identifier, name, selector, exported, domain) { |
| if (domain & 8) |
| return super.addVariable(identifier, name, selector, exported, domain); |
| return this._innerScope.addVariable(identifier, name, selector, exported, domain); |
| } |
| addUse(use, origin) { |
| if (origin === this._innerScope) |
| return super.addUse(use); |
| return this._innerScope.addUse(use); |
| } |
| markExported(id) { |
| if (this._exports === undefined) { |
| this._exports = [id.text]; |
| } |
| else { |
| this._exports.push(id.text); |
| } |
| } |
| end(cb) { |
| this._innerScope.end((value, key) => { |
| value.exported = value.exported || this._exportAll |
| || this._exports !== undefined && this._exports.includes(key.text); |
| value.inGlobalScope = this._global; |
| return cb(value, key, this); |
| }); |
| return super.end((value, key, scope) => { |
| value.exported = value.exported || scope === this |
| && this._exports !== undefined && this._exports.includes(key.text); |
| return cb(value, key, scope); |
| }); |
| } |
| getDestinationScope() { |
| return this; |
| } |
| } |
| class NonRootScope extends AbstractScope { |
| constructor(_parent, _boundary) { |
| super(false); |
| this._parent = _parent; |
| this._boundary = _boundary; |
| } |
| _addUseToParent(use) { |
| return this._parent.addUse(use, this); |
| } |
| getDestinationScope(selector) { |
| return this._boundary & selector |
| ? this |
| : this._parent.getDestinationScope(selector); |
| } |
| } |
| class EnumScope extends NonRootScope { |
| constructor(parent) { |
| super(parent, 1); |
| } |
| end() { |
| this._applyUses(); |
| } |
| } |
| class ConditionalTypeScope extends NonRootScope { |
| constructor(parent) { |
| super(parent, 8); |
| this._state = 0; |
| } |
| updateState(newState) { |
| this._state = newState; |
| } |
| addUse(use) { |
| if (this._state === 2) |
| return void this._uses.push(use); |
| return this._parent.addUse(use, this); |
| } |
| } |
| class FunctionScope extends NonRootScope { |
| constructor(parent) { |
| super(parent, 1); |
| } |
| beginBody() { |
| this._applyUses(); |
| } |
| } |
| class AbstractNamedExpressionScope extends NonRootScope { |
| constructor(_name, _domain, parent) { |
| super(parent, 1); |
| this._name = _name; |
| this._domain = _domain; |
| } |
| end(cb) { |
| this._innerScope.end(cb); |
| return cb({ |
| declarations: [this._name], |
| domain: this._domain, |
| exported: false, |
| uses: this._uses, |
| inGlobalScope: false, |
| }, this._name, this); |
| } |
| addUse(use, source) { |
| if (source !== this._innerScope) |
| return this._innerScope.addUse(use); |
| if (use.domain & this._domain && use.location.text === this._name.text) { |
| this._uses.push(use); |
| } |
| else { |
| return this._parent.addUse(use, this); |
| } |
| } |
| getFunctionScope() { |
| return this._innerScope; |
| } |
| getDestinationScope() { |
| return this._innerScope; |
| } |
| } |
| class FunctionExpressionScope extends AbstractNamedExpressionScope { |
| constructor(name, parent) { |
| super(name, 4, parent); |
| this._innerScope = new FunctionScope(this); |
| } |
| beginBody() { |
| return this._innerScope.beginBody(); |
| } |
| } |
| class ClassExpressionScope extends AbstractNamedExpressionScope { |
| constructor(name, parent) { |
| super(name, 4 | 2, parent); |
| this._innerScope = new NonRootScope(this, 1); |
| } |
| } |
| class BlockScope extends NonRootScope { |
| constructor(_functionScope, parent) { |
| super(parent, 2); |
| this._functionScope = _functionScope; |
| } |
| getFunctionScope() { |
| return this._functionScope; |
| } |
| } |
| function mapDeclaration(declaration) { |
| return { |
| declaration, |
| exported: true, |
| domain: getDeclarationDomain(declaration), |
| }; |
| } |
| class NamespaceScope extends NonRootScope { |
| constructor(_ambient, _hasExport, parent) { |
| super(parent, 1); |
| this._ambient = _ambient; |
| this._hasExport = _hasExport; |
| this._innerScope = new NonRootScope(this, 1); |
| this._exports = undefined; |
| } |
| finish(cb) { |
| return super.end(cb); |
| } |
| end(cb) { |
| this._innerScope.end((variable, key, scope) => { |
| if (scope !== this._innerScope || |
| !variable.exported && (!this._ambient || this._exports !== undefined && !this._exports.has(key.text))) |
| return cb(variable, key, scope); |
| const namespaceVar = this._variables.get(key.text); |
| if (namespaceVar === undefined) { |
| this._variables.set(key.text, { |
| declarations: variable.declarations.map(mapDeclaration), |
| domain: variable.domain, |
| uses: [...variable.uses], |
| }); |
| } |
| else { |
| outer: for (const declaration of variable.declarations) { |
| for (const existing of namespaceVar.declarations) |
| if (existing.declaration === declaration) |
| continue outer; |
| namespaceVar.declarations.push(mapDeclaration(declaration)); |
| } |
| namespaceVar.domain |= variable.domain; |
| for (const use of variable.uses) { |
| if (namespaceVar.uses.includes(use)) |
| continue; |
| namespaceVar.uses.push(use); |
| } |
| } |
| }); |
| this._applyUses(); |
| this._innerScope = new NonRootScope(this, 1); |
| } |
| createOrReuseNamespaceScope(name, exported, ambient, hasExportStatement) { |
| if (!exported && (!this._ambient || this._hasExport)) |
| return this._innerScope.createOrReuseNamespaceScope(name, exported, ambient || this._ambient, hasExportStatement); |
| return super.createOrReuseNamespaceScope(name, exported, ambient || this._ambient, hasExportStatement); |
| } |
| createOrReuseEnumScope(name, exported) { |
| if (!exported && (!this._ambient || this._hasExport)) |
| return this._innerScope.createOrReuseEnumScope(name, exported); |
| return super.createOrReuseEnumScope(name, exported); |
| } |
| addUse(use, source) { |
| if (source !== this._innerScope) |
| return this._innerScope.addUse(use); |
| this._uses.push(use); |
| } |
| refresh(ambient, hasExport) { |
| this._ambient = ambient; |
| this._hasExport = hasExport; |
| } |
| markExported(name, _as) { |
| if (this._exports === undefined) |
| this._exports = new Set(); |
| this._exports.add(name.text); |
| } |
| getDestinationScope() { |
| return this._innerScope; |
| } |
| } |
| function getEntityNameParent(name) { |
| let parent = name.parent; |
| while (parent.kind === ts.SyntaxKind.QualifiedName) |
| parent = parent.parent; |
| return parent; |
| } |
| class UsageWalker { |
| constructor() { |
| this._result = new Map(); |
| } |
| getUsage(sourceFile) { |
| const variableCallback = (variable, key) => { |
| this._result.set(key, variable); |
| }; |
| const isModule = ts.isExternalModule(sourceFile); |
| this._scope = new RootScope(sourceFile.isDeclarationFile && isModule && !containsExportStatement(sourceFile), !isModule); |
| const cb = (node) => { |
| if (util_1.isBlockScopeBoundary(node)) |
| return continueWithScope(node, new BlockScope(this._scope.getFunctionScope(), this._scope), handleBlockScope); |
| switch (node.kind) { |
| case ts.SyntaxKind.ClassExpression: |
| return continueWithScope(node, node.name !== undefined |
| ? new ClassExpressionScope(node.name, this._scope) |
| : new NonRootScope(this._scope, 1)); |
| case ts.SyntaxKind.ClassDeclaration: |
| this._handleDeclaration(node, true, 4 | 2); |
| return continueWithScope(node, new NonRootScope(this._scope, 1)); |
| case ts.SyntaxKind.InterfaceDeclaration: |
| case ts.SyntaxKind.TypeAliasDeclaration: |
| this._handleDeclaration(node, true, 2); |
| return continueWithScope(node, new NonRootScope(this._scope, 4)); |
| case ts.SyntaxKind.EnumDeclaration: |
| this._handleDeclaration(node, true, 7); |
| return continueWithScope(node, this._scope.createOrReuseEnumScope(node.name.text, util_1.hasModifier(node.modifiers, ts.SyntaxKind.ExportKeyword))); |
| case ts.SyntaxKind.ModuleDeclaration: |
| return this._handleModule(node, continueWithScope); |
| case ts.SyntaxKind.MappedType: |
| return continueWithScope(node, new NonRootScope(this._scope, 4)); |
| case ts.SyntaxKind.FunctionExpression: |
| case ts.SyntaxKind.ArrowFunction: |
| case ts.SyntaxKind.Constructor: |
| case ts.SyntaxKind.MethodDeclaration: |
| case ts.SyntaxKind.FunctionDeclaration: |
| case ts.SyntaxKind.GetAccessor: |
| case ts.SyntaxKind.SetAccessor: |
| case ts.SyntaxKind.MethodSignature: |
| case ts.SyntaxKind.CallSignature: |
| case ts.SyntaxKind.ConstructSignature: |
| case ts.SyntaxKind.ConstructorType: |
| case ts.SyntaxKind.FunctionType: |
| return this._handleFunctionLikeDeclaration(node, cb, variableCallback); |
| case ts.SyntaxKind.ConditionalType: |
| return this._handleConditionalType(node, cb, variableCallback); |
| case ts.SyntaxKind.VariableDeclarationList: |
| this._handleVariableDeclaration(node); |
| break; |
| case ts.SyntaxKind.Parameter: |
| if (node.parent.kind !== ts.SyntaxKind.IndexSignature && |
| (node.name.kind !== ts.SyntaxKind.Identifier || |
| node.name.originalKeywordKind !== ts.SyntaxKind.ThisKeyword)) |
| this._handleBindingName(node.name, false, false); |
| break; |
| case ts.SyntaxKind.EnumMember: |
| this._scope.addVariable(util_1.getPropertyName(node.name), node.name, 1, true, 4); |
| break; |
| case ts.SyntaxKind.ImportClause: |
| case ts.SyntaxKind.ImportSpecifier: |
| case ts.SyntaxKind.NamespaceImport: |
| case ts.SyntaxKind.ImportEqualsDeclaration: |
| this._handleDeclaration(node, false, 7 | 8); |
| break; |
| case ts.SyntaxKind.TypeParameter: |
| this._scope.addVariable(node.name.text, node.name, node.parent.kind === ts.SyntaxKind.InferType ? 8 : 7, false, 2); |
| break; |
| case ts.SyntaxKind.ExportSpecifier: |
| if (node.propertyName !== undefined) |
| return this._scope.markExported(node.propertyName, node.name); |
| return this._scope.markExported(node.name); |
| case ts.SyntaxKind.ExportAssignment: |
| if (node.expression.kind === ts.SyntaxKind.Identifier) |
| return this._scope.markExported(node.expression); |
| break; |
| case ts.SyntaxKind.Identifier: |
| const domain = getUsageDomain(node); |
| if (domain !== undefined) |
| this._scope.addUse({ domain, location: node }); |
| return; |
| } |
| return ts.forEachChild(node, cb); |
| }; |
| const continueWithScope = (node, scope, next = forEachChild) => { |
| const savedScope = this._scope; |
| this._scope = scope; |
| next(node); |
| this._scope.end(variableCallback); |
| this._scope = savedScope; |
| }; |
| const handleBlockScope = (node) => { |
| if (node.kind === ts.SyntaxKind.CatchClause && node.variableDeclaration !== undefined) |
| this._handleBindingName(node.variableDeclaration.name, true, false); |
| return ts.forEachChild(node, cb); |
| }; |
| ts.forEachChild(sourceFile, cb); |
| this._scope.end(variableCallback); |
| return this._result; |
| function forEachChild(node) { |
| return ts.forEachChild(node, cb); |
| } |
| } |
| _handleConditionalType(node, cb, varCb) { |
| const savedScope = this._scope; |
| const scope = this._scope = new ConditionalTypeScope(savedScope); |
| cb(node.checkType); |
| scope.updateState(1); |
| cb(node.extendsType); |
| scope.updateState(2); |
| cb(node.trueType); |
| scope.updateState(3); |
| cb(node.falseType); |
| scope.end(varCb); |
| this._scope = savedScope; |
| } |
| _handleFunctionLikeDeclaration(node, cb, varCb) { |
| if (node.decorators !== undefined) |
| node.decorators.forEach(cb); |
| const savedScope = this._scope; |
| if (node.kind === ts.SyntaxKind.FunctionDeclaration) |
| this._handleDeclaration(node, false, 4); |
| const scope = this._scope = node.kind === ts.SyntaxKind.FunctionExpression && node.name !== undefined |
| ? new FunctionExpressionScope(node.name, savedScope) |
| : new FunctionScope(savedScope); |
| if (node.name !== undefined) |
| cb(node.name); |
| if (node.typeParameters !== undefined) |
| node.typeParameters.forEach(cb); |
| node.parameters.forEach(cb); |
| if (node.type !== undefined) |
| cb(node.type); |
| if (node.body !== undefined) { |
| scope.beginBody(); |
| cb(node.body); |
| } |
| scope.end(varCb); |
| this._scope = savedScope; |
| } |
| _handleModule(node, next) { |
| if (node.flags & ts.NodeFlags.GlobalAugmentation) |
| return next(node, this._scope.createOrReuseNamespaceScope('-global', false, true, false)); |
| if (node.name.kind === ts.SyntaxKind.Identifier) { |
| const exported = isNamespaceExported(node); |
| this._scope.addVariable(node.name.text, node.name, 1, exported, 1 | 4); |
| const ambient = util_1.hasModifier(node.modifiers, ts.SyntaxKind.DeclareKeyword); |
| return next(node, this._scope.createOrReuseNamespaceScope(node.name.text, exported, ambient, ambient && namespaceHasExportStatement(node))); |
| } |
| return next(node, this._scope.createOrReuseNamespaceScope(`"${node.name.text}"`, false, true, namespaceHasExportStatement(node))); |
| } |
| _handleDeclaration(node, blockScoped, domain) { |
| if (node.name !== undefined) |
| this._scope.addVariable(node.name.text, node.name, blockScoped ? 3 : 1, util_1.hasModifier(node.modifiers, ts.SyntaxKind.ExportKeyword), domain); |
| } |
| _handleBindingName(name, blockScoped, exported) { |
| if (name.kind === ts.SyntaxKind.Identifier) |
| return this._scope.addVariable(name.text, name, blockScoped ? 3 : 1, exported, 4); |
| util_1.forEachDestructuringIdentifier(name, (declaration) => { |
| this._scope.addVariable(declaration.name.text, declaration.name, blockScoped ? 3 : 1, exported, 4); |
| }); |
| } |
| _handleVariableDeclaration(declarationList) { |
| const blockScoped = util_1.isBlockScopedVariableDeclarationList(declarationList); |
| const exported = declarationList.parent.kind === ts.SyntaxKind.VariableStatement && |
| util_1.hasModifier(declarationList.parent.modifiers, ts.SyntaxKind.ExportKeyword); |
| for (const declaration of declarationList.declarations) |
| this._handleBindingName(declaration.name, blockScoped, exported); |
| } |
| } |
| function isNamespaceExported(node) { |
| return node.parent.kind === ts.SyntaxKind.ModuleDeclaration || util_1.hasModifier(node.modifiers, ts.SyntaxKind.ExportKeyword); |
| } |
| function namespaceHasExportStatement(ns) { |
| if (ns.body === undefined || ns.body.kind !== ts.SyntaxKind.ModuleBlock) |
| return false; |
| return containsExportStatement(ns.body); |
| } |
| function containsExportStatement(block) { |
| for (const statement of block.statements) |
| if (statement.kind === ts.SyntaxKind.ExportDeclaration || statement.kind === ts.SyntaxKind.ExportAssignment) |
| return true; |
| return false; |
| } |