From 5edf075142dd0ed87473b22e403aa9a089fc7ec7 Mon Sep 17 00:00:00 2001 From: Daniel Rosenwasser Date: Mon, 8 Sep 2014 12:27:12 -0700 Subject: [PATCH] Corrected some spelling/grammar issues. --- src/compiler/checker.ts | 68 ++++++++++++++++++++--------------------- src/compiler/emitter.ts | 30 +++++++++--------- src/compiler/parser.ts | 28 ++++++++--------- src/compiler/scanner.ts | 8 ++--- src/compiler/types.ts | 2 +- 5 files changed, 68 insertions(+), 68 deletions(-) diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts index 4256ef7cefc..ab8e3655541 100644 --- a/src/compiler/checker.ts +++ b/src/compiler/checker.ts @@ -24,9 +24,9 @@ module ts { } /// fullTypeCheck denotes if this instance of the typechecker will be used to get semantic diagnostics. - /// If fullTypeCheck === true - then typechecker should do every possible check to produce all errors - /// If fullTypeCheck === false - typechecker can shortcut and skip checks that only produce errors. - /// NOTE: checks that somehow affects decisions being made during typechecking should be executed in both cases. + /// If fullTypeCheck === true, then the typechecker should do every possible check to produce all errors + /// If fullTypeCheck === false, the typechecker can take shortcuts and skip checks that only produce errors. + /// NOTE: checks that somehow affect decisions being made during typechecking should be executed in both cases. export function createTypeChecker(program: Program, fullTypeCheck: boolean): TypeChecker { var Symbol = objectAllocator.getSymbolConstructor(); @@ -573,7 +573,7 @@ module ts { return (resolveImport(symbol).flags & SymbolFlags.Value) !== 0; } - // If it is an instantiated symbol, then it is a value if hte symbol it is an + // If it is an instantiated symbol, then it is a value if the symbol it is an // instantiation of is a value. if (symbol.flags & SymbolFlags.Instantiated) { return (getSymbolLinks(symbol).target.flags & SymbolFlags.Value) !== 0; @@ -697,7 +697,7 @@ module ts { function getAccessibleSymbolChain(symbol: Symbol, enclosingDeclaration: Node, meaning: SymbolFlags): Symbol[] { function getAccessibleSymbolChainFromSymbolTable(symbols: SymbolTable): Symbol[] { function canQualifySymbol(symbolFromSymbolTable: Symbol, meaning: SymbolFlags) { - // If the symbol is equivalent and doesnt need futher qualification, this symbol is accessible + // If the symbol is equivalent and doesn't need further qualification, this symbol is accessible if (!needsQualification(symbolFromSymbolTable, enclosingDeclaration, meaning)) { return true; } @@ -793,9 +793,9 @@ module ts { return { accessibility: SymbolAccessibility.Accessible, aliasesToMakeVisible: hasAccessibleDeclarations.aliasesToMakeVisible }; } - // If we havent got the accessible symbol doesnt mean the symbol is actually inaccessible. - // It could be qualified symbol and hence verify the path - // eg: + // If we haven't got the accessible symbol, it doesn't mean the symbol is actually inaccessible. + // It could be a qualified symbol and hence verify the path + // e.g.: // module m { // export class c { // } @@ -803,7 +803,7 @@ module ts { // var x: typeof m.c // In the above example when we start with checking if typeof m.c symbol is accessible, // we are going to see if c can be accessed in scope directly. - // But it cant, hence the accessible is going to be undefined, but that doesnt mean m.c is accessible + // But it can't, hence the accessible is going to be undefined, but that doesn't mean m.c is inaccessible // It is accessible if the parent m is accessible because then m.c can be accessed through qualification meaningToLook = getQualifiedLeftMeaning(meaning); symbol = getParentOfSymbol(symbol); @@ -815,7 +815,7 @@ module ts { if (symbolExternalModule) { var enclosingExternalModule = getExternalModuleContainer(enclosingDeclaration); if (symbolExternalModule !== enclosingExternalModule) { - // name from different external module that is not visibile + // name from different external module that is not visible return { accessibility: SymbolAccessibility.CannotBeNamed, errorSymbolName: symbolToString(initialSymbol, enclosingDeclaration, meaning), @@ -892,7 +892,7 @@ module ts { { accessibility: SymbolAccessibility.NotAccessible, errorSymbolName: firstIdentifierName }; } - // Enclosing declaration is optional when we dont want to get qualified name in the enclosing declaration scope + // Enclosing declaration is optional when we don't want to get qualified name in the enclosing declaration scope // Meaning needs to be specified if the enclosing declaration is given function symbolToString(symbol: Symbol, enclosingDeclaration?: Node, meaning?: SymbolFlags) { function getSymbolName(symbol: Symbol) { @@ -919,7 +919,7 @@ module ts { currentSymbolName = ts.map(accessibleSymbolChain, accessibleSymbol => getSymbolName(accessibleSymbol)).join("."); } else { - // If we didnt find accessible symbol chain for this symbol, break if this is external module + // If we didn't find accessible symbol chain for this symbol, break if this is external module if (!isFirstName && ts.forEach(symbol.declarations, declaration => hasExternalModuleSymbol(declaration))) { break; } @@ -991,7 +991,7 @@ module ts { function writeTypeReference(type: TypeReference) { if (type.target === globalArrayType && !(flags & TypeFormatFlags.WriteArrayAsGenericType)) { // If we are writing array element type the arrow style signatures are not allowed as - // we need to surround it by curlies, eg. { (): T; }[]; as () => T[] would mean something different + // we need to surround it by curlies, e.g. { (): T; }[]; as () => T[] would mean something different writeType(type.typeArguments[0], /*allowFunctionOrConstructorTypeLiteral*/ false); writer.write("[]"); } @@ -1244,7 +1244,7 @@ module ts { !(node.kind !== SyntaxKind.ImportDeclaration && parent.kind !== SyntaxKind.SourceFile && isInAmbientContext(parent))) { return isGlobalSourceFile(parent) || isUsedInExportAssignment(node); } - // Exported members/ambient module elements (exception import declaraiton) are visible if parent is visible + // Exported members/ambient module elements (exception import declaration) are visible if parent is visible return isDeclarationVisible(parent); case SyntaxKind.Property: @@ -4032,7 +4032,7 @@ module ts { } else { // current declaration belongs to a different symbol - // set cutoffPos so reorderings in the future won't change result set from 0 to cutoffPos + // set cutoffPos so re-orderings in the future won't change result set from 0 to cutoffPos pos = cutoffPos = result.length; lastParent = parent; } @@ -4782,7 +4782,7 @@ module ts { var ok = checkReferenceExpression(node.left, Diagnostics.Invalid_left_hand_side_of_assignment_expression); // Use default messages if (ok) { - // to avoid cascading errors check assignability only if 'isReference' check succeded and no errors were reported + // to avoid cascading errors check assignability only if 'isReference' check succeeded and no errors were reported checkTypeAssignableTo(valueType, leftType, node.left, /*chainedMessage*/ undefined, /*terminalMessage*/ undefined); } } @@ -4828,7 +4828,7 @@ module ts { // Checks an expression and returns its type. The contextualMapper parameter serves two purposes: When // contextualMapper is not undefined and not equal to the identityMapper function object it indicates that the // expression is being inferentially typed (section 4.12.2 in spec) and provides the type mapper to use in - // conjuction with the generic contextual type. When contextualMapper is equal to the identityMapper function + // conjunction with the generic contextual type. When contextualMapper is equal to the identityMapper function // object, it serves as an indicator that all contained function and arrow expressions should be considered to // have the wildcard function type; this form of type check is used during overload resolution to exclude // contextually typed function and arrow expressions in the initial phase. @@ -4933,7 +4933,7 @@ module ts { // legal case - parameter initializer references some parameter strictly on left of current parameter declaration return; } - // fallthrough to error reporting + // fall through to error reporting } error(n, Diagnostics.Initializer_of_parameter_0_cannot_reference_identifier_1_declared_after_it, identifierToString(parameterDeclaration.name), identifierToString(n)); @@ -5325,7 +5325,7 @@ module ts { } // when checking exported function declarations across modules check only duplicate implementations - // names and consistensy of modifiers are verified when we check local symbol + // names and consistency of modifiers are verified when we check local symbol var isExportSymbolInsideModule = symbol.parent && symbol.parent.flags & SymbolFlags.Module; for (var i = 0; i < declarations.length; i++) { var node = declarations[i]; @@ -5421,7 +5421,7 @@ module ts { var symbol: Symbol; // Exports should be checked only if enclosing module contains both exported and non exported declarations. - // In case if all declarations are non-exported check is unnecesary. + // In case if all declarations are non-exported check is unnecessary. // if localSymbol is defined on node then node itself is exported - check is required var symbol = node.localSymbol; @@ -5866,7 +5866,7 @@ module ts { checkTypeAssignableTo(checkExpression(node.expression), returnType, node.expression, /*chainedMessage*/ undefined, /*terminalMessage*/ undefined); } else if (func.kind == SyntaxKind.Constructor) { - // constructor doesn't have explicit return type annontation and yet its return type is known - declaring type + // constructor doesn't have explicit return type annotation and yet its return type is known - declaring type // handle constructors and issue specialized error message for them. if (!isTypeAssignableTo(checkExpression(node.expression), returnType)) { error(node.expression, Diagnostics.Return_type_of_constructor_signature_must_be_assignable_to_the_instance_type_of_the_class); @@ -6113,7 +6113,7 @@ module ts { } if ((base.flags & derived.flags & SymbolFlags.Method) || ((base.flags & SymbolFlags.PropertyOrAccessor) && (derived.flags & SymbolFlags.PropertyOrAccessor))) { - // method is overridden with method or property\accessor is overridden with property\accessor - correct case + // method is overridden with method or property/accessor is overridden with property/accessor - correct case continue; } @@ -6965,7 +6965,7 @@ module ts { return moduleType ? moduleType.symbol : undefined; } - // Intentinal fallthrough + // Intentional fall-through case SyntaxKind.NumericLiteral: // index access if (node.parent.kind == SyntaxKind.IndexedAccess && (node.parent).index === node) { @@ -7030,7 +7030,7 @@ module ts { var apparentType = getApparentType(type); if (apparentType.flags & TypeFlags.ObjectType) { - // Augment the apprent type with Function and Object memeber as applicaple + // Augment the apparent type with Function and Object members as applicable var propertiesByName: Map = {}; var results: Symbol[] = []; @@ -7187,17 +7187,17 @@ module ts { var symbol = getSymbolOfNode(node); var signaturesOfSymbol = getSignaturesOfSymbol(symbol); // If this function body corresponds to function with multiple signature, it is implementation of overload - // eg: function foo(a: string): string; - // function foo(a: number): number; - // function foo(a: any) { // This is implementation of the overloads - // return a; - // } + // e.g.: function foo(a: string): string; + // function foo(a: number): number; + // function foo(a: any) { // This is implementation of the overloads + // return a; + // } return signaturesOfSymbol.length > 1 || - // If there is single signature for the symbol, it is overload if that signature isnt coming from the node - // eg: function foo(a: string): string; - // function foo(a: any) { // This is implementation of the overloads - // return a; - // } + // If there is single signature for the symbol, it is overload if that signature isn't coming from the node + // e.g.: function foo(a: string): string; + // function foo(a: any) { // This is implementation of the overloads + // return a; + // } (signaturesOfSymbol.length === 1 && signaturesOfSymbol[0].declaration !== node); } return false; diff --git a/src/compiler/emitter.ts b/src/compiler/emitter.ts index 6c108dd1ff7..6b18ad4c133 100644 --- a/src/compiler/emitter.ts +++ b/src/compiler/emitter.ts @@ -266,7 +266,7 @@ module ts { } } else { - // Single line comment of styly //.... + // Single line comment of style //.... writer.write(currentSourceFile.text.substring(comment.pos, comment.end)); } @@ -393,7 +393,7 @@ module ts { } var prevEncodedEmittedColumn = lastEncodedSourceMapSpan.emittedColumn; - // Line/Comma deliminators + // Line/Comma delimiters if (lastEncodedSourceMapSpan.emittedLine == lastRecordedSourceMapSpan.emittedLine) { // Emit comma to separate the entry if (sourceMapData.sourceMapMappings) { @@ -401,7 +401,7 @@ module ts { } } else { - // Emit line deliminators + // Emit line delimiters for (var encodedLine = lastEncodedSourceMapSpan.emittedLine; encodedLine < lastRecordedSourceMapSpan.emittedLine; encodedLine++) { sourceMapData.sourceMapMappings += ";"; } @@ -470,7 +470,7 @@ module ts { var emittedLine = writer.getLine(); var emittedColumn = writer.getColumn(); - // If this location wasnt recorded or the location in source is going backwards, record the span + // If this location wasn't recorded or the location in source is going backwards, record the span if (!lastRecordedSourceMapSpan || lastRecordedSourceMapSpan.emittedLine != emittedLine || lastRecordedSourceMapSpan.emittedColumn != emittedColumn || @@ -516,7 +516,7 @@ module ts { } function recordNewSourceFileStart(node: SourceFile) { - // Add the the file to tsFilePaths + // Add the file to tsFilePaths // If sourceroot option: Use the relative path corresponding to the common directory path // otherwise source locations relative to map file location var sourcesDirectoryPath = compilerOptions.sourceRoot ? program.getCommonSourceDirectory() : sourceMapDir; @@ -953,7 +953,7 @@ module ts { write(tokenToString(node.operator)); } // In some cases, we need to emit a space between the operator and the operand. One obvious case - // is when the operator is an identifer, like delete or typeof. We also need to do this for plus + // is when the operator is an identifier, like delete or typeof. We also need to do this for plus // and minus expressions in certain cases. Specifically, consider the following two cases (parens // are just for clarity of exposition, and not part of the source code): // @@ -2116,7 +2116,7 @@ module ts { } function getLeadingCommentsToEmit(node: Node) { - // Emit the leading comments only if the parent's pos doesnt match because parent should take care of emitting these comments + // Emit the leading comments only if the parent's pos doesn't match because parent should take care of emitting these comments if (node.parent.kind === SyntaxKind.SourceFile || node.pos !== node.parent.pos) { var leadingComments: Comment[]; if (hasDetachedComments(node.pos)) { @@ -2139,7 +2139,7 @@ module ts { } function emitTrailingDeclarationComments(node: Node) { - // Emit the trailing comments only if the parent's end doesnt match + // Emit the trailing comments only if the parent's end doesn't match if (node.parent.kind === SyntaxKind.SourceFile || node.end !== node.parent.end) { var trailingComments = getTrailingComments(currentSourceFile.text, node.end); // trailing comments are emitted at space/*trailing comment1 */space/*trailing comment*/ @@ -2215,7 +2215,7 @@ module ts { return currentSourceFile.text.charCodeAt(comment.pos + 2) === CharacterCodes.exclamation; } // Verify this is /// comment, but do the regexp match only when we first can find /// in the comment text - // so that we dont end up computing comment string and doing match for all // comments + // so that we don't end up computing comment string and doing match for all // comments else if (currentSourceFile.text.charCodeAt(comment.pos + 1) === CharacterCodes.slash && comment.pos + 2 < comment.end && currentSourceFile.text.charCodeAt(comment.pos + 2) === CharacterCodes.slash && @@ -2691,7 +2691,7 @@ module ts { } function emitVariableDeclaration(node: VariableDeclaration) { - // If we are emitting property it isnt moduleElement and hence we already know it needs to be emitted + // If we are emitting property it isn't moduleElement and hence we already know it needs to be emitted // so there is no check needed to see if declaration is visible if (node.kind !== SyntaxKind.VariableDeclaration || resolver.isDeclarationVisible(node)) { emitSourceTextOfNode(node.name); @@ -2715,7 +2715,7 @@ module ts { Diagnostics.Exported_variable_0_has_or_is_using_name_1_from_private_module_2 : Diagnostics.Exported_variable_0_has_or_is_using_private_name_1; } - // This check is to ensure we dont report error on constructor parameter property as that error would be reported during parameter emit + // This check is to ensure we don't report error on constructor parameter property as that error would be reported during parameter emit else if (node.kind === SyntaxKind.Property) { if (node.flags & NodeFlags.Static) { diagnosticMessage = symbolAccesibilityResult.errorModuleName ? @@ -2820,7 +2820,7 @@ module ts { } function emitFunctionDeclaration(node: FunctionDeclaration) { - // If we are emitting Method/Constructor it isnt moduleElement and hence already determined to be emitting + // If we are emitting Method/Constructor it isn't moduleElement and hence already determined to be emitting // so no need to verify if the declaration is visible if ((node.kind !== SyntaxKind.FunctionDeclaration || resolver.isDeclarationVisible(node)) && !resolver.isImplementationOfOverload(node)) { @@ -3096,7 +3096,7 @@ module ts { } if (root) { - // Emiting single file so emit references in this file only + // Emitting just a single file, so emit references in this file only if (!compilerOptions.noResolve) { var addedGlobalFileReference = false; forEach(root.referencedFiles, fileReference => { @@ -3127,9 +3127,9 @@ module ts { forEach(sourceFile.referencedFiles, fileReference => { var referencedFile = resolveScriptReference(sourceFile, fileReference); - // If the reference file is declaration file or external module emit that reference + // If the reference file is a declaration file or an external module, emit that reference if (isExternalModuleOrDeclarationFile(referencedFile) && - !contains(emittedReferencedFiles, referencedFile)) { // If the file refernece was not already emitted + !contains(emittedReferencedFiles, referencedFile)) { // If the file reference was not already emitted writeReferencePath(referencedFile); emittedReferencedFiles.push(referencedFile); diff --git a/src/compiler/parser.ts b/src/compiler/parser.ts index 536f40a291d..68c076367d4 100644 --- a/src/compiler/parser.ts +++ b/src/compiler/parser.ts @@ -141,11 +141,11 @@ module ts { export function getLeadingCommentsOfNode(node: Node, sourceFileOfNode: SourceFile) { // If parameter/type parameter, the prev token trailing comments are part of this node too if (node.kind === SyntaxKind.Parameter || node.kind === SyntaxKind.TypeParameter) { - // eg (/** blah */ a, /** blah */ b); + // e.g. (/** blah */ a, /** blah */ b); return concatenate(getTrailingComments(sourceFileOfNode.text, node.pos), - // eg: ( - // /** blah */ a, - // /** blah */ b); + // e.g.: ( + // /** blah */ a, + // /** blah */ b); getLeadingComments(sourceFileOfNode.text, node.pos)); } else { @@ -157,7 +157,7 @@ module ts { return filter(getLeadingCommentsOfNode(node, sourceFileOfNode), comment => isJsDocComment(comment)); function isJsDocComment(comment: Comment) { - // js doc is if comment is starting with /** but not if it is /**/ + // True if the comment starts with '/**' but not if it is '/**/' return sourceFileOfNode.text.charCodeAt(comment.pos + 1) === CharacterCodes.asterisk && sourceFileOfNode.text.charCodeAt(comment.pos + 2) === CharacterCodes.asterisk && sourceFileOfNode.text.charCodeAt(comment.pos + 3) !== CharacterCodes.slash; @@ -661,7 +661,7 @@ module ts { } function reportInvalidUseInStrictMode(node: Identifier): void { - // identifierToString cannot be used here since it uses backreference to 'parent' that is not yet set + // identifierToString cannot be used here since it uses a backreference to 'parent' that is not yet set var name = sourceText.substring(skipTrivia(sourceText, node.pos), node.end); grammarErrorOnNode(node, Diagnostics.Invalid_use_of_0_in_strict_mode, name); } @@ -732,7 +732,7 @@ module ts { lookAheadMode = LookAheadMode.NoErrorYet; var result = callback(); - // If we switched from 1 to to -1 then a parse error occurred during the callback. + // If we switched from 1 to -1 then a parse error occurred during the callback. // If that's the case, then we want to act as if we never got any result at all. Debug.assert(lookAheadMode === LookAheadMode.Error || lookAheadMode === LookAheadMode.NoErrorYet); if (lookAheadMode === LookAheadMode.Error) { @@ -1634,7 +1634,7 @@ module ts { // (i.e. they're both BinaryExpressions with an assignment operator in it). // First, check if we have an arrow function (production '4') that starts with a parenthesized - // parameter list. If we do, we must *not* recurse for productsion 1, 2 or 3. An ArrowFunction is + // parameter list. If we do, we must *not* recurse for productions 1, 2 or 3. An ArrowFunction is // not a LeftHandSideExpression, nor does it start a ConditionalExpression. So we are done // with AssignmentExpression if we see one. var arrowExpression = tryParseParenthesizedArrowFunctionExpression(); @@ -1822,7 +1822,7 @@ module ts { if (token === SyntaxKind.EqualsGreaterThanToken) { // ERROR RECOVERY TWEAK: // If we see a standalone => try to parse it as an arrow function expression as that's - // likely whatthe user intended to write. + // likely what the user intended to write. return Tristate.True; } // Definitely not a parenthesized arrow function. @@ -2725,8 +2725,8 @@ module ts { switch (token) { case SyntaxKind.SemicolonToken: // If we're in error recovery, then we don't want to treat ';' as an empty statement. - // The problem is that ';' can show up in far too many contexts, and if we see one - // and assume it's a statement, then we may bail out innapropriately from whatever + // The problem is that ';' can show up in far too many contexts, and if we see one + // and assume it's a statement, then we may bail out inappropriately from whatever // we're parsing. For example, if we have a semicolon in the middle of a class, then // we really don't want to assume the class is over and we're on a statement in the // outer module. We just want to consume and move on. @@ -3286,7 +3286,7 @@ module ts { function isIntegerLiteral(expression: Expression): boolean { function isInteger(literalExpression: LiteralExpression): boolean { // Allows for scientific notation since literalExpression.text was formed by - // coercing a number to a string. Sometimes this coersion can yield a string + // coercing a number to a string. Sometimes this coercion can yield a string // in scientific notation. // We also don't need special logic for hex because a hex integer is converted // to decimal when it is coerced. @@ -3308,7 +3308,7 @@ module ts { var inConstantEnumMemberSection = true; // In an ambient declaration, the grammar only allows integer literals as initializers. - // In a nonambient declaration, the grammar allows uninitialized members only in a + // In a non-ambient declaration, the grammar allows uninitialized members only in a // ConstantEnumMemberSection, which starts at the beginning of an enum declaration // or any time an integer literal initializer is encountered. function parseAndCheckEnumMember(): EnumMember { @@ -3848,7 +3848,7 @@ module ts { commonSourceDirectory = getNormalizedPathFromPathCompoments(commonPathComponents); if (commonSourceDirectory) { // Make sure directory path ends with directory separator so this string can directly - // used to replace with "" to get the relative path of the source file and the relative path doesnt + // used to replace with "" to get the relative path of the source file and the relative path doesn't // start with / making it rooted path commonSourceDirectory += directorySeparator; } diff --git a/src/compiler/scanner.ts b/src/compiler/scanner.ts index 614c190d426..59c7913e24a 100644 --- a/src/compiler/scanner.ts +++ b/src/compiler/scanner.ts @@ -192,7 +192,7 @@ module ts { return false; } - // Perform binary search in one of the unicode range maps + // Perform binary search in one of the Unicode range maps var lo: number = 0; var hi: number = map.length; var mid: number; @@ -281,8 +281,8 @@ module ts { if (lineNumber < 0) { // If the actual position was not found, // the binary search returns the negative value of the next line start - // eg. if line starts at [5, 10, 23, 80] and position requested was 20 - // the search will return -2 + // e.g. if the line starts at [5, 10, 23, 80] and the position requested was 20 + // then the search will return -2 lineNumber = (~lineNumber) - 1; } return { @@ -369,7 +369,7 @@ module ts { // Extract comments from the given source text starting at the given position. If trailing is false, whitespace is skipped until // the first line break and comments between that location and the next token are returned. If trailing is true, comments occurring // between the given position and the next line break are returned. The return value is an array containing a TextRange for each - // comment. Single-line comment ranges include the the beginning '//' characters but not the ending line break. Multi-line comment + // comment. Single-line comment ranges include the beginning '//' characters but not the ending line break. Multi-line comment // ranges include the beginning '/* and ending '*/' characters. The return value is undefined if no comments were found. function getCommentRanges(text: string, pos: number, trailing: boolean): Comment[] { var result: Comment[]; diff --git a/src/compiler/types.ts b/src/compiler/types.ts index 30952ec4f30..922db40cdec 100644 --- a/src/compiler/types.ts +++ b/src/compiler/types.ts @@ -648,7 +648,7 @@ module ts { export interface SymbolAccessiblityResult { accessibility: SymbolAccessibility; errorSymbolName?: string // Optional symbol name that results in error - errorModuleName?: string // If the symbol is not visibile from module, module's name + errorModuleName?: string // If the symbol is not visible from module, module's name aliasesToMakeVisible?: ImportDeclaration[]; // aliases that need to have this symbol visible }