// This allows users to just specify library files they want to used through --lib

// and they will not get an error from not having unrelated library files

let deferredGlobalESSymbolConstructorSymbol: Symbol | undefined;

let deferredGlobalESSymbolType: ObjectType;

let deferredGlobalTypedPropertyDescriptorType: GenericType;

let deferredGlobalPromiseType: GenericType;

const additionalContainers = mapDefined(container.declarations, fileSymbolIfFileSymbolExportEqualsContainer);

const reexportContainers = enclosingDeclaration && getAlternativeContainingModules(symbol, enclosingDeclaration);

const objectLiteralContainer = getVariableDeclarationOfObjectLiteral(container, meaning);

return append(concatenate(concatenate([container], additionalContainers), reexportContainers), objectLiteralContainer); // This order expresses a preference for the real container if it is in scope

}

}

const candidates = mapDefined(symbol.declarations, d => {

if (!isAmbientModule(d) && d.parent && hasNonGlobalAugmentationExternalModuleSymbol(d.parent)) {

}

}

}

const propertyName = getPropertyNameNodeForSymbol(propertySymbol, context);

context.approximateLength += (symbolName(propertySymbol).length + 1);

const optionalToken = propertySymbol.flags & SymbolFlags.Optional ? factory.createToken(SyntaxKind.QuestionToken) : undefined;

if (propertySymbol.flags & (SymbolFlags.Function | SymbolFlags.Method) && !getPropertiesOfObjectType(propertyType).length && !isReadonlySymbol(propertySymbol)) {

if (fromNameType) {

return fromNameType;

}

const rawName = unescapeLeadingUnderscores(symbol.escapedName);

const stringNamed = !!length(symbol.declarations) && every(symbol.declarations, isStringNamed);

return createPropertyNameNodeForIdentifierOrLiteral(rawName, stringNamed, singleQuote);

return widenTypeForVariableLikeDeclaration(getTypeForVariableLikeDeclaration(declaration, /*includeOptionality*/ true), declaration, reportErrors);

}

function widenTypeForVariableLikeDeclaration(type: Type | undefined, declaration: any, reportErrors?: boolean) {

if (type) {

if (reportErrors) {

reportErrorsFromWidening(declaration, type);

}

return deferredGlobalESSymbolConstructorSymbol || (deferredGlobalESSymbolConstructorSymbol = getGlobalValueSymbol("Symbol" as __String, reportErrors));

}

function getGlobalESSymbolType(reportErrors: boolean) {

return deferredGlobalESSymbolType || (deferredGlobalESSymbolType = getGlobalType("Symbol" as __String, /*arity*/ 0, reportErrors)) || emptyObjectType;

}

function getLiteralTypeFromProperty(prop: Symbol, include: TypeFlags) {

if (!(getDeclarationModifierFlagsFromSymbol(prop) & ModifierFlags.NonPublicAccessibilityModifier)) {

let type = getSymbolLinks(getLateBoundSymbol(prop)).nameType;

if (prop.escapedName === InternalSymbolName.Default) {

type = getLiteralType("default");

}

else {

const name = prop.valueDeclaration && getNameOfDeclaration(prop.valueDeclaration) as PropertyName;

}

}

if (type && type.flags & include) {

}

function getPropertyNameFromIndex(indexType: Type, accessNode: StringLiteral | Identifier | PrivateIdentifier | ObjectBindingPattern | ArrayBindingPattern | ComputedPropertyName | NumericLiteral | IndexedAccessTypeNode | ElementAccessExpression | SyntheticExpression | undefined) {

return isTypeUsableAsPropertyName(indexType) ?

getPropertyNameFromType(indexType) :

accessNode && isPropertyName(accessNode) ?

// late bound names are handled in the first branch, so here we only need to handle normal names

getPropertyNameForPropertyNameNode(accessNode) :

!isTypeAssignableTo(links.resolvedType, stringNumberSymbolType)) {

error(node, Diagnostics.A_computed_property_name_must_be_of_type_string_number_symbol_or_any);

}

}

return links.resolvedType;

// As otherwise they may not be checked until exports for the type at this position are retrieved,

// which may never occur.

for (const elem of node.properties) {

checkComputedPropertyName(elem.name);

}

}

let offset = 0;

for (const memberDecl of node.properties) {

let member = getSymbolOfNode(memberDecl);

checkComputedPropertyName(memberDecl.name) : undefined;

if (memberDecl.kind === SyntaxKind.PropertyAssignment ||

memberDecl.kind === SyntaxKind.ShorthandPropertyAssignment ||

return checkIndexedAccessIndexType(getFlowTypeOfAccessExpression(node, indexedAccessType.symbol, indexedAccessType, indexExpression), node);

}

function callLikeExpressionMayHaveTypeArguments(node: CallLikeExpression): node is CallExpression | NewExpression | TaggedTemplateExpression | JsxOpeningElement {

return isCallOrNewExpression(node) || isTaggedTemplateExpression(node) || isJsxOpeningLikeElement(node);

}

}

}

/**

* Gets the *yield*, *return*, and *next* types of an `Iterable`-like or `AsyncIterable`-like

* type from its members.

export function isSimpleInlineableExpression(expression: Expression) {

}

export function isCompoundAssignment(kind: BinaryOperator): kind is CompoundAssignmentOperator {

| CallChainRoot

;

/** @internal */

export type BindableObjectDefinePropertyCall = CallExpression & {

readonly arguments: readonly [BindableStaticNameExpression, StringLiteralLike | NumericLiteral, ObjectLiteralExpression] & Readonly<TextRange>;

/** @internal */

export type LiteralLikeElementAccessExpression = ElementAccessExpression & Declaration & {

};

/** @internal */

/** x[0] OR x['a'] OR x[Symbol.y] */

export function isLiteralLikeElementAccess(node: Node): node is LiteralLikeElementAccessExpression {

}

/** Any series of property and element accesses. */

return escapeLeadingUnderscores(name.text);

}

}

return undefined;

}

export function hasDynamicName(declaration: Declaration): declaration is DynamicNamedDeclaration | DynamicNamedBinaryExpression {

const name = getNameOfDeclaration(declaration);

}

const expr = isElementAccessExpression(name) ? skipParentheses(name.argumentExpression) : name.expression;

return !isStringOrNumericLiteralLike(expr) &&

}

export function getPropertyNameForPropertyNameNode(name: PropertyName): __String | undefined {

return escapeLeadingUnderscores(name.text);

case SyntaxKind.ComputedPropertyName:

const nameExpression = name.expression;

return escapeLeadingUnderscores(nameExpression.text);

}

else if (isSignedNumericLiteral(nameExpression)) {

return `__@${getSymbolId(symbol)}@${symbol.escapedName}` as __String;

}

export function getSymbolNameForPrivateIdentifier(containingClassSymbol: Symbol, description: __String): __String {

return `__#${getSymbolId(containingClassSymbol)}@${description}` as __String;

}

interface IteratorYieldResult<TYield> {