function checkGrammarNumericLiteral(node: NumericLiteral): boolean {

// Grammar checking

let diagnosticMessage: DiagnosticMessage | undefined;

if (languageVersion >= ScriptTarget.ES5) {

diagnosticMessage = Diagnostics.Octal_literals_are_not_available_when_targeting_ECMAScript_5_and_higher_Use_the_syntax_0;

return /^\.\.?($|[\\/])/.test(moduleName);

}

return compilerOptions.target || ScriptTarget.ES3;

}

} = handlers;

const newLine = getNewLineCharacter(printerOptions);

const comments = createCommentWriter(printerOptions, onEmitSourceMapOfPosition);

const {

emitNodeWithComments,

}

const preferNewLine = node.multiLine ? ListFormat.PreferNewLine : ListFormat.None;

emitList(node, properties, ListFormat.ObjectLiteralExpressionProperties | allowTrailingComma | preferNewLine);

if (indentedFlag) {

// 1..toString is a valid property access, emit a dot after the literal

// Also emit a dot if expression is a integer const enum value - it will appear in generated code as numeric literal

function needsDotDotForPropertyAccess(expression: Expression) {

// check if numeric literal is a decimal literal that was originally written with a dot

const text = getLiteralTextOfNode(<LiteralExpression>expression);

&& text.indexOf(tokenToString(SyntaxKind.DotToken)) < 0;

}

else if (isPropertyAccessExpression(expression) || isElementAccessExpression(expression)) {

}

}

}

/**

export function parenthesizeForAccess(expression: Expression): LeftHandSideExpression {

// isLeftHandSideExpression is almost the correct criterion for when it is not necessary

//

// NewExpression:

// new C.x -> not the same as (new C).x

//

const emittedExpression = skipPartiallyEmittedExpressions(expression);

if (isLeftHandSideExpression(emittedExpression)

return <LeftHandSideExpression>expression;

}

node.isUnterminated = true;

}

// Octal literals are not allowed in strict mode or ES5

// Note that theoretically the following condition would hold true literals like 009,

// which is not octal.But because of how the scanner separates the tokens, we would

// never get a token like this. Instead, we would get 00 and 9 as two separate tokens.

// We also do not need to check for negatives because any prefix operator would be part of a

// parent unary expression.

}

return node;

}

isIdentifier(): boolean;

isReservedWord(): boolean;

isUnterminated(): boolean;

reScanGreaterToken(): SyntaxKind;

reScanSlashToken(): SyntaxKind;

reScanTemplateToken(): SyntaxKind;

let precedingLineBreak: boolean;

let hasExtendedUnicodeEscape: boolean;

let tokenIsUnterminated: boolean;

setText(text, start, length);

isIdentifier: () => token === SyntaxKind.Identifier || token > SyntaxKind.LastReservedWord,

isReservedWord: () => token >= SyntaxKind.FirstReservedWord && token <= SyntaxKind.LastReservedWord,

isUnterminated: () => tokenIsUnterminated,

reScanGreaterToken,

reScanSlashToken,

reScanTemplateToken,

let end = pos;

if (text.charCodeAt(pos) === CharacterCodes.E || text.charCodeAt(pos) === CharacterCodes.e) {

pos++;

if (text.charCodeAt(pos) === CharacterCodes.plus || text.charCodeAt(pos) === CharacterCodes.minus) pos++;

if (isDigit(text.charCodeAt(pos))) {

pos++;

hasExtendedUnicodeEscape = false;

precedingLineBreak = false;

tokenIsUnterminated = false;

while (true) {

tokenPos = pos;

if (pos >= end) {

value = 0;

}

tokenValue = "" + value;

return token = SyntaxKind.NumericLiteral;

}

else if (pos + 2 < end && (text.charCodeAt(pos + 1) === CharacterCodes.B || text.charCodeAt(pos + 1) === CharacterCodes.b)) {

value = 0;

}

tokenValue = "" + value;

return token = SyntaxKind.NumericLiteral;

}

else if (pos + 2 < end && (text.charCodeAt(pos + 1) === CharacterCodes.O || text.charCodeAt(pos + 1) === CharacterCodes.o)) {

value = 0;

}

tokenValue = "" + value;

return token = SyntaxKind.NumericLiteral;

}

// Try to parse as an octal

if (pos + 1 < end && isOctalDigit(text.charCodeAt(pos + 1))) {

tokenValue = "" + scanOctalDigits();

return token = SyntaxKind.NumericLiteral;

}

// This fall-through is a deviation from the EcmaScript grammar. The grammar says that a leading zero

case SyntaxKind.TemplateTail:

return visitTemplateLiteral(<LiteralExpression>node);

case SyntaxKind.TaggedTemplateExpression:

return visitTaggedTemplateExpression(<TaggedTemplateExpression>node);

return setTextRange(createLiteral(node.text), node);

}

/**

text: string;

isUnterminated?: boolean;

hasExtendedUnicodeEscape?: boolean;

}

// The text property of a LiteralExpression stores the interpreted value of the literal in text form. For a StringLiteral,

kind: SyntaxKind.NoSubstitutionTemplateLiteral;

}

export interface NumericLiteral extends LiteralExpression {

kind: SyntaxKind.NumericLiteral;

}

export interface TemplateHead extends LiteralLikeNode {

}

export interface PrinterOptions {

removeComments?: boolean;

newLine?: NewLineKind;

/*@internal*/ sourceMap?: boolean;

return getSourceTextOfNodeFromSourceFile(getSourceFileOfNode(node), node, includeTrivia);

}

// If we don't need to downlevel and we can reach the original source text using

// the node's parent reference, then simply get the text as it was originally written.

if (!nodeIsSynthesized(node) && node.parent) {

}

// If we can't reach the original source text, use the canonical form if it's a number,

Debug.fail(`Literal kind '${node.kind}' not accounted for.`);

}

function getQuotedEscapedLiteralText(leftQuote: string, text: string, rightQuote: string) {

return leftQuote + escapeNonAsciiCharacters(escapeString(text)) + rightQuote;

}

return false;

}

export function isStringOrNumericLiteral(node: Node): node is StringLiteral | NumericLiteral {

const kind = node.kind;

return kind === SyntaxKind.StringLiteral